Gemini Batch API कीमत: लिमिट, फ्री टियर और रिस्पॉन्स टाइम

जिन जवाबों की इसी मिनट ज़रूरत नहीं है, उनके लिए पूरी कीमत चुकाना Gemini प्रोजेक्ट्स में सबसे आम बर्बादी है। Gemini Batch API ठीक इसी स्थिति के लिए बना है: आप Google को बहुत सारे requests सौंपते हैं, इंतज़ार छोड़ देते हैं और बाद में नतीजे मानक लागत का 50% देकर ले लेते हैं। पेच समय का है। Google का लक्ष्य टर्नअराउंड 24 घंटे है, jobs 48 घंटे बाद expire हो जाते हैं, और कुछ लिमिट तय करती हैं कि आप कितना बड़ा ढेर भेज सकते हैं।

यह लेख सारे आँकड़े एक जगह रखता है: हर मॉडल की batch कीमतें, फ्री टियर में असल में क्या मिलता है, टियर के हिसाब से आकार और token की सीमाएँ, नतीजे आने में कितना समय लगता है, और job भेजने की सटीक Python कॉल। सारे आँकड़े Google के सार्वजनिक pricing, batch और rate limit पेजों से हैं, जिन्हें अक्टूबर 2026 में जाँचा गया था, इसलिए बड़ा बजट लगाने से पहले इन्हें ज़रूर पक्का कर लें।

💡 त्वरित उत्तर: Batch आधी कीमत पर है, 24 घंटे का लक्ष्य रखता है, 20 MB से कम inline या हर फ़ाइल के लिए 2 GB तक स्वीकार करता है, और 100 एक साथ चलने वाली jobs की अनुमति देता है। फ्री टियर में batch सिर्फ़ दो Flash-Lite मॉडलों के लिए मुफ़्त दिखाया गया है।

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

आधी कीमत पर असिंक्रोनस jobs

सामान्य Gemini कॉल सिंक्रोनस होती है: आप प्रॉम्प्ट भेजते हैं, कुछ सेकंड इंतज़ार करते हैं और इंटरैक्टिव दर चुकाते हैं। Batch job किसी छाँटने वाले दफ़्तर में लिफ़ाफ़ों का क्रेट छोड़ने जैसा काम करती है। आप कई requests को एक job के रूप में भेजते हैं, Google उसे कतार में लगाता है, क्षमता होने पर चलाता है, और output आपके डाउनलोड के लिए तैयार रखता है। मॉडल, prompt का फ़ॉर्मेट और सेटिंग्स वैसी ही रहती हैं। बदलता सिर्फ़ डिलीवरी का तरीका है, और इस बदलाव के बदले Google मानक लागत का 50% वसूलता है।

Batch सिर्फ़ सादे टेक्स्ट prompts तक सीमित नहीं है:

• कॉन्टेक्स्ट कैशिंग, स्टैंडर्ड कैशिंग दरों पर बिल होती है
• batches.create_embeddings के ज़रिए एम्बेडिंग जॉब
• Gemini इमेज मॉडल की Nano Banana फ़ैमिली के साथ इमेज जनरेशन
• JSON स्कीमा के साथ स्ट्रक्चर्ड आउटपुट
• रिक्वेस्ट के अंदर एक टूल के रूप में Google Search

Batch किन कामों के लिए सबसे उपयुक्त है

Batch तब फ़ायदेमंद है जब जवाब का इंतज़ार कोई नहीं कर रहा हो। अच्छे उदाहरण हैं: प्रोडक्ट कैटलॉग को वर्गीकृत करना, हज़ारों सपोर्ट टिकटों का सार निकालना, डेटासेट पर लेबल लगाना, रात भर एक evaluation suite चलाना, इमेज लाइब्रेरी के लिए alt text लिखना, या search index के लिए embeddings बनाना। यह हर उस pipeline के लिए भी ठीक है जो पहले से किसी शेड्यूल पर चलती है, जैसे उस दिन बदले प्रोडक्ट्स के विवरण का रात का नवीनीकरण। बुरे उदाहरण हैं चैटबॉट, लाइव सर्च और कोई भी स्क्रीन जहाँ कोई इंसान spinner देख रहा हो।

💡 मोटा नियम: अगर छह घंटे की देरी से किसी को फ़र्क न पड़े, तो job batch में जाना चाहिए।

मॉडल के हिसाब से Gemini Batch API कीमत

नीचे की हर दर पहले से छूट वाली है। कीमतें अमेरिकी डॉलर में 1 मिलियन tokens पर दी गई हैं, पेड टियर के लिए, जो अक्टूबर 2026 में Google के pricing पेज से ली गई हैं।

प्रति मिलियन टोकन दरें

यहाँ दो बातें मायने रखती हैं। पहली, Gemini 3.8, 3.7 और 3.6 Flash की batch दरें 31 दिसंबर 2026 तक प्रमोशनल हैं और 1 जनवरी 2027 को दोगुनी हो जाती हैं, इसलिए अभी बनाए जा रहे बजट में दोनों पंक्तियाँ होनी चाहिए। दूसरी, Gemini 2.5 Pro इस तालिका में अकेला ऐसा मॉडल है जहाँ prompt की लंबाई यूनिट कीमत बदलती है।

हल किया गया लागत उदाहरण

10,000 रिक्वेस्ट का एक जॉब लें, जिसकी हर रिक्वेस्ट में 1,500 इनपुट टोकन और 300 आउटपुट टोकन हैं। कुल मिलाकर यह 15 मिलियन इनपुट टोकन और 3 मिलियन आउटपुट टोकन होता है।

छूट ठीक आधी है, इसलिए Flash-Lite वाला run $6.00 बचाता है और Flash वाला run $24.75। 1,000,000 requests पर वही jobs $600 और $2,475 बचाते हैं। अगर आपके prompts लंबी रीज़निंग शुरू करते हैं, तो याद रखें कि thinking tokens आउटपुट के रूप में बिल होते हैं, इसलिए आउटपुट कॉलम इनपुट कॉलम से तेज़ी से बढ़ सकता है।

टोकन गिनती का अंदाज़ा न लगाएँ। पहले सामान्य API से 50 प्रतिनिधि requests चलाएँ, हर response का usage metadata पढ़ें, और input व output आँकड़ों का औसत निकालें। फिर उसे अपनी request संख्या और batch दर से गुणा करें। 50 के नमूने में कुछ मिनट लगते हैं और अक्सर वह एक prompt रूप सामने आ जाता है जो बाकियों से तीन गुना लंबा चलता है।

इमेज जनरेशन की लागत

इमेज jobs में सबसे महँगा हिस्सा इमेज आउटपुट है। Gemini 3.1 Flash Image, जिसे Nano Banana 2 के नाम से जाना जाता है, batch दरें इस तरह देता है: टेक्स्ट या इमेज input tokens के प्रति मिलियन $0.25, टेक्स्ट और thinking output tokens के प्रति मिलियन $1.50, और इमेज output tokens के प्रति मिलियन $30.00। कुछ ही तस्वीरों के लिए job की ज़रूरत ही नहीं होती: PicassoIA पर Nano Banana 2 बिना क्रेडिट सीमा के इमेज बनाता है, इसलिए 5,000 तस्वीरों की कतार लगाने से पहले prompt परखने के लिए यह एक सस्ती जगह है।

फ्री टियर: असल में क्या मिलता है

मुफ़्त batch वाले मॉडल

Google की प्राइसिंग टेबल में हर मॉडल के लिए एक Batch पंक्ति है, जिसमें अलग-अलग Free Tier और Paid Tier कॉलम हैं। इस लेख के लिखे जाने के समय, Free Tier कॉलम दो मॉडलों के लिए बिना शुल्क दिखाता है: Gemini 3.5 Flash-Lite और Gemini 3.1 Flash-Lite। यह Gemini 3.8, 3.7, 3.6 और 3.5 Flash, Gemini 3.1 Flash Image, Gemini 2.5 Pro, Gemini 2.5 Flash और Gemini 2.5 Flash-Lite के लिए उपलब्ध नहीं दिखाता है।

जहाँ दस्तावेज़ चुप हैं

Batch पेज यह नहीं बताता कि फ्री टियर के अकाउंट job भेज सकते हैं या नहीं। Rate limit पेज तीनों पेड टियर के लिए enqueued token संख्याएँ देता है, फ्री टियर के लिए कोई नहीं। इसलिए "free" को उन दो मॉडलों के लिए शून्य कीमत पढ़ें, असीमित नहीं।

💡 योजना बनाने से पहले टेस्ट करें: दो Flash-Lite मॉडल में से किसी एक पर दस रिक्वेस्ट का जॉब भेजें, उसकी स्थिति देखें, और AI Studio में अपने प्रोजेक्ट के लिए रेट लिमिट पेज जाँचें। जब तक यह छोटा जॉब सफल न हो, किसी फ्री batch पंक्ति के भरोसे प्रोडक्शन शेड्यूल न बनाएँ।

वे लिमिट जिनसे आपका सामना होगा

Batch की लिमिट दो समूहों में आती हैं: एक अकेली job कितनी बड़ी हो सकती है, और एक साथ कितना काम कतार में रह सकता है।

Request और फ़ाइल आकार की सीमाएँ

इनलाइन रिक्वेस्ट छोटे जॉब के लिए ठीक रहती हैं। पेलोड 20 MB के करीब पहुँचते ही JSONL फ़ाइल पर जाएँ: हर लाइन में एक रिक्वेस्ट, और हर लाइन में रिक्वेस्ट ID के साथ रिक्वेस्ट बॉडी, जिसे Files API से अपलोड किया जाता है।

टियर के हिसाब से enqueued tokens

सबसे सख़्त लिमिट फ़ाइल आकार नहीं, बल्कि enqueued tokens है: एक मॉडल के लिए सभी सक्रिय batch jobs में कतार में लगे कुल tokens। यह आपके billing टियर के साथ बढ़ती है।

जिस मॉडल की Tier 1 लिमिट 3,000,000 tokens है, उसके लिए हमारे 15 मिलियन input tokens वाले उदाहरण को कम से कम पाँच अलग-अलग लहरों की ज़रूरत होगी। Tier 2 पर यह एक ही job में आराम से फ़िट हो जाता है। Tier 1 से Tier 2 पर जाने की छलाँग ही वह है जो pipeline के डिज़ाइन का तरीका बदल देती है।

रिस्पॉन्स टाइम और job states

24 घंटे का असल मतलब

Google 24 घंटे को लक्ष्य टर्नअराउंड कहता है और जोड़ता है कि ज़्यादातर मामलों में नतीजे इससे कहीं जल्दी आ जाते हैं। इसे ऐसी सीमा मानें जिसके हिसाब से योजना बनाएँ, न कि ऐसी रफ़्तार जिस पर भरोसा किया जा सके। छोटी jobs अक्सर जल्दी लौट आती हैं, जबकि बड़ी jobs क्षमता मिलने का इंतज़ार करती हैं।

सख़्त सीमा 48 घंटे है: उस समय तक pending या running job expire हो जाती है। बड़े काम को कई jobs में बाँटने का मतलब है कि expiry या failure में नुकसान पूरे रन की जगह सिर्फ़ एक टुकड़े जितना हो।

एक और जाल: batch जॉब भेजना idempotent नहीं है। अगर create कॉल के बाद आपकी स्क्रिप्ट टाइमआउट हो जाए और आप दोबारा कोशिश करें, तो दूसरा जॉब बन जाता है और आपको दोनों का भुगतान करना पड़ता है। कुछ और करने से पहले पहले रिस्पॉन्स से जॉब का नाम सेव कर लें।

एक व्यावहारिक लय रात भर चलने वाला रन है। कार्यदिवस के अंत में job भेजें, उसे रात भर चलने दें, और सुबह की पहली चाय के साथ नतीजे पढ़ें। अगर पूरे एक दिन बाद भी job pending है, तो 48 घंटे की expiry का इंतज़ार न करें: उसकी state जाँचें, उस मॉडल के लिए अपना enqueued token योग देखें, और job रद्द करके छोटे टुकड़ों में दोबारा भेजने पर विचार करें।

देखने लायक job states

बेकरी के काम की तरह, एक job कई चरणों से गुज़रती है, और आप आख़िर में ही output उठाते हैं।

Google का नमूना कोड हर 30 सेकंड में poll करता है। जिन jobs को घंटों चलने की उम्मीद है, उनके लिए धीमा अंतराल बेकार की कॉलें बचाता है।

Python में batch job भेजें

Inline requests

google-genai SDK के साथ, इनलाइन जॉब में रिक्वेस्ट की एक सूची, एक मॉडल का नाम और एक वैकल्पिक डिस्प्ले नाम दिया जाता है:

from google import genai

client = genai.Client()

inline_requests = [
    {"contents": [{"parts": [{"text": "Tell me a one-sentence joke."}], "role": "user"}]},
    {"contents": [{"parts": [{"text": "Why is the sky blue?"}], "role": "user"}]},
]

job = client.batches.create(
    model="gemini-3.8-flash",
    src=inline_requests,
    config={"display_name": "inlined-requests-job-1"},
)
print(job.name)

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

फ़ाइल वाली job के लिए JSONL को client.files.upload से अपलोड करें, mime_type='jsonl' का उपयोग करते हुए, फिर uploaded_file.name को src के रूप में पास करें।

Poll करें और नतीजे पढ़ें

import time

finished_states = {
    "JOB_STATE_SUCCEEDED",
    "JOB_STATE_FAILED",
    "JOB_STATE_CANCELLED",
    "JOB_STATE_EXPIRED",
}

job = client.batches.get(name=job.name)
while job.state.name not in finished_states:
    time.sleep(30)
    job = client.batches.get(name=job.name)

if job.state.name == "JOB_STATE_SUCCEEDED":
    for i, item in enumerate(job.dest.inlined_responses):
        if item.response:
            print(i, item.response.text)
        elif item.error:
            print(i, item.error)

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

फ़ाइल वाली jobs इसके बजाय एक result फ़ाइल लौटाती हैं: job.dest.file_name पढ़ें और उसे client.files.download से लाएँ।

Batch से पहले prompts परखें

Batch job धीमी फ़ीडबैक देती है। खराब प्रॉम्प्ट का मतलब है पूरी टर्नअराउंड खिड़की और पूरा बिल। पहले इंटरैक्टिव रूप से prompt परखें, एक दर्जन अलग-अलग नमूनों पर, और फिर ही हज़ारों को कतार में लगाएँ।

PicassoIA पर Gemini 3.5 Flash इस्तेमाल करें

PicassoIA पर Gemini 3.5 Flash आपके ब्राउज़र में एकल prompts चलाता है, इसलिए यह परीक्षण के लिए त्वरित बेंच है। यह Batch API jobs नहीं भेजता, वे अब भी Google के SDK से जाती हैं। दिनचर्या यह है:

1. मॉडल पेज खोलें और Prompt फ़ील्ड ढूँढें।
2. वही सटीक प्रॉम्प्ट पेस्ट करें जो आप batch में भेजने की योजना बना रहे हैं, किसी भी उदाहरण समेत।
3. एक system instruction जोड़ें जो भूमिका और आउटपुट फ़ॉर्मैट तय करे, जैसे "हर उत्पाद के लिए एक JSON object लौटाएँ"।
4. thinking level चुनें: none, low या high। ऊँचे levels आपके असली batch में ज़्यादा output tokens लगाते हैं, इसलिए जो सबसे निचला level पास हो जाए, वही इस्तेमाल करें।
5. extraction या classification के लिए temperature कम करें। 0 से 2 के पैमाने पर डिफ़ॉल्ट 1 है।
6. job को ज़रूरत हो तो media जोड़ें। मॉडल 7 MB तक की 10 इमेज, 8.4 घंटे तक का ऑडियो और 45 मिनट तक का वीडियो स्वीकार करता है।
7. दस अलग-अलग नमूने चलाएँ और हर जवाब पढ़ें। प्रॉम्प्ट ठीक करें, फिर उन्हें दोबारा चलाएँ।
8. अंतिम प्रॉम्प्ट और system instruction को अपनी batch requests में कॉपी करें।

डिफ़ॉल्ट output सीमा 65,535 tokens है, इसलिए छोटे कामों के लिए कम सीमा तय करें। Batch में हर वह unused token, जिसे आपने बनने नहीं दिया, आपका बचा हुआ पैसा है।

क्वालिटी पर दूसरी राय चाहिए? Gemini 3.1 Pro, Gemini 3 Flash और Gemini 2.5 Flash एक ही लार्ज लैंग्वेज मॉडल संग्रह में मौजूद हैं, इसलिए job में कौन सा मॉडल जाए यह चुनने से पहले आप एक ही प्रॉम्प्ट इन सबपर चला सकते हैं।

कम खर्च करें, फिर इमेज बनाएँ

बिल घटाने के तीन तरीके

1. साझा हिस्से को कैश करें। कॉन्टेक्स्ट कैशिंग batch jobs के भीतर standard caching दरों पर काम करती है, इसलिए 10,000 requests में दोहराए जाने वाले लंबे system prompt के लिए 10,000 बार पैसे नहीं देने चाहिए।
2. जो सबसे छोटा मॉडल पास हो जाए, वही चुनें। Gemini 3.5 Flash-Lite का input प्रति मिलियन tokens $0.15 है, जबकि Gemini 3.5 Flash का $0.75; यह पाँच गुना कम है, और इसकी output दर $1.25 है, जो $4.50 का लगभग 28% है।
3. आउटपुट सीमित करें। छोटे जवाब, कम thinking level और कसी हुई output सीमा आपके बिल के सबसे महँगे कॉलम को छोटा करती है।

जब कोई इंसान इंतज़ार कर रहा हो, जब नतीजे किसी लाइव स्क्रीन को खिलाने हों, या जब job इतनी छोटी हो कि polling का खर्च छूट से ज़्यादा हो, तब batch पूरी तरह छोड़ दें।

सस्ते में परखने और फिर बड़ा खर्च करने की यही आदत विज़ुअल्स पर भी लागू होती है। अगर आपकी batch job किसी ब्लॉग, कैटलॉग या ऐप को भरती है, तो शायद आप टेक्स्ट के साथ तस्वीरें भी चाहेंगे। PicassoIA पर Nano Banana 2 खोलें और बिना क्रेडिट काउंटर चलाए इमेज बनाएँ, किसी अलग रूप के लिए Seedream 5 Pro या FLUX 2 Pro आज़माएँ, और नतीजा सही होने तक दोहराएँ। हर विकल्प picassoia.com/en/all-models पर देखें और आज ही अपनी पहली इमेज बनाएँ।