> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bettertoken.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Nano Banana API: चित्र बनाना, संदर्भ और लगातार संपादन

> BetterToken पर Nano Banana Pro, 2 और 2.1 जोड़ें: प्रमाणीकरण, रिज़ॉल्यूशन, Python उदाहरण, संदर्भ चित्र, परिणाम सहेजना, लगातार संपादन और API पैरामीटर सीमाएँ।

एक ही Gemini native endpoint से टेक्स्ट चित्र, संदर्भ संपादन और आगे के संपादन करें। उदाहरण `nano-banana-2.1` उपयोग करते हैं; अन्य दोनों के लिए URL या SDK का मॉडल ID बदलें।

* [Gemini टेक्स्ट से चित्र API](/hi/api-reference/gemini-images-generations)
* [Gemini चित्र संपादन API](/hi/api-reference/gemini-images-edits)

<Warning>
  BetterToken API खोज की मदद से चित्र बनाना समर्थित नहीं करता, जिसमें Google वेब खोज और चित्र खोज grounding शामिल हैं। खोज टूल न जोड़ें।
</Warning>

## कनेक्शन जानकारी

| फ़ील्ड | मान |
| - | - |
| Base URL | `https://bettertoken.ai` |
| अनुरोध | `POST /v1beta/models/{model}:generateContent` |
| प्रमाणीकरण | `x-goog-api-key: YOUR_API_KEY` या `Authorization: Bearer YOUR_API_KEY` में से एक चुनें। |
| बॉडी | `application/json` |
| Model ID | `nano-banana-pro`, `nano-banana-2`, `nano-banana-2.1` |

<a href={"https://bettertoken.ai/register"}>BetterToken API Key बनाएं</a> · <a href={"https://bettertoken.ai/pricing"}>मॉडल कैटलॉग</a> · [Nano Banana मॉडल परिचय](/hi/model-updates/nano-banana)

<Warning>
  ये तीनों मॉडल `POST /v1/images/generations` और `POST /v1/images/edits` स्वीकार नहीं करते; `400 unsupported_endpoint` लौटता है। GPT Image के multipart, `image[]` या `data[].b64_json` उदाहरण न अपनाएं।
</Warning>

## पहला चित्र बनाएं

टर्मिनल में `BETTERTOKEN_API_KEY` सेट करके अनुरोध चलाएं। यह निर्माण पूरा होने तक इंतज़ार करता है और पूरा JSON `response.json` में सहेजता है।

<Tabs>
  <Tab title="macOS / Linux">
    ```bash theme={null}
    export BETTERTOKEN_API_KEY="YOUR_API_KEY"

    curl --fail-with-body --max-time 650 \
      "https://bettertoken.ai/v1beta/models/nano-banana-2.1:generateContent" \
      -H "x-goog-api-key: $BETTERTOKEN_API_KEY" \
      -H "Content-Type: application/json" \
      -H "X-BetterToken-Max-Images: 1" \
      -d '{
        "contents": [{
          "role": "user",
          "parts": [{"text": "सफेद मेज पर नीले सिरेमिक मग की स्टूडियो उत्पाद तस्वीर।"}]
        }],
        "generationConfig": {
          "responseModalities": ["IMAGE"],
          "candidateCount": 1,
          "imageConfig": {"imageSize": "1K", "aspectRatio": "1:1"}
        }
      }' -o response.json
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell theme={null}
    $env:BETTERTOKEN_API_KEY = "YOUR_API_KEY"
    $headers = @{
        "x-goog-api-key" = $env:BETTERTOKEN_API_KEY
        "X-BetterToken-Max-Images" = "1"
    }
    $body = @{
        contents = @(@{
            role = "user"
            parts = @(@{ text = "सफेद मेज पर नीले सिरेमिक मग की स्टूडियो उत्पाद तस्वीर।" })
        })
        generationConfig = @{
            responseModalities = @("IMAGE")
            candidateCount = 1
            imageConfig = @{ imageSize = "1K"; aspectRatio = "1:1" }
        }
    } | ConvertTo-Json -Depth 10
    Invoke-WebRequest `
        -Uri "https://bettertoken.ai/v1beta/models/nano-banana-2.1:generateContent" `
        -Method Post `
        -Headers $headers `
        -ContentType "application/json" `
        -Body ([System.Text.Encoding]::UTF8.GetBytes($body)) `
        -TimeoutSec 650 `
        -OutFile "response.json"
    ```
  </Tab>
</Tabs>

बड़े रिज़ॉल्यूशन के लिए `imageSize` को `2K` या `4K` करें। पहले `1K`, `1:1` और एक चित्र से शुरू करें। `--retry` से स्वचालित दोबारा अनुरोध न जोड़ें।

## सामान्य पैरामीटर

उत्पाद फ़ोटो के लिए विषय, सामग्री, रोशनी और पृष्ठभूमि बताएं। पोस्टर के लिए सटीक टेक्स्ट और लेआउट दें। संपादन में क्या बदलना और क्या रखना है बताएं।

Native HTTP में नीचे के फ़ील्ड और Python SDK में snake\_case उपयोग होता है। चित्र सेटिंग `generationConfig.imageConfig` के अंदर रखें।

| फ़ील्ड | मान |
| - | - |
| `contents[].parts[].text` | विषय, पृष्ठभूमि, शैली और बदलाव लिखें। |
| `contents[].parts[].inlineData` | मूल संदर्भ फ़ाइल का `mimeType` और base64, चित्र URL नहीं। |
| `generationConfig.responseModalities` | स्पष्ट रूप से `["IMAGE"]` सेट करें। |
| `generationConfig.imageConfig.imageSize` | बड़े अक्षरों में `1K`, `2K`, `4K`; डिफ़ॉल्ट `1K`। |
| `generationConfig.imageConfig.aspectRatio` | नीचे की तालिका से मॉडल का अनुपात चुनें; उदाहरण `1:1` उपयोग करते हैं। |
| `generationConfig.candidateCount` | छोड़ें या पूर्णांक `1` दें; native root में `n` न दें। |
| `X-BetterToken-Max-Images` | वैकल्पिक header: पूर्णांक `1` से `4`, डिफ़ॉल्ट `1`। प्राप्ति और भुगतान के लिए अधिकतम अनुमत चित्र। |

<span id="aspect-ratios" />

### Google के समर्थित अनुपात

Nano Banana 2 और 2.1 में 14 अनुपात और Pro में 10 समर्थित हैं। पहले अनुरोध में `1:1` से शुरू करें।

| मॉडल | रिज़ॉल्यूशन | अनुपात |
| - | - | - |
| `nano-banana-pro` | `1K`, `2K`, `4K` | `1:1`, `2:3`, `3:2`, `3:4`, `4:3`, `4:5`, `5:4`, `9:16`, `16:9`, `21:9` |
| `nano-banana-2` | `1K`, `2K`, `4K` | `1:1`, `1:4`, `1:8`, `2:3`, `3:2`, `3:4`, `4:1`, `4:3`, `4:5`, `5:4`, `8:1`, `9:16`, `16:9`, `21:9` |
| `nano-banana-2.1` | `1K`, `2K`, `4K` | `1:1`, `1:4`, `1:8`, `2:3`, `3:2`, `3:4`, `4:1`, `4:3`, `4:5`, `5:4`, `8:1`, `9:16`, `16:9`, `21:9` |

[Google अनुपात और चित्र आकार संदर्भ](https://ai.google.dev/gemini-api/docs/image-generation#aspect-ratios-and-image-size)

यह अधिकतम संख्या की गारंटी नहीं है। कई चित्र मांगने पर भी एक मिल सकता है। निश्चित संख्या के लिए अलग-अलग अनुरोध भेजें।

## प्रतिक्रिया पढ़ें और चित्र सहेजें

चित्र `candidates[].content.parts[].inlineData` में होते हैं। नीचे की संरचना में `BASE64_IMAGE_DATA` केवल placeholder है। सभी अंतिम चित्र parts पढ़ें और `thought: true` वाले भाग छोड़ें।

```json theme={null}
{
  "candidates": [{
    "content": {
      "role": "model",
      "parts": [{
        "inlineData": {
          "mimeType": "image/jpeg",
          "data": "BASE64_IMAGE_DATA"
        }
      }]
    },
    "finishReason": "STOP"
  }]
}
```

यह Python, curl का परिणाम सहेजता है। `mimeType` से extension चुनें; चित्र JPEG हो सकता है, हमेशा `.png` नहीं।

```python theme={null}
import base64
import json
from pathlib import Path

suffixes = {"image/png": ".png", "image/jpeg": ".jpg"}
result = json.loads(Path("response.json").read_text())
saved = 0
for candidate in result.get("candidates", []):
    for part in candidate.get("content", {}).get("parts", []):
        if part.get("thought"):
            continue
        blob = part.get("inlineData")
        if not blob:
            continue
        suffix = suffixes.get(blob["mimeType"])
        if suffix is None:
            raise ValueError("Unexpected image MIME type: " + blob["mimeType"])
        saved += 1
        Path(f"generated-{saved}{suffix}").write_bytes(
            base64.b64decode(blob["data"], validate=True)
        )
if saved == 0:
    raise RuntimeError("No final image returned; inspect response.json.")
```

## पूरा Python SDK उदाहरण

Python 3.10 या नया और `google-genai==2.30.1` उपयोग करें। प्रोजेक्ट virtual environment में इंस्टॉल करें; पुराने SDK `image_size` भेजना छोड़ सकते हैं।

```bash theme={null}
python -m pip install "google-genai==2.30.1"
```

SDK Base URL डोमेन root है, `/v1` या `/v1beta` नहीं जोड़ें। `timeout` मिलीसेकंड में है और `attempts=1` स्वचालित retry बंद करता है। `save_images` सभी अंतिम चित्र सहेजता है।

```python theme={null}
import os
from pathlib import Path
from google import genai
from google.genai import types

MODEL = "nano-banana-2.1"
client = genai.Client(
    vertexai=False,
    api_key=os.environ["BETTERTOKEN_API_KEY"],
    http_options=types.HttpOptions(
        base_url="https://bettertoken.ai",
        api_version="v1beta",
        timeout=650_000,
        retry_options=types.HttpRetryOptions(attempts=1),
        headers={"X-BetterToken-Max-Images": "1"},
    ),
)
config = types.GenerateContentConfig(
    response_modalities=["IMAGE"],
    candidate_count=1,
    image_config=types.ImageConfig(image_size="1K", aspect_ratio="1:1"),
)

def save_images(response, prefix):
    if len(response.candidates or []) != 1 or not response.candidates[0].content:
        raise RuntimeError("No single image candidate returned.")
    saved = 0
    suffixes = {"image/png": ".png", "image/jpeg": ".jpg"}
    for part in response.candidates[0].content.parts or []:
        if part.thought or not part.inline_data:
            continue
        blob = part.inline_data
        suffix = suffixes.get(blob.mime_type)
        if suffix is None:
            raise ValueError("Unexpected image MIME type: " + str(blob.mime_type))
        saved += 1
        Path(f"{prefix}-{saved}{suffix}").write_bytes(blob.data)
    if saved == 0:
        raise RuntimeError("No final image returned; inspect the response.")

first_turn = types.Content(
    role="user",
    parts=[types.Part(text="सफेद मेज पर नीले सिरेमिक मग की स्टूडियो उत्पाद तस्वीर।")],
)
response = client.models.generate_content(
    model=MODEL, contents=[first_turn], config=config,
)
save_images(response, "generated")
```

## संदर्भ चित्र भेजें

Python उदाहरण के बाद चलाने पर नया संपादन अनुरोध भेजता है। `reference.jpg` को अपनी फ़ाइल से बदलें। PNG के लिए `mime_type="image/png"` दें। अधिक संदर्भ उसी user संदेश के `parts` में जोड़ें।

```python theme={null}
first_turn = types.Content(
    role="user",
    parts=[
        types.Part(text="मग को लाल करें। उसका आकार और पृष्ठभूमि बनाए रखें।"),
        types.Part.from_bytes(
            data=Path("reference.jpg").read_bytes(),
            mime_type="image/jpeg",
        ),
    ],
)
response = client.models.generate_content(
    model=MODEL, contents=[first_turn], config=config,
)
save_images(response, "reference-edit")
```

Native JSON में `inlineData: {"mimeType": "image/jpeg", "data": "BASE64_IMAGE_DATA"}` दें। मूल bytes का base64 बनाएं; `data:image/...;base64,` prefix न दें। multipart, Files या `fileData` उपयोग नहीं होता।

## आगे संपादन करें

सफल निर्माण या संदर्भ संपादन के बाद चलाएं। मॉडल का पूरा `content`, parts का क्रम और `thoughtSignature` रखें। केवल चित्र से इतिहास न बनाएं और हस्ताक्षर न गढ़ें या बदलें।

```python theme={null}
history = [first_turn, response.candidates[0].content]
edit_turn = types.Content(
    role="user",
    parts=[types.Part(text="एक छोटा सुनहरा हैंडल जोड़ें। बाकी सब वैसा ही रखें।")],
)
edited = client.models.generate_content(
    model=MODEL, contents=[*history, edit_turn], config=config,
)
save_images(edited, "follow-up")
history.extend([edit_turn, edited.candidates[0].content])
```

हर चरण नया निर्माण अनुरोध है। पूरा `history` रखें, नया user निर्देश और फिर मॉडल का `content` जोड़ें। यहां Interactions का `previous_interaction_id` न दें।

## API का समर्थन

* बिना streaming वाला `generateContent` उपयोग करें। इस कनेक्शन में Files / `fileData`, Batch, Interactions और streaming समर्थित नहीं हैं।
* `responseMimeType`, `responseSchema` और कस्टम चित्र compression format समर्थित नहीं हैं। `imageConfig` में केवल ऊपर दिए दो फ़ील्ड उपयोग करें।
* `cachedContent`, function calling, code execution, फ़ाइल खोज, Maps, URL context और ऑडियो इनपुट या निर्माण की सेटिंग न जोड़ें।

## मौजूदा OpenAI Chat क्लाइंट

`POST /v1/chat/completions` और Base URL `https://bettertoken.ai/v1` उपयोग कर सकते हैं। नए कनेक्शन, संदर्भ और लगातार संपादन के लिए ऊपर दिया Gemini native API उपयोग करें। Chat में `n` छोड़ें या पूर्णांक `1` दें।

HTTP में `google.image_config` JSON root पर रखें। Python OpenAI SDK में `extra_body` दें, जिसे SDK root में जोड़ता है। यहां `generationConfig` न दें।

```bash theme={null}
curl --fail-with-body --max-time 650 \
  "https://bettertoken.ai/v1/chat/completions" \
  -H "Authorization: Bearer $BETTERTOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-BetterToken-Max-Images: 1" \
  -d '{
    "model": "nano-banana-2.1",
    "messages": [{"role": "user", "content": "सफेद मेज पर नीला सिरेमिक मग।"}],
    "n": 1,
    "stream": false,
    "google": {"image_config": {"image_size": "1K", "aspect_ratio": "1:1"}}
  }'
```

Python OpenAI SDK उदाहरण के लिए उसी virtual environment में `openai==1.66.2` इंस्टॉल करें:

```python theme={null}
import base64
import os
import re
from pathlib import Path
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BETTERTOKEN_API_KEY"],
    base_url="https://bettertoken.ai/v1",
    max_retries=0,
    timeout=650,
)
response = client.chat.completions.create(
    model="nano-banana-2.1",
    messages=[{"role": "user", "content": "सफेद मेज पर नीला सिरेमिक मग।"}],
    n=1,
    stream=False,
    extra_headers={"X-BetterToken-Max-Images": "1"},
    extra_body={
        "google": {"image_config": {"image_size": "1K", "aspect_ratio": "1:1"}}
    },
)
content = response.choices[0].message.content or ""
images = re.findall(r"data:(image/(?:png|jpeg));base64,([A-Za-z0-9+/=]+)", content)
if not images:
    raise RuntimeError("No inline image in Chat response.")
for index, (mime, data) in enumerate(images, 1):
    suffix = ".png" if mime == "image/png" else ".jpg"
    Path(f"chat-{index}{suffix}").write_bytes(base64.b64decode(data, validate=True))
```

Chat चित्र `choices[0].message.content` में Markdown Data URL होते हैं, Images API के `data[]` में नहीं। इस टेक्स्ट से हस्ताक्षर इतिहास न बनाएं; native संपादन उपयोग करें।

## सामान्य त्रुटियां

| समस्या | कार्रवाई |
| - | - |
| `401` / गलत Key | Google नहीं, BetterToken API Key उपयोग करें; variable और header जांचें। |
| `404` / URL | Base URL root, `api_version="v1beta"` और तीन सार्वजनिक Model ID में से एक दें। |
| `400 unsupported_endpoint` | `/v1/images/*` की जगह `:generateContent` दें। |
| `400` / पैरामीटर | फ़ील्ड का स्तर, `1K/2K/4K` के बड़े अक्षर और चुने मॉडल के अनुपात जांचें। `candidateCount` छोड़ें या पूर्णांक `1` दें; खोज टूल न जोड़ें। |
| अंतिम चित्र नहीं | पूरी प्रतिक्रिया में त्रुटि, सुरक्षा, टेक्स्ट और `finishReason` जांचें। thought चित्र अंतिम नहीं हैं। |
| फ़ाइल नहीं खुलती | base64 decode और MIME extension उपयोग करें; पूरा JSON या Markdown चित्र के रूप में न सहेजें। |
| Timeout या कनेक्शन टूटा | उपयोग रिकॉर्ड और response request ID रखें। दोबारा अनुरोध से पहले support से परिणाम जांचें ताकि दोहरी generation और शुल्क न हो। |

चित्र वर्तमान प्रतिक्रिया में मिलता है। इस कार्यप्रवाह में बाद में चित्र प्राप्त करने या task polling का endpoint नहीं है। परिणाम तुरंत सहेजें, SDK और proxy में पर्याप्त समय रखें और स्वचालित retry बंद करें।

## आधिकारिक स्रोत

* [Nano Banana Pro मॉडल](https://ai.google.dev/gemini-api/docs/models/gemini-3-pro-image)
* [Nano Banana 2 मॉडल](https://ai.google.dev/gemini-api/docs/models/gemini-3.1-flash-image)
* [Nano Banana 2.1 मॉडल](https://ai.google.dev/gemini-api/docs/models/gemini-nano-banana-2.1)
* [Google चित्र निर्माण गाइड](https://ai.google.dev/gemini-api/docs/generate-content/image-generation)
* [Google रिलीज़ नोट्स](https://ai.google.dev/gemini-api/docs/changelog)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.