Nano Banana Pro API: कीमत, Python उदाहरण और Endpoint

अगर आप Nano Banana Pro को किसी ऐप में जोड़ने वाले हैं, तो कोड लिखने से पहले तीन सवाल सामने आते हैं: एक इमेज की लागत कितनी है, आप कौन-सा endpoint कॉल करते हैं, और एक काम करने वाली Python स्क्रिप्ट कैसी दिखती है? यह लेख इन तीनों का जवाब देता है। आँकड़े Google के अपने प्राइसिंग पेज से लिए गए हैं, रिक्वेस्ट टर्मिनल में सीधे चिपकाने लायक तैयार हैं, और बजट टेबल दिखाती हैं कि रीट्राई गिनने के बाद एक हज़ार इमेज असल में कितनी पड़ती हैं। Nano Banana Pro 1K, 2K या 4K पर रेंडर होता है और हर रिक्वेस्ट में 14 रेफ़रेंस इमेज तक स्वीकार करता है। API के ज़रिए इस तक पहुँचने में लगभग पंद्रह मिनट लगते हैं। बिल को अनुमान लगाने योग्य रखने में थोड़ा ज़्यादा सोचना पड़ता है, इसलिए यह लेख ज़्यादातर उसी पर है।

💡 संक्षिप्त जवाब: Google $0.134 प्रति 1K या 2K इमेज और $0.24 प्रति 4K इमेज की सूची देता है। बैच मोड दोनों को आधा कर देता है। Replicate और fal.ai पर लगभग $0.18 प्रति इमेज बताया गया है। बजट तय करने से पहले मौजूदा दरें जाँच लें, क्योंकि प्रोवाइडर इन्हें बदलते रहते हैं।

API असल में क्या है

Nano Banana Pro सार्वजनिक नाम है। Google के डेवलपर डॉक्यूमेंटेशन में इस मॉडल को Gemini 3 Pro Image कहा गया है, और Gemini API कोड सैंपल में जो identifier आप पास करते हैं वह gemini-3-pro-image-preview है। Replicate इसी मॉडल को google/nano-banana-pro के रूप में होस्ट करता है। एक ही मॉडल फ़ैमिली के तीन नाम हैं, और यह गड़बड़ी लगभग हर किसी को पहली दोपहर में उलझा देती है।

API तब काम की होती है जब इमेज कोई इंसान नहीं, बल्कि सॉफ़्टवेयर बनाए: एक स्टोर जो हर नए प्रोडक्ट के लिए लाइफ़स्टाइल शॉट रेंडर करे, एक न्यूज़लेटर जिसे हर सुबह हेडर चाहिए, या एक ऐप जो यूज़र्स को उनकी अपनी फ़ोटो को नए स्टाइल में बदलने देता है। कुछ गिनी-चुनी एक-बार वाली इमेज के लिए ब्राउज़र तेज़ है और इंजीनियरिंग समय भी नहीं लगता।

एक मॉडल, कई नाम

एक रिक्वेस्ट क्या कर सकती है

हर रिक्वेस्ट में ये नियंत्रण एक साथ जोड़े जा सकते हैं:

• रिज़ॉल्यूशन: 1K, 2K या 4K आउटपुट।
• रेफ़रेंस इमेज: स्टाइल, सब्जेक्ट या कंपोज़िशन को दिशा देने के लिए प्रॉम्प्ट के साथ 14 तक इमेज भेजी जा सकती हैं।
• आस्पेक्ट रेशियो: 1:1, 4:3, 3:2, 16:9, 9:16 और 21:9 जैसे प्रीसेट।
• आउटपुट फ़ॉर्मेट: Replicate स्कीमा के अनुसार JPG या PNG।
• सेफ़्टी फ़िल्टर लेवल: तीन सेटिंग्स हैं, सबसे सख्त से सबसे कम पाबंदी वाली तक। कुछ प्रॉम्प्ट सबसे कम पाबंदी वाली सेटिंग पर भी ब्लॉक हो जाते हैं।

Nano Banana Pro API प्राइसिंग

कीमतों में प्रोवाइडर सबसे ज़्यादा अलग हैं, इसलिए आँकड़े एक-एक स्रोत के हिसाब से दिए गए हैं।

Google की आधिकारिक दरें

प्रॉम्प्ट का टेक्स्ट अलग से बिल होता है, $2.00 प्रति दस लाख इनपुट टोकन की दर से। इसलिए 150 टोकन वाला प्रॉम्प्ट लगभग $0.0003 पड़ता है, जो इमेज के खर्च के सामने नगण्य है। असली खर्च आउटपुट इमेज का है, और रिज़ॉल्यूशन वह सबसे बड़ा लीवर है जिसे आप नियंत्रित करते हैं: 4K रेंडर एक 2K रेंडर से लगभग 79 प्रतिशत ज़्यादा लागत का होता है।

चूँकि 1K और 2K की कीमत एक जैसी है, नियम सीधा है। 1K ड्राफ़्ट, थंबनेल और प्रॉम्प्ट टेस्टिंग के लिए इस्तेमाल करें, जहाँ पिक्सल से ज़्यादा स्पीड मायने रखती है। ब्लॉग हेडर और वेब पेज के लिए 2K लें, क्योंकि अतिरिक्त डिटेल के लिए आपको कुछ ज़्यादा नहीं देना पड़ता। 4K को प्रिंट, बड़े डिस्प्ले या उन इमेज के लिए रखें जिन्हें आप बहुत ज़्यादा क्रॉप करने वाले हैं, क्योंकि सिर्फ़ यही स्तर है जहाँ कीमत सच में बदलती है।

💡 मॉडल के identifier में अब भी शब्द "preview" है। Google preview मॉडलों के नाम, लिमिट और कीमतें बदल सकता है, इसलिए लॉन्च की योजना जिस दिन बनाएँ उस दिन प्राइसिंग पेज पढ़ लें।

बैच प्राइसिंग से बिल आधा हो जाता है

बैच जॉब्स स्टैंडर्ड दर से ठीक आधी कीमत पर चलते हैं: 1K या 2K पर $0.134 की जगह $0.067, और 4K पर $0.24 की जगह $0.12। इसके बदले में आप स्पीड खोते हैं। आप रिक्वेस्ट की एक फ़ाइल जमा करते हैं, Google जब क्षमता मिलती है तब उसे प्रोसेस करता है, और आप नतीजे बाद में ले लेते हैं। यह कैटलॉग, रात के रिफ़्रेश और आर्काइव के काम के लिए ठीक है। यह उस बटन के लिए ठीक नहीं जिसका ग्राहक इंतज़ार कर रहा हो।

एक उदाहरण से फ़र्क साफ़ होता है। 2K पर 2,000 प्रोडक्ट शॉट रेंडर करने में स्टैंडर्ड टियर पर $268.00 लगते हैं और बैच में $134.00। वही मॉडल, वही आउटपुट, इंतज़ार करने के बदले $134.00 की बचत।

Replicate और fal.ai के मार्कअप

थर्ड-पार्टी प्राइस ट्रैकर बताते हैं कि Replicate और fal.ai दोनों पर लगभग $0.18 प्रति इमेज है। Google के $0.134 के मुकाबले यह प्रति इमेज लगभग 34 प्रतिशत ज़्यादा है। यह कीमत आप सुविधा के लिए चुकाते हैं: कोई Google Cloud प्रोजेक्ट नहीं, सैकड़ों मॉडलों के लिए एक टोकन, और एक एकसमान predictions API। बजट बनाने से पहले हर प्लेटफ़ॉर्म पर मॉडल पेज जाँच लें, क्योंकि ऊपर के सिर्फ़ Google के आँकड़े सीधे विक्रेता के अपने पेज से लिए गए हैं।

मासिक बजट कैसे दिखते हैं

तीन वास्तविक परिदृश्य

ये पंक्तियाँ Google की सूची-कीमतें इस्तेमाल करती हैं।

स्टूडियो वाली दो पंक्तियाँ सबसे ज़्यादा सिखाने वाली हैं। रात की कतार आधी लागत पर चलती है, इसलिए सवाल सिर्फ़ इतना है कि क्या किसी को पोस्टर अभी इसी मिनट चाहिए।

अपने प्रोजेक्ट की कीमत निकालने के लिए प्रति माह अपेक्षित इमेज को अपने टियर की दर से गुणा करें, फिर उसे रखने की दर (keep rate) से भाग दें। जो शॉप हर पाँच में से 4 रेंडर रखने की उम्मीद करती है और उसे 1,000 काम की 2K इमेज चाहिए, उसे 1,250 रेंडर का बजट बनाना चाहिए, यानी स्टैंडर्ड दर पर लगभग $167.50।

रीट्राई एक छिपी लागत जोड़ते हैं

कोई भी हर रेंडर नहीं रखता। अगर आप हर पाँच में से चार इमेज रखते हैं, तो हर रखी गई इमेज की लागत 2K पर $0.134 ÷ 0.8 = $0.1675 और 4K पर $0.30 पड़ती है। ज़्यादातर रीट्राई अस्पष्ट प्रॉम्प्ट से आते हैं, ब्लॉक हुई इमेज से कम, इसलिए सबसे सस्ता इलाज बड़ा बजट नहीं बल्कि बेहतर लिखना है। तीन आदतें यह संख्या घटाती हैं:

• 1K से पहले टेस्ट करें। नतीजे तेज़ लौटते हैं, और आप सिर्फ़ विजेता इमेज को 4K पर दोबारा चलाते हैं।
• रिक्वेस्ट के हिसाब से कैश करें। प्रॉम्प्ट और पैरामीटर का हैश बनाएँ, ताकि एक जैसी कॉल दोबारा बिल न हो।
• हर कॉल लॉग करें। हर प्रोजेक्ट का चालू लागत-योग रखने से बेकाबू लूप इनवॉइस आने से पहले पकड़ में आ जाता है।

Endpoint, चरण दर चरण

Google का Gemini API endpoint

REST रूट Google के मानक पैटर्न का पालन करता है:

POST https://generativelanguage.googleapis.com/v1beta/models/gemini-3-pro-image-preview:generateContent

प्रॉम्प्ट कॉपी करें

Google AI Studio में बनाई गई क्रेडेंशियल से ऑथेंटिकेट करें, जिसे Gemini API रेफ़रेंस में बताए अनुसार एक रिक्वेस्ट हेडर में भेजा जाता है। बॉडी में प्रॉम्प्ट और एक इमेज कॉन्फ़िगरेशन होता है:

{
  "contents": [{"parts": [{"text": "A ceramic mug on a walnut desk at sunrise, 85mm lens, soft window light"}]}],
  "generationConfig": {
    "responseModalities": ["TEXT", "IMAGE"],
    "imageConfig": {"aspectRatio": "16:9", "imageSize": "2K"}
  }
}

प्रॉम्प्ट कॉपी करें

जवाब image part के अंदर base64 टेक्स्ट के रूप में आता है, इसलिए फ़ाइल लिखने से पहले उसे decode करें। Google के मौजूदा डॉक्स एक नई interactions-style कॉल भी दिखाते हैं, जिसके मॉडल नाम से "preview" सफ़िक्स हट जाता है। इस फ़ैमिली के नाम पहले भी बदल चुके हैं, इसलिए शिप करने से पहले डॉक्स में सटीक स्ट्रिंग की पुष्टि कर लें।

Replicate का REST endpoint

Replicate हर मॉडल के लिए एक predictions रूट इस्तेमाल करता है:

curl -s -X POST \
  -H "Authorization: Bearer $REPLICATE_API_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Prefer: wait" \
  -d '{"input": {"prompt": "A ceramic mug on a walnut desk at sunrise, 85mm lens, soft window light", "aspect_ratio": "16:9", "resolution": "2K", "output_format": "jpg"}}' \
  https://api.replicate.com/v1/models/google/nano-banana-pro/predictions

प्रॉम्प्ट कॉपी करें

Prefer: wait हेडर कनेक्शन खुला रखता है ताकि सिंक्रोनस जवाब मिल सके। इसके बिना आपको एक prediction object मिलता है, और जब तक status succeeded न पढ़े, तब तक urls.get में दिए पते पर poll करते रहना होता है। पूरी हुई prediction का output फ़ील्ड इमेज URL रखता है। फ़ाइल डाउनलोड करें और उसे खुद स्टोर करें, उससे लिंक करके न छोड़ें।

चलने वाला Python उदाहरण

Gemini SDK वर्ज़न

पैकेज pip install google-genai pillow से इंस्टॉल करें, फिर चलाएँ:

from google import genai
from google.genai import types

client = genai.Client()  # reads your Gemini credential from the environment

response = client.models.generate_content(
    model="gemini-3-pro-image-preview",
    contents="A ceramic mug on a walnut desk at sunrise, 85mm lens, soft window light",
    config=types.GenerateContentConfig(
        response_modalities=["TEXT", "IMAGE"],
        image_config=types.ImageConfig(aspect_ratio="16:9", image_size="2K"),
    ),
)

for part in response.parts:
    if part.inline_data is not None:
        part.as_image().save("mug.png")
    elif part.text:
        print(part.text)

प्रॉम्प्ट कॉपी करें

Google के डॉक्स image_size में uppercase K माँगते हैं, इसलिए "2K" लिखें, "2k" नहीं। लूप भी मायने रखता है: मॉडल इमेज के साथ टेक्स्ट लौटा सकता है, और ब्लॉक हुआ प्रॉम्प्ट बिना किसी इमेज के सिर्फ़ टेक्स्ट लौटाता है।

Replicate क्लाइंट वर्ज़न

import replicate

output = replicate.run(
    "google/nano-banana-pro",
    input={
        "prompt": "A ceramic mug on a walnut desk at sunrise, 85mm lens, soft window light",
        "aspect_ratio": "16:9",
        "resolution": "2K",
        "output_format": "jpg",
        "safety_filter_level": "block_only_high",
    },
)

with open("mug.jpg", "wb") as f:
    f.write(output.read())

प्रॉम्प्ट कॉपी करें

इसे pip install replicate से इंस्टॉल करें और अपने environment में REPLICATE_API_TOKEN सेट करें। किसी मौजूदा फ़ोटो को एडिट करने के लिए image_input जोड़ें, जिसमें सार्वजनिक इमेज URL की सूची हो (14 तक), और प्रॉम्प्ट में बदलाव बताएँ:

input={
    "prompt": "Place the mug from the first image on the desk from the second image",
    "image_input": [
        "https://example.com/mug.jpg",
        "https://example.com/desk.jpg",
    ],
    "aspect_ratio": "match_input_image",
}

प्रॉम्प्ट कॉपी करें

तीन प्रोडक्शन बातें डीबगिंग का समय बचाती हैं:

• टाइमआउट: PicassoIA की इस मॉडल की उदाहरण गैलरी में 1K रेंडर के लिए लगभग 18 सेकंड और एक 2K रेंडर के लिए 113 सेकंड दिए गए हैं। क्लाइंट टाइमआउट कम से कम तीन मिनट पर सेट करें।
• रेट लिमिट: HTTP 429 जवाबों को exponential backoff के साथ रीट्राई करें, और प्रयासों की संख्या सीमित करें।
• लागत ट्रैकिंग: हर सफल कॉल के बाद सूची-कीमत जोड़ें।

PRICE = {"1K": 0.134, "2K": 0.134, "4K": 0.24}

def add_cost(total: float, resolution: str) -> float:
    return round(total + PRICE[resolution], 4)

प्रॉम्प्ट कॉपी करें

PicassoIA पर Nano Banana Pro इस्तेमाल करें

हर काम को कोड की ज़रूरत नहीं होती। PicassoIA पर Nano Banana Pro पेज इस मॉडल को ब्राउज़र में चलाता है, और पेज के अनुसार इसे बिना कोडिंग के मुफ़्त में आज़माया जा सकता है। PicassoIA api.picassoia.com/v1 पर एक डेवलपर API भी चलाता है, लेकिन वह PicassoIA Image और PicassoIA Image Editor Pro जैसे इन-हाउस मॉडल देता है, Nano Banana Pro नहीं। कोड के ज़रिए Nano Banana Pro के लिए, ऊपर दिखाए अनुसार Google या Replicate इस्तेमाल करें।

1. मॉडल पेज खोलें और प्रॉम्प्ट सादी भाषा में लिखें: सब्जेक्ट, लेंस, रोशनी और मूड।
2. आस्पेक्ट रेशियो चुनें। बैनर के लिए 16:9, स्टोरीज़ के लिए 9:16 और अवतार के लिए 1:1 इस्तेमाल करें।
3. रिज़ॉल्यूशन चुनें। 2K डिफ़ॉल्ट है, और 4K प्रिंट के लिए ठीक है।
4. रेफ़रेंस इमेज जोड़ें अगर आपके पास हैं, 14 तक।
5. JPG या PNG चुनें और सेफ़्टी फ़िल्टर लेवल सेट करें।
6. जनरेट करें, फिर कुछ शब्द बदलें और कोई एक रखने से पहले वेरिएशन की तुलना करें।

ज़रूरी सेटिंग्स

💡 डिफ़ॉल्ट आस्पेक्ट रेशियो के साथ आउटपुट आपकी पहली रेफ़रेंस इमेज के अनुपात से मेल खाता है। सिर्फ़ टेक्स्ट से जनरेट करते समय रेशियो खुद सेट करें।

कोड के बिना रेफ़रेंस इमेज

रेफ़रेंस इमेज ही वह फ़ीचर है जो इस मॉडल को सादे टेक्स्ट-टू-इमेज टूल से अलग करता है। इसमें एक प्रोडक्ट फ़ोटो, मूड बोर्ड या कोई चेहरा दें जिसे आप एकसमान रखना चाहते हैं, फिर एक वाक्य में बदलाव बताएँ। मॉडल विज़ुअल संदर्भ बनाए रखता है और आपका एडिट लागू करता है। वही 14-इमेज की सीमा ब्राउज़र और API दोनों में लागू होती है।

ज़्यादा रेफ़रेंस का मतलब हमेशा बेहतर नतीजे नहीं होते। दो या तीन से शुरू करें, प्रॉम्प्ट में हर एक की भूमिका बताएँ ("दूसरी इमेज की रोशनी इस्तेमाल करें"), और पूरे सेट में रोशनी एकसमान रखें। और तभी जोड़ें जब आउटपुट उस लुक से भटकने लगे जो आप चाहते हैं।

जब सस्ता मॉडल जीतता है

4K आउटपुट और भारी रेफ़रेंस वाले काम के लिए Nano Banana Pro सही चुनाव है। ड्राफ़्ट, थंबनेल और बल्क फ़िलर को शायद ही इतनी ऊँची सीमा चाहिए।

त्वरित मॉडल तुलना

लार्ज लैंग्वेज मॉडल (LLM) से प्रॉम्प्ट का ड्राफ़्ट

छोटा ब्रीफ़ धुंधली इमेज देता है, और धुंधली इमेज रीट्राई की ओर ले जाती है। पहले किसी लार्ज लैंग्वेज मॉडल (LLM) से ब्रीफ़ को विस्तार देने को कहें। Gemini 3.5 Flash बल्क काम के लिए काफ़ी तेज़ है, और Claude Sonnet 5 लंबे निर्देश अच्छे से संभालता है। एक उपयोगी निर्देश ऐसा दिखता है:

इस ब्रीफ़ को 60 शब्दों के एक इमेज प्रॉम्प्ट में दोबारा लिखें। सब्जेक्ट, कैमरा एंगल, लेंस, रोशनी की दिशा और एक सतह की बनावट का नाम दें। इमेज के अंदर कोई टेक्स्ट नहीं।

विस्तारित प्रॉम्प्ट को 1K पर चलाएँ, विजेता रखें, और तभी 4K के लिए पैसे दें। यही एक आदत, प्रॉम्प्ट के लिए लैंग्वेज मॉडल और टेस्ट के लिए सस्ता टियर, एक सामान्य महीने के ज़्यादातर बेकार रेंडर खत्म कर देती है।

आज अपनी पहली इमेज बनाएँ

अब आपके पास वे तीन चीज़ें हैं जिन्हें API पेज अक्सर छिपा देते हैं: दरें, endpoints और एक चलने वाली स्क्रिप्ट। यह जाँचने का सबसे तेज़ तरीका कि Nano Banana Pro आपके प्रोजेक्ट में फ़िट होता है या नहीं, एक पैसा खर्च करने से पहले दस मिनट इसके साथ बिताना है। Picasso IA पर Nano Banana Pro पेज खोलें, इस लेख से एक प्रॉम्प्ट चिपकाएँ, 1K और 4K के बीच स्विच करें, और एक-दो रेफ़रेंस इमेज जोड़ें। फिर जीतने वाला प्रॉम्प्ट अपनी Python स्क्रिप्ट में ले जाएँ। सेटिंग्स आज़माएँ, नतीजों की साथ-साथ तुलना करें, और कोड कहाँ जाए यह बजट टेबल तय करने दें।