Gemini इमेज API प्राइसिंग: रेट लिमिट, रिज़ॉल्यूशन और Python

एक Gemini इमेज की लागत लगभग तीन सेंट से चौबीस सेंट तक हो सकती है, और इन दोनों संख्याओं के बीच का फ़र्क ही वह जगह है जहाँ ज़्यादातर बजट बिगड़ता है। गलत मॉडल चुनें, ऐसे समय 4K माँगें जब 1K से काम चल जाए, या रात के जॉब में बैच मोड छोड़ दें, तो वही 10,000 इमेज आपको $336 या $2,400 में पड़ सकती हैं। यह लेख Google के प्राइसिंग और रेट लिमिट पेज के असली आँकड़े लेता है, उन्हें मासिक बिल में बदलता है, और अंत में ऐसा Python कोड देता है जिसे आप आज ही अपनी स्क्रिप्ट में डाल सकते हैं।

💡 स्रोत और तारीख: नीचे की हर कीमत Google के प्रकाशित Gemini API प्राइसिंग पेज से अक्टूबर 2026 में पढ़ी गई थी। Google इन दरों को बदलता रहता है, इसलिए बजट तय करने से पहले लाइव पेज ज़रूर जाँच लें।

चार मॉडल, चार कीमतें

Google अपनी नेटिव इमेज जनरेशन को Nano Banana नाम से बेचता है, और API में चार मॉडल उपलब्ध हैं। तीन वर्तमान हैं और एक लीगेसी। वर्तमान मॉडलों में से किसी का भी फ़्री टियर नहीं है, इसलिए आपकी पहली टेस्ट कॉल पर भी शुल्क लगेगा। हर आउटपुट में SynthID वॉटरमार्क भी होता है।

कौन-सा मॉडल किस काम का है

Nano Banana 2 Lite वॉल्यूम वाला विकल्प है। थंबनेल, प्रोडक्ट वैरिएशन और ड्राफ़्ट पास के लिए लगभग 3.4 सेंट प्रति इमेज, लेकिन एक शर्त है: यह केवल 1K आउटपुट देता है।

Nano Banana 2 प्रोडक्शन कार्य के लिए डिफ़ॉल्ट विकल्प है। यह 0.5K से 4K तक जाता है, Google Search ग्राउंडिंग को सपोर्ट करता है (इस मॉडल पर इमेज सर्च ग्राउंडिंग सहित), और 1K इमेज के लिए 6.7 सेंट लेता है।

Nano Banana Pro प्रीमियम विकल्प है, जिसे Google जटिल विज़ुअल कार्यों के लिए पेश करता है। यह 1K या 2K पर 13.4 सेंट लेता है, इसलिए इसे वहीं इस्तेमाल करें जहाँ सस्ते मॉडल पर एक बार दोबारा जनरेट करने में लगने वाला समय उस कीमत के फ़र्क से ज़्यादा महँगा पड़े।

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

लीगेसी मॉडल से आगे बढ़ना

Google के डॉक्स gemini-2.5-flash-image को सीरीज़ का लीगेसी पायनियर कहते हैं और बेहतर क्वालिटी, तेज़ जनरेशन और कम API कीमत के लिए Nano Banana 2 Lite पर स्विच करने की सलाह देते हैं। अगर आप इसे अब भी प्रोडक्शन में कॉल कर रहे हैं, तो पहले मॉडल ID बदलें और अपने कुछ प्रॉम्प्ट्स से दोबारा जाँच करें। कोड की एक लाइन बदलने से पहले आप PicassoIA पर आउटपुट साथ-साथ तुलना भी कर सकते हैं, जहाँ Gemini 2.5 Flash Image अब भी सूचीबद्ध है।

रिज़ॉल्यूशन के अनुसार प्रति इमेज प्राइसिंग

Google इमेज आउटपुट का बिल टोकन में बनाता है, लेकिन हर रिज़ॉल्यूशन के लिए एक फ़्लैट प्रति-इमेज कीमत भी प्रकाशित करता है, और बजट असल में इसी संख्या से बनाया जाता है।

स्टैंडर्ड दरें एक नज़र में

दो पैटर्न साफ़ दिखते हैं। Nano Banana 2 2K पर 1K से 1.5 गुना और 4K पर 2.25 गुना चार्ज करता है। Nano Banana Pro 1K और 2K की कीमत एक ही रखता है, इसलिए वहाँ 2K एक समझदार डिफ़ॉल्ट है, फिर 4K पर लगभग 79 प्रतिशत की छलांग लगती है।

इनपुट का भी बिल बनता है: Nano Banana 2 पर $0.50 प्रति मिलियन टोकन, Lite पर $0.25 और Pro पर $2.00। कुछ सौ टोकन का प्रॉम्प्ट एक सेंट के अंश भर जोड़ता है, इसलिए जब तक आप बहुत सारे रेफ़रेंस इमेज नहीं जोड़ते, बिल पर इमेज आउटपुट ही हावी रहता है।

बैच मोड से बिल आधा हो जाता है

बैच प्राइसिंग हर मॉडल पर स्टैंडर्ड की आधी है। Nano Banana 2 1K पर $0.034, 2K पर $0.050 और 4K पर $0.076 तक आ जाता है। Nano Banana Pro को भी 50 प्रतिशत की वही कटौती मिलती है। Nano Banana 2 Lite की आउटपुट दर $30 से घटकर प्रति मिलियन टोकन $15 रह जाती है, जो प्रति इमेज लगभग 1.7 सेंट है।

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

कीमत के पीछे टोकन का हिसाब

हर प्रति-इमेज कीमत को आउटपुट दर से भाग दें, तो प्रति इमेज टोकन की संख्या मिल जाती है। Nano Banana 2 के लिए $0.067 और प्रति मिलियन $60 पर, 1K इमेज लगभग 1,120 टोकन बनती है, 2K पर लगभग 1,680 और 4K पर लगभग 2,520। ये संख्याएँ Google की प्राइस टेबल से निकाली गई हैं, उसमें से सीधे उद्धृत नहीं की गईं, लेकिन ये प्राइसिंग का ढाँचा समझाती हैं।

Nano Banana Pro के लिए $0.134 और प्रति मिलियन $120 पर भी 1K पर लगभग 1,120 टोकन आते हैं, जबकि इसकी 4K कीमत $0.24 लगभग 2,000 टोकन बताती है। इसका मतलब है कि 4K पर प्रीमियम सिकुड़ जाता है: $0.24 बनाम $0.151 लगभग 1.6 गुना है, जबकि 1K पर ठीक 2 गुना।

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

रेट लिमिट, बिना अंदाज़े के

रेट लिमिट तय करती है कि आपकी पाइपलाइन सुचारू चलेगी या रात 2 बजे एररों की बौछार में अटक जाएगी। Gemini API इन्हें प्रोजेक्ट के स्तर पर लागू करता है, और कुछ बारीकियाँ आसानी से छूट जाती हैं।

RPM, IPM और RPD की व्याख्या

Google तीन पैमानों पर उपयोग को परखता है: प्रति मिनट रिक्वेस्ट (RPM), प्रति मिनट टोकन (TPM) और प्रति दिन रिक्वेस्ट (RPD)। इमेज मॉडलों के लिए डॉक्स TPM की जगह प्रति मिनट इमेज (IPM) रखते हैं। कोई भी एक सीमा पार होते ही रिक्वेस्ट फ़ेल हो जाती है, भले ही बाकी दो अपनी ऊपरी सीमा से बहुत नीचे हों।

तीन बारीकियाँ लोगों को अक्सर उलझा देती हैं:

• लिमिट प्रोजेक्ट के हिसाब से होती है, क्रेडेंशियल के हिसाब से नहीं। एक ही प्रोजेक्ट में दूसरा एक्सेस टोकन आपको कोई अतिरिक्त जगह नहीं देता।
• दैनिक काउंटर आधी रात को प्रशांत समय (Pacific time) पर रीसेट होता है। UTC नहीं, और आपकी लोकल मिडनाइट भी नहीं।
• सटीक संख्याएँ मॉडल के हिसाब से अलग होती हैं। Google इन्हें डॉक्स की टेबल में नहीं छापता। ये आपके अपने AI Studio रेट लिमिट पेज (aistudio.google.com/rate-limit) पर मिलती हैं और आपके टियर के साथ बदलती हैं, इसलिए यह लेख ऐसे आँकड़े नहीं देता जो जल्दी पुराने पड़ जाएँ।

उपयोग टियर और खर्च की सीमाएँ

आपका टियर इस पर निर्भर करता है कि आपने कितना खर्च किया है:

RPM और IPM के अलावा, Google 10 मिनट की रोलिंग विंडो पर खर्च की कैप भी लगाता है। इसे तोड़ने पर आपको 429 RESOURCE_EXHAUSTED एरर मिलता है। इमेज के काम में यह कैप अक्सर RPM से पहले लग जाती है, क्योंकि हर कॉल महँगी होती है। इमेज कीमतों पर लागू करने पर यह लगभग ऐसा बैठता है:

• Nano Banana 2 1K पर ($0.067): Tier 1 पर प्रति विंडो लगभग 149 इमेज, Tier 2 पर 746 और Tier 3 पर 2,985।
• Nano Banana Pro 4K पर ($0.24): Tier 1 पर प्रति विंडो केवल लगभग 41 इमेज।

यह प्रकाशित कैप से मेरा अपना हिसाब है, इसलिए इसे योजना का अनुमान मानें और अपनी असली सीमाएँ AI Studio में ज़रूर जाँच लें।

429 एरर को सँभालना

429 को अपवाद नहीं, बल्कि एक सामान्य घटना मानें। तीन आदतें पाइपलाइन को स्वस्थ रखती हैं:

1. एक्सपोनेंशियल बैकऑफ़ और जिटर के साथ रीट्राई करें, लगभग एक सेकंड से शुरू करके एक सीमा तक दोगुना करते जाएँ।
2. अपनी ओर से थ्रॉटल करें। टोकन बकेट का आकार अपने टियर की दस मिनट की स्पेंड कैप से नीचे रखें, ताकि वह कभी ट्रिगर न हो।
3. गैर-ज़रूरी काम को बैच मोड में डालें, जो कीमत आधी कर देता है और लंबे जॉब को इंटरैक्टिव रास्ते से बाहर रखता है।

नीचे दिए Python सेक्शन का हेल्पर पहली आदत को लागू करता है।

रिज़ॉल्यूशन और आस्पेक्ट रेशियो के विकल्प

Gemini 3 इमेज मॉडल डिफ़ॉल्ट रूप से 1K पर जनरेट करते हैं। समर्थित साइज़ 512px (0.5K), 1K, 2K और 4K हैं, और Nano Banana 2 Lite 1K पर रुक जाता है। जो Google टेबल मैंने पढ़ी, उसमें Nano Banana 2 के 0.5K टियर की कोई कीमत नहीं दिखी, जबकि थर्ड-पार्टी ट्रैकर लगभग $0.045 बताते हैं। इसलिए इस पर भरोसा करने से पहले लाइव पेज पर इसकी पुष्टि ज़रूर करें।

साइज़ को मंज़िल के हिसाब से चुनें:

• ब्लॉग थंबनेल, सोशल पोस्ट, प्रोडक्ट लिस्टिंग: 1K।
• हीरो बैनर और हाई-डेंसिटी डिस्प्ले: 2K।
• प्रिंट और बड़े क्रॉप: 4K, और केवल फ़ाइनल चुनिंदा इमेज के लिए।

बड़ी फ़ाइलों का एक सस्ता रास्ता यह है कि 1K पर जनरेट करें और विजेता इमेज को सुपर-रेज़ोल्यूशन मॉडल से चलाएँ। PicassoIA पर Real ESRGAN और Google's Upscaler दोनों फ़ोटो को 4x बड़ा करते हैं, और Clarity Pro Upscaler फोटोरियलिस्टिक नतीजों का लक्ष्य रखता है। अपस्केलर नई सामग्री नहीं जोड़ते, बल्कि शार्पनेस बढ़ाते हैं, इसलिए फ़ैसला करने से पहले अपनी इमेज के नेटिव 4K रेंडर से किसी एक की तुलना ज़रूर करें।

आस्पेक्ट रेशियो पर भी उतनी ही सावधानी चाहिए। दस उपलब्ध हैं: 1:1, 3:2, 2:3, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9 और 21:9। जनरेट करने से पहले चुनें। 16:9 रेंडर को 4:5 फ़ीड पोस्ट में काटने पर फ़्रेम का आधे से ज़्यादा हिस्सा चला जाता है, और हर रीरोल एक और बिल की गई इमेज है।

काम करने वाला Python कोड

pip install google-genai से SDK इंस्टॉल करें और अपनी Gemini क्रेडेंशियल को एनवायरनमेंट वेरिएबल के रूप में सेट करें। क्लाइंट इसे अपने-आप पढ़ लेता है, इसलिए आपके सोर्स में कोई सीक्रेट नहीं दिखता।

बेसिक Interactions कॉल

Google के मौजूदा डॉक्स इमेज जनरेशन Interactions API के ज़रिए करते हैं। यह उनके सैंपल से अनुकूलित न्यूनतम संस्करण है:

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.1-flash-image",
    input="A ceramic mug of black coffee on an oak desk, morning window light, 35mm photo",
)

with open("generated_image.png", "wb") as f:
    f.write(base64.b64decode(interaction.output_image.data))

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

इमेज base64 के रूप में interaction.output_image.data में वापस आती है, इसलिए लिखने से पहले उसे डिकोड किया जाता है। डिफ़ॉल्ट रूप से आपको 1K इमेज मिलती है, और थिंकिंग लेवल डिफ़ॉल्ट रूप से minimal रहता है।

साइज़ और आस्पेक्ट रेशियो सेट करें

response_format आर्गुमेंट आउटपुट का प्रकार, अनुपात और साइज़ नियंत्रित करता है:

interaction = client.interactions.create(
    model="gemini-3.1-flash-image",
    input="Overhead photo of a croissant on a linen placemat, soft window light",
    response_format={
        "type": "image",
        "mime_type": "image/jpeg",
        "aspect_ratio": "16:9",
        "image_size": "2K",
    },
)

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

फ़ॉलो-अप एडिट के लिए previous_interaction_id=interaction.id के साथ नया input भेजें, और मॉडल पिछले नतीजे को एडिट कर देता है। किसी कठिन प्रॉम्प्ट पर generation_config={"thinking_level": "high"} के साथ रीज़निंग बढ़ा सकते हैं। इसे हर जगह चालू करने से पहले एक छोटी टेस्ट रन के बाद अपना बिलिंग डैशबोर्ड ज़रूर देखें।

रीट्राई और लागत लॉगिंग

प्रोडक्शन कोड को दो चीज़ें चाहिए जो सैंपल में नहीं हैं: 429 पर बैकऑफ़ और चलती लागत का काउंटर।

import base64
import random
import time

from google import genai

client = genai.Client()

PRICE = {
    ("gemini-3.1-flash-lite-image", "1K"): 0.0336,
    ("gemini-3.1-flash-image", "1K"): 0.067,
    ("gemini-3.1-flash-image", "2K"): 0.101,
    ("gemini-3.1-flash-image", "4K"): 0.151,
    ("gemini-3-pro-image", "1K"): 0.134,
    ("gemini-3-pro-image", "2K"): 0.134,
    ("gemini-3-pro-image", "4K"): 0.24,
}

total = 0.0


def generate(prompt, model="gemini-3.1-flash-image", size="1K", ratio="16:9", retries=5):
    global total
    for attempt in range(retries):
        try:
            interaction = client.interactions.create(
                model=model,
                input=prompt,
                response_format={
                    "type": "image",
                    "mime_type": "image/jpeg",
                    "aspect_ratio": ratio,
                    "image_size": size,
                },
            )
            total += PRICE[(model, size)]
            return base64.b64decode(interaction.output_image.data)
        except Exception as err:
            if getattr(err, "code", None) != 429 or attempt == retries - 1:
                raise
            time.sleep(2 ** attempt + random.random())


image = generate("Overhead photo of a croissant on a linen placemat, soft window light")
with open("croissant.jpg", "wb") as f:
    f.write(image)
print(f"Spent so far: ${total:.3f}")

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

डिक्शनरी की कीमतें सीधे ऊपर की टेबलों से ली गई हैं, इसलिए जब भी Google अपनी दरें बदले, इन्हें अपडेट करें। हर रन के बाद total लॉग करें, तो आपको बिल इनवॉइस आने से पहले दिख जाएगा।

असली मासिक लागत के उदाहरण

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

हर महीने 1,000 इमेज

एक छोटा कैटलॉग या व्यस्त ब्लॉग इसी स्तर पर रहता है। सबसे महँगी पंक्ति भी $240 पर ही रहती है, इसलिए इस वॉल्यूम पर मॉडल का चुनाव लागत से ज़्यादा क्वालिटी का मामला है। 2K पर Nano Banana 2 का एक महीना $101 तक पहुँचता है, जो Tier 2 की $100 की रेखा से बस ऊपर है।

हर महीने 50,000 इमेज

इस पैमाने पर चुनावों का असर जुड़ता जाता है। बैच में Lite ($840) और स्टैंडर्ड दरों पर Pro ($6,700) के बीच का फ़र्क हर महीने $5,860 है, यानी लगभग आठ गुना। हर महीने $3,350 खर्च करने पर लगभग नौ दिनों में $1,000 की Tier 3 रेखा पार हो जाती है, लेकिन 30 दिन का इंतज़ार फिर भी लागू रहता है, इसलिए अपने पहले महीने की योजना Tier 2 की सीमाओं के हिसाब से बनाएँ। हर दिन लगभग 1,700 इमेज का स्थिर लोड $50 की दस मिनट की कैप के आसपास भी नहीं है। कैप को असल में बर्स्ट ट्रिगर करते हैं।

PicassoIA पर Nano Banana 2 Lite आज़माएँ

API पर प्रॉम्प्ट प्रयोगों में पैसा लगाने से पहले उन्हें वहाँ आज़माएँ जहाँ दोहराना सस्ता हो। Nano Banana 2 Lite PicassoIA पर एक तेज़, कम लागत वाले टेक्स्ट-टू-इमेज मॉडल के रूप में उपलब्ध है, जिसमें इमेज एडिटिंग पहले से शामिल है।

1. मॉडल पेज खोलें Nano Banana 2 Lite का।
2. प्रॉम्प्ट लिखें। सब्जेक्ट, रोशनी की दिशा, लेंस और सतह की बनावट के नाम लिखें।
3. ज़रूरत हो तो रेफ़रेंस इमेज जोड़ें। इमेज इनपुट 14 इमेज तक ले सकता है, ताकि उन्हें मिलाया या नए स्टाइल में बदला जा सके।
4. आस्पेक्ट रेशियो चुनें। डिफ़ॉल्ट match_input_image है। प्रीसेट 1:1 से 21:9 तक जाते हैं, और साथ में 1:4, 4:1, 1:8 और 8:1 जैसे लंबे और चौड़े चरम अनुपात भी।
5. आउटपुट फ़ॉर्मैट के रूप में jpg या png चुनें।
6. जनरेट करें, तुलना करें, और सबसे अच्छे नतीजे देने वाले प्रॉम्प्ट के शब्द अपनी Python स्क्रिप्ट के लिए रखें।

💡 टिप: होस्टेड मॉडल पर अच्छे काम करने वाले प्रॉम्प्ट API पर भी काफ़ी हद तक वैसे ही काम करने चाहिए, हालाँकि प्लेटफ़ॉर्म के बीच नतीजे कभी हूबहू एक जैसे नहीं होते। स्केल करने से पहले कुछ साथ-साथ जाँच ज़रूर चलाएँ।

अगर आप बड़ी संख्या में प्रॉम्प्ट ड्राफ़्ट करते हैं, तो PicassoIA पर Gemini 3.5 Flash प्रॉम्प्ट वेरिएशन लिखने के लिए एक तेज़ टेक्स्ट मॉडल है। वहाँ टेस्टिंग आपके Gemini कोटा या Google बिल को नहीं छूती।

Picasso IA पर अपने प्रॉम्प्ट आज़माएँ

प्राइसिंग टेबल एक हद तक ही काम आती हैं। यह जानने का सबसे तेज़ तरीका कि कौन-सा मॉडल, साइज़ और अनुपात आपके प्रोजेक्ट के लिए ठीक है, कुछ इमेज जनरेट करके उन्हें खुद देखना है। Picasso IA खोलें, अपने कैटलॉग के किसी प्रॉम्प्ट के साथ Nano Banana 2 Lite आज़माएँ, फिर उसकी तुलना Nano Banana 2 और Nano Banana Pro से करें। पूरी मॉडल सूची picassoia.com/en/all-models पर देखें, जो आउटपुट आपको पसंद आए उसे चुनें, और उस चुनाव को असली आँकड़ों के साथ अपने API बजट में लाएँ।