मौजूदा gemini-3.1-flash-image मॉडल और Interactions API का उपयोग करके Gemini इमेज जनरेशन API के लिए एक काम करने वाला Python वॉकथ्रू। अपनी पहली इमेज जनरेट करें, आस्पेक्ट रेशियो और रिज़ोल्यूशन नियंत्रित करें, फ़ोटो एडिट करें, विफल कॉल को दोबारा आज़माएँ, और हर इमेज की असली लागत का अनुमान लगाएँ।
ज़्यादातर Gemini इमेज ट्यूटोरियल अब भी gemini-2.5-flash-image को कॉल करते हैं, और Google का प्राइसिंग पेज इस मॉडल को deprecated बताता है, जिसकी शटडाउन तारीख 2 अक्टूबर 2026 है। वह तारीख निकल चुकी है, इसलिए इस पर बने स्निपेट्स को टूटा हुआ मानना चाहिए। यह पेज मौजूदा मॉडल gemini-3.1-flash-image और Interactions API का उपयोग करता है, जिसे Google का अपना दस्तावेज़ अब सबसे पहले सुझाता है।
आप एक खाली फ़ोल्डर से शुरू करके एक ऐसी स्क्रिप्ट तक पहुँचेंगे जो इमेज जनरेट करती है, उसका साइज़ नियंत्रित करती है, मौजूदा फ़ोटो एडिट करती है, मिक्स्ड टेक्स्ट और इमेज आउटपुट सेव करती है, और रेट लिमिट को झेल लेती है। हर स्निपेट इतना छोटा है कि उसे एक फ़ाइल में चिपकाकर चलाया जा सकता है। स्टैंडर्ड Flash मॉडल पर एक 1K इमेज की लागत लगभग $0.067 है, इसलिए टेस्टिंग सस्ती रहती है।
आपकी पहली तस्वीर के रास्ते में तीन चीज़ें हैं: Python 3 का नया इंस्टॉल, Google AI Studio से मिला एक क्रेडेंशियल, और बिलिंग चालू वाला एक प्रोजेक्ट। Google के प्राइसिंग पेज पर किसी भी Gemini इमेज मॉडल के लिए कोई फ़्री टियर नहीं दिखता, इसलिए बिना बिलिंग वाला प्रोजेक्ट पहली कॉल पर शायद रिजेक्ट हो जाएगा।
एक ही पैकेज सब कुछ करता है:
pip install -U google-genai
Interactions API को google-genai 2.3.0 या उससे नया चाहिए, इसीलिए -U फ़्लैग मायने रखता है। अगर नीचे का कोई स्निपेट client.interactions पर attribute error देता है, तो pip show google-genai चलाएँ।
Google AI Studio में एक क्रेडेंशियल बनाएँ, फिर उसे नीचे दिए गए सटीक नाम से एनवायरनमेंट वेरिएबल के रूप में एक्सपोर्ट करें। SDK वह वेरिएबल अपने आप पढ़ लेता है, इसलिए आपकी स्क्रिप्ट में सीक्रेट रखना ज़रूरी नहीं होता।
export GEMINI_API_KEY="paste-your-credential-here"
Windows PowerShell में वही लाइन $env:GEMINI_API_KEY = "paste-your-credential-here" होती है।
💡 क्रेडेंशियल को कभी ऐसी स्क्रिप्ट में न डालें जो Git पर जाती है। उसे एनवायरनमेंट वेरिएबल में रखें या किसी
.envफ़ाइल में, जिसे आपकी.gitignoreपहले से बाहर रखती है।
Google अब चार इमेज मॉडल सूचीबद्ध करता है। तीन मौजूदा हैं, एक रिटायर हो चुका है।
| मॉडल ID | साइज़ | प्रति इमेज कीमत | सबसे अच्छा किसके लिए |
|---|---|---|---|
gemini-3.1-flash-lite-image | केवल 1K | लगभग $0.034 | बल्क काम, थंबनेल |
gemini-3.1-flash-image | 0.5K, 1K, 2K, 4K | $0.045, $0.067, $0.101, $0.151 | ज़्यादातर स्क्रिप्ट्स के लिए डिफ़ॉल्ट चुनाव |
gemini-3-pro-image | 1K, 2K, 4K | $0.134 (1K और 2K), $0.24 (4K) | जटिल, बहु-भाग वाले प्रॉम्प्ट |
gemini-2.5-flash-image | लागू नहीं | $0.039 | रिटायर हो चुका है, इसका उपयोग न करें |
ये कीमतें लिखने के समय Google के प्राइसिंग पेज से हैं। बड़ा रन करने से पहले इन्हें दोबारा जाँच लें।
कैसे चुनें? gemini-3.1-flash-image से शुरू करें। यह अकेला मौजूदा मॉडल है जो चारों साइज़ देता है, इसलिए एक ही कोड पाथ थंबनेल और प्रिंट फ़ाइलें दोनों संभालता है। जब आप हज़ारों छोटी इमेज जनरेट करें और हर पैसा मायने रखे, तब Flash Lite पर जाएँ। जब प्रॉम्प्ट के कई हिस्से हों, जैसे कई लेबल वाले तत्वों का पोस्टर लेआउट, और सस्ता मॉडल बार-बार डिटेल छोड़ दे, तब Pro की ओर जाएँ। चूँकि तीनों मौजूदा मॉडल एक ही कॉल शेप साझा करते हैं, बाद में मॉडल बदलने का मतलब सिर्फ़ एक स्ट्रिंग बदलना है।
इसे first_image.py के रूप में सेव करें:
import base64
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-3.1-flash-image",
input="A photograph of a bowl of oranges on a linen cloth, soft window light",
)
with open("oranges.png", "wb") as f:
f.write(base64.b64decode(interaction.output_image.data))
python first_image.py चलाएँ और स्क्रिप्ट के बगल में एक oranges.png फ़ाइल दिखेगी। पूरा चक्र बस इतना है: प्रॉम्प्ट अंदर, base64 स्ट्रिंग बाहर, और डिस्क पर बाइट्स।
एक से ज़्यादा तस्वीर जनरेट करते ही एक तय फ़ाइल नाम आपका पिछला परिणाम ओवरराइट कर देगा। इसके बजाय नाम टाइमस्टैम्प से बनाएँ, जैसे f"image_{int(time.time())}.png", तो हर रन अपनी अलग फ़ाइल छोड़ता है। फिर आप एक ही प्रॉम्प्ट के एक दर्जन वेरिएशन साथ-साथ देख सकते हैं।
genai.Client() एक क्लाइंट बनाता है और उस क्रेडेंशियल को खींचता है जो आपने पहले एनवायरनमेंट वेरिएबल में एक्सपोर्ट किया था, इसलिए फ़ाइल में कुछ भी संवेदनशील नहीं रहता।client.interactions.create() प्रॉम्प्ट भेजता है और एक Interaction ऑब्जेक्ट लौटाता है, जिसमें id, आउटपुट स्टेप्स और output_image जैसे शॉर्टकट होते हैं।interaction.output_image.data इमेज को base64 स्ट्रिंग के रूप में रखता है। लिखने से पहले उसे डिकोड करना ज़रूरी है, वरना फ़ाइल तस्वीर नहीं बल्कि टेक्स्ट होगी।मॉडल सीन के विवरण पर सबसे अच्छी तरह प्रतिक्रिया देता है, ढेर सारे अलग-अलग टैग पर नहीं। वह प्रॉम्प्ट जो किसी फ़ोटोग्राफ़र की शॉट लिस्ट जैसा पढ़ता है, विशेषणों की सूची से ज़्यादा नियंत्रण देता है।
💡 अपने प्रॉम्प्ट Python list या टेक्स्ट फ़ाइल में रखें। जब कोई परिणाम चौंकाए, तो आप एक वेरिएबल बदलकर तुलना कर सकते हैं, जो याद से दोबारा लिखने से बेहतर है।
साइज़ और आकार एक response_format डिक्शनरी के अंदर रहते हैं। इससे कई लोग उलझ जाते हैं, क्योंकि पुराना कोड इमेज सेटिंग्स generation_config में रखता था।
interaction = client.interactions.create(
model="gemini-3.1-flash-image",
input="A wide photograph of a coastal road at dawn, 35mm lens, film grain",
response_format={
"type": "image",
"mime_type": "image/jpeg",
"aspect_ratio": "16:9",
"image_size": "2K",
},
)
with open("coast.jpg", "wb") as f:
f.write(base64.b64decode(interaction.output_image.data))
चूँकि माँगा गया mime_type JPEG है, फ़ाइल को .jpg एक्सटेंशन मिलता है। एक्सटेंशन को उसी टाइप से मिलाएँ जो आप माँगते हैं, तो आपका इमेज व्यूअर कभी शिकायत नहीं करेगा।
Google का दस्तावेज़ दस रेशियो सूचीबद्ध करता है: 1:1, 3:2, 2:3, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, और 21:9।
| रेशियो | आम उपयोग |
|---|---|
| 1:1 | प्रोफ़ाइल पिक्चर, प्रोडक्ट टाइल |
| 4:5 | सोशल फ़ीड पोस्ट |
| 9:16 | स्टोरी और वर्टिकल वीडियो थंबनेल |
| 16:9 | ब्लॉग हेडर, वीडियो थंबनेल |
| 21:9 | अल्ट्रावाइड बैनर |
| 3:2 | क्लासिक फ़ोटो प्रिंट |
image_size की वैल्यू मॉडल पर निर्भर करती है। Flash Lite सिर्फ़ 1K देता है। Flash 0.5K, 1K, 2K, और 4K देता है। Pro 1K, 2K, और 4K देता है। वैल्यू में K को बड़े अक्षरों में लिखें।
एक सरल नियम खर्च को काबू में रखता है: ड्राफ़्ट के लिए 1K, वेब पेज के लिए 2K, और सिर्फ़ प्रिंट के लिए 4K। Flash पर 4K इमेज की लागत $0.151 है, जबकि 1K पर $0.067, यानी लगभग 2.25 गुना ज़्यादा, इसलिए "हमेशा सबसे बड़ा" वाली आदत जल्दी भारी पड़ती है।
वही एंडपॉइंट इमेज एडिट भी करता है। सादे स्ट्रिंग की जगह input एक ऐसी list बन जाता है जिसमें टेक्स्ट ब्लॉक और इमेज ब्लॉक मिले होते हैं। इमेज अपने MIME टाइप के साथ base64 स्ट्रिंग के रूप में जाती है।
import base64
from google import genai
client = genai.Client()
with open("portrait.png", "rb") as f:
encoded = base64.b64encode(f.read()).decode("utf-8")
interaction = client.interactions.create(
model="gemini-3.1-flash-image",
input=[
{
"type": "text",
"text": "Replace the background with a sunlit brick wall. Keep the person unchanged.",
},
{"type": "image", "data": encoded, "mime_type": "image/png"},
],
)
with open("portrait_edit.png", "wb") as f:
f.write(base64.b64decode(interaction.output_image.data))
एडिट प्रॉम्प्ट के शब्दों पर ध्यान दें। उसमें बताया गया है कि क्या बदलना है (बैकग्राउंड) और क्या वैसा ही रहना है (व्यक्ति)। दूसरा हिस्सा न हो, तो मॉडल पूरे फ़्रेम को नए सिरे से स्टाइल कर सकता है।
हर छोटे बदलाव के लिए इमेज दोबारा भेजने की ज़रूरत नहीं है। पिछली interaction का id पास करें, और मॉडल वह तस्वीर याद रखता है जो उसने अभी बनाई:
second = client.interactions.create(
model="gemini-3.1-flash-image",
input="Make the light warmer, like late afternoon.",
previous_interaction_id=interaction.id,
response_format={
"type": "image",
"mime_type": "image/jpeg",
"aspect_ratio": "4:5",
"image_size": "2K",
},
)
पहली इमेज जैसा ही आस्पेक्ट रेशियो रखें, वरना मॉडल सीन को क्रॉप या बढ़ा सकता है। हर interaction.id को अपने डेटाबेस में स्टोर करें, तो आप सेशन में किसी भी पिछले स्टेप पर वापस जा सकते हैं। क्लाइंट के काम में यह काम का है, जहाँ "वर्ज़न दो पर वापस चलो" अक्सर आता है।
कभी-कभी मॉडल टेक्स्ट का एक वाक्य और एक इमेज लौटाता है। सरल स्क्रिप्ट्स के लिए output_image शॉर्टकट ठीक है, लेकिन एक हेल्पर जो steps list पर चलता है, हर केस संभालता है:
def save_outputs(interaction, prefix="gemini", ext="png"):
saved = []
for step in interaction.steps:
if step.type != "model_output":
continue
for block in step.content:
if block.type == "text":
print(block.text)
elif block.type == "image":
path = f"{prefix}_{len(saved) + 1}.{ext}"
with open(path, "wb") as f:
f.write(base64.b64decode(block.data))
saved.append(path)
return saved
फ़ंक्शन फ़ाइल पाथ की list लौटाता है। खाली list का मतलब है कि मॉडल ने सिर्फ़ टेक्स्ट भेजा, जो कोई exception नहीं है, इसलिए फ़ाइल होने की मान्यता रखने से पहले इसे जाँच लें।
कुछ तस्वीरें ऐसे तथ्यों पर निर्भर करती हैं जो रोज़ बदलते हैं: मौसम ग्राफ़िक, स्कोर कार्ड, या प्राइस चार्ट। Google Search चालू करें, तो मॉडल ड्रॉ करने से पहले लाइव डेटा खींच सकता है:
interaction = client.interactions.create(
model="gemini-3.1-flash-image",
input="Create an infographic of this week's weather in Chicago",
tools=[{"type": "google_search"}],
generation_config={"thinking_level": "high"},
)
thinking_level सेटिंग "minimal" या "high" स्वीकार करती है। जब स्पीड मायने रखे और लेआउट सरल हो, तो minimal इस्तेमाल करें। जब प्रॉम्प्ट कई हिस्सों वाला स्ट्रक्चर्ड लेआउट माँगे, तो high इस्तेमाल करें।
💡 API जो हर इमेज लौटाता है उसमें SynthID watermark होता है, एक अदृश्य निशान जो Google जोड़ता है ताकि इमेज को AI-जनरेटेड पहचाना जा सके। यह आपको खुद जोड़ने की ज़रूरत नहीं है।
इमेज कॉल अक्सर टेक्स्ट कॉल से ज़्यादा समय लेती हैं, और अनुरोधों की बाढ़ रेट लिमिट को ट्रिगर कर सकती है। एक छोटा retry रैपर ज़्यादातर परेशानी से बचा लेता है। यह HTTP 429, 500, और 503 पर दोबारा कोशिश करता है और हर विफलता के बाद ज़्यादा देर इंतज़ार करता है:
import time
def generate_with_retry(prompt, retries=4, **kwargs):
for attempt in range(retries):
try:
return client.interactions.create(
model="gemini-3.1-flash-image",
input=prompt,
**kwargs,
)
except Exception as exc:
status = getattr(exc, "status_code", None) or getattr(exc, "code", None)
if status not in (429, 500, 503) or attempt == retries - 1:
raise
time.sleep(2 ** attempt)
SDK वर्ज़न के आधार पर HTTP स्टेटस status_code पर हो सकता है या code पर, इसलिए हेल्पर दोनों जाँचता है। जो चीज़ दोबारा नहीं आज़माई जा सकती, जैसे खराब request, उसे तुरंत raise किया जाता है ताकि आपको असली मैसेज दिखे।
प्रॉम्प्ट्स की list प्रोसेस करने के लिए, एक बार में कुछ ही चलाएँ:
from multiprocessing.pool import ThreadPool
prompts = ["A bowl of oranges", "A lighthouse at dusk", "A forest road in fog"]
with ThreadPool(4) as pool:
results = pool.map(generate_with_retry, prompts)
चार workers से शुरू करें। अगर retry हेल्पर लगातार चालू होता रहे, तो कोटा बढ़ाने से पहले दो पर आ जाएँ।
रिजेक्ट हुए प्रॉम्प्ट्स के लिए अलग आदत चाहिए। Google का दस्तावेज़ बताता है कि Interactions API में कस्टम safety settings सपोर्ट नहीं होतीं, इसलिए आप कोड से फ़िल्टर ढीले नहीं कर सकते। जब कोई response टेक्स्ट लौटाए और इमेज नहीं, तो प्रॉम्प्ट और टेक्स्ट दोनों लॉग करें, फिर प्रॉम्प्ट को ज़्यादा शांत और ठोस विवरण के साथ लिखें। एक ही प्रॉम्प्ट को दोबारा भेजने से जवाब शायद ही बदलता है और बस समय बर्बाद होता है।
gemini-2.5-flash-image वाले किसी भी स्निपेट में मॉडल स्ट्रिंग को किसी मौजूदा से बदलना होगा।aspect_ratio को generation_config में डालना। यह response_format में जाता है, image_size के साथ।base64.b64decode() चलाएँ, वरना फ़ाइल नहीं खुलेगी।अगर आपके पास पुराना कोड है जो generate_content को कॉल करता है, तो Google कहता है कि वह API अब भी सपोर्टेड है और अब legacy के रूप में चिह्नित है। नए प्रोजेक्ट्स के लिए, Google का दस्तावेज़ Interactions API की सिफ़ारिश करता है।
लागत वॉल्यूम के साथ बढ़ती है, इसलिए किसी बड़े loop से पहले हिसाब लगा लें। Flash पर पाँच सौ 2K इमेज की लागत 500 x $0.101 है, यानी $50.50। Google उन जॉब्स के लिए batch pricing भी देता है, जो इंतज़ार कर सकते हैं, लगभग स्टैंडर्ड दर की आधी कीमत पर:
| रिज़ोल्यूशन | स्टैंडर्ड | बैच |
|---|---|---|
| 0.5K | $0.045 | $0.022 |
| 1K | $0.067 | $0.034 |
| 2K | $0.101 | $0.050 |
| 4K | $0.151 | $0.076 |
वही 500 इमेज 2K पर batch के ज़रिए लगभग $25 पड़ती हैं। अगर किसी को नतीजे का इंतज़ार नहीं है, जैसे रात का कैटलॉग रिफ़्रेश, तो batch सस्ता रास्ता है।
हर इमेज के लिए स्क्रिप्ट की ज़रूरत नहीं होती। अगर आप API क्रेडिट खर्च करने से पहले प्रॉम्प्ट टेस्ट करना चाहते हैं, या काम किसी ऐसे साथी को देना चाहते हैं जो Python नहीं लिखता, तो PicassoIA पर Nano Banana Pro उसी Google मॉडल फ़ैमिली से 4K तक आउटपुट पाने का बिना कोड वाला तरीका है।
16:9, 9:16, 4:5, 21:9, और match_input_image शामिल हैं।1K, 2K (डिफ़ॉल्ट), या 4K।block_only_high डिफ़ॉल्ट और सबसे ज़्यादा अनुमति देने वाला है; block_low_and_above सबसे सख्त है।अगर आप पेज पर प्रोटोटाइप करते हैं और फिर कोड की ओर जाते हैं, तो सेटिंग्स लगभग एक-से-एक मेल खाती हैं:
| PicassoIA फ़ील्ड | Python API समकक्ष |
|---|---|
| Prompt | input (टेक्स्ट ब्लॉक) |
| Image Input | input (इमेज ब्लॉक, base64) |
| aspect_ratio | response_format["aspect_ratio"] |
| resolution | response_format["image_size"] |
| output_format | response_format["mime_type"] |
PicassoIA पर Google फ़ैमिली एक मॉडल से कहीं बड़ी है। Nano Banana त्वरित एडिट संभालता है, Nano Banana 2 Lite स्पीड को प्राथमिकता देता है, और Imagen 4 तथा Imagen 4 Ultra फ़ोटोरियलिस्टिक डिटेल पर ध्यान देते हैं। एक ही प्रॉम्प्ट को उनमें से दो पर चलाने में एक मिनट लगता है और यह दिखा देता है कि एक भी लाइन इंटीग्रेशन कोड लिखने से पहले आपके प्रोजेक्ट के लिए कौन सी स्टाइल सही है।
अब आपके पास हर हिस्सा है: एक काम करता इंस्टॉल, पहली इमेज, साइज़ और रेशियो नियंत्रण, एडिट, मिक्स्ड आउटपुट पढ़ने का सुरक्षित तरीका, एक retry रैपर, और एक भरोसेमंद लागत अनुमान। एक छोटा काम चुनें, जैसे ब्लॉग हेडर या प्रोडक्ट टाइल, और आज दोपहर उसे शुरू से अंत तक चलाएँ।
अगर आप टर्मिनल छूने से पहले नतीजे देखना चाहते हैं, तो Picasso IA खोलें, Nano Banana Pro जैसा मॉडल चुनें, और वही प्रॉम्प्ट टाइप करें जो आपने अपनी स्क्रिप्ट के लिए लिखा था। तीन वेरिएशन आज़माएँ, आस्पेक्ट रेशियो बदलें, और तुलना करें। वहाँ मिला सबसे अच्छा प्रॉम्प्ट ऊपर के Python कोड में सीधा जाता है।
पेज पर टेस्ट करना और कोड में शिप करना, यह चक्र हर प्रयोग के लिए पैसे दिए बिना किसी लुक को तय करने का सबसे तेज़ तरीका है। Picasso IA खोलें, अपना पहला प्रॉम्प्ट चलाएँ, और दोपहर खत्म होने से पहले देखें कि आप क्या बना सकते हैं।
अपनी भाषा चुनें
