Python में OpenAI Image Generation API: उदाहरण सहित गाइड

OpenAI इमेज एंडपॉइंट के ज़्यादातर ट्यूटोरियल "यह रहा एक URL" पर खत्म हो जाते हैं। DALL-E के लिए यह काम करता था। GPT Image मॉडल के लिए यह नहीं चलता, क्योंकि वे base64 डेटा लौटाते हैं और बस इतना ही, इसलिए लोग जो स्क्रिप्ट सबसे पहले कॉपी करते हैं वह अक्सर result.data[0].url पर क्रैश हो जाती है। यह ट्यूटोरियल एक ऐसी स्क्रिप्ट से शुरू होता है जो चलती है, फिर उसमें साइज़, क्वालिटी लेवल, मास्क-आधारित एडिट, स्ट्रीमिंग प्रीव्यू, async बैच और एक छोटा कॉस्ट ट्रैकर जोड़ा जाता है।

नीचे दिए गए पैरामीटर, मॉडल नाम और कीमतें OpenAI के मौजूदा इमेज जनरेशन डॉक्स और प्राइसिंग पेज से ली गई हैं, जो 2026-10-06 को पढ़ी गई थीं। जहाँ कोई संख्या बदल सकती है, वहाँ टेक्स्ट यह साफ़ बताता है।

कोड लिखने से पहले

पहली रिक्वेस्ट सफल होने से पहले तीन चीज़ें तैयार होनी चाहिए: एक मॉडल नाम, इंस्टॉल किया हुआ SDK, और एक वेरिफ़ाइड OpenAI organization। आख़िरी वाली चीज़ ज़्यादातर नए अकाउंट्स को अटका देती है, क्योंकि डेवलपर कंसोल सेटिंग्स में वेरिफ़िकेशन पूरा होने तक GPT Image मॉडल एक्सेस एरर लौटाते हैं।

मॉडल चुनें

ये वे GPT Image मॉडल हैं जिनकी कीमत OpenAI आज तय करता है। पाँचों PicassoIA पर भी चलते हैं, जो कोड लिखने से पहले प्रॉम्प्ट टेस्ट करने के लिए काम आता है।

PicassoIA पर आप GPT Image 2.5 Flare, GPT Image 2.5 Sunburst, GPT Image 2, GPT Image 1 और GPT Image 1 Mini को साथ-साथ आज़मा सकते हैं। एक समझदार डिफ़ॉल्ट: जनरेशन के लिए Flare, और जब काम एडिट का हो तो Sunburst।

इंस्टॉल करें और ऑथेंटिकेट करें

आधिकारिक SDK इंस्टॉल करें:

pip install --upgrade openai pillow

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

OpenAI डैशबोर्ड में एक प्रोजेक्ट सीक्रेट बनाएँ, फिर उसे एनवायरनमेंट वेरिएबल के रूप में सेट करें। SDK उसे अपने-आप पढ़ लेता है, इसलिए सीक्रेट कभी आपकी सोर्स फ़ाइल में दिखाई नहीं देता।

# macOS / Linux
export OPENAI_API_KEY="sk-..."

# Windows PowerShell
$env:OPENAI_API_KEY = "sk-..."

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

💡 टिप: सीक्रेट को उन नोटबुक से बाहर रखें जिन्हें आप शेयर करने वाले हैं, और git हिस्ट्री से भी। अगर वह लीक हो जाए, तो डैशबोर्ड में उसे रद्द करें और नया बनाएँ।

Python में आपकी पहली इमेज

न्यूनतम स्क्रिप्ट

यह पूरी स्क्रिप्ट है। इसे चलाएँ और स्क्रिप्ट के बगल में एक PNG दिख जाएगा।

import base64
from pathlib import Path
from openai import OpenAI

client = OpenAI()

result = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="A ceramic bowl of ripe peaches on a linen cloth, soft window light, 50mm photograph",
    size="1536x1024",
    quality="medium",
)

image_bytes = base64.b64decode(result.data[0].b64_json)
Path("peaches.png").write_bytes(image_bytes)

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

चार आर्गुमेंट्स काम करते हैं। model इंजन चुनता है, prompt तस्वीर का वर्णन करता है, size पिक्सल डाइमेंशन तय करता है, और quality स्पीड और लागत को डिटेल के मुकाबले तौलता है। बाकी सब में एक समझदार डिफ़ॉल्ट है, और आउटपुट फ़ॉर्मेट PNG रहता है जब तक आप कुछ और न माँगें।

ऐसे प्रॉम्प्ट लिखें जो टिकें

डेमो में चलने वाला प्रॉम्प्ट पचास इमेज के लूप में बिखर सकता है। चार आदतें नतीजों को स्थिर रखती हैं:

• पहले सब्जेक्ट बताएँ, फिर सेटिंग, रोशनी और लेंस। "लिनन के कपड़े पर पके आड़ू की सिरेमिक कटोरी, बाईं ओर से आती नरम खिड़की की रोशनी, 50mm फ़ोटोग्राफ़" विशेषणों की सूची से बेहतर है।
• जो टेक्स्ट इमेज में दिखना ज़रूरी है, उसे कोट करें, और उसे एक-दो शब्दों तक रखें।
• जिससे बचना है, उसे सकारात्मक शब्दों में बताएँ। "सादी सफ़ेद दीवार" का नतीजा "कोई बेतरतीब सामान नहीं" से बेहतर रहता है।
• हर रन में एक ही चीज़ बदलें। अगर आप सब्जेक्ट, रोशनी और साइज़ एक साथ बदलते हैं, तो पता नहीं चलेगा कि कौन-सा बदलाव काम आया।

रिस्पॉन्स base64 क्यों है

GPT Image मॉडल हमेशा base64 लौटाते हैं। DALL-E वाला response_format="url" विकल्प यहाँ समर्थित नहीं है, इसलिए result.data[0].url मौजूद ही नहीं है, और इमेज खुद b64_json के अंदर आती है। इससे तीन आदतें बनती हैं:

• एक बार डिकोड करें, फिर डिस्क पर लिखें। base64.b64decode आपको रॉ बाइट्स देता है, जिन्हें आप सेव कर सकते हैं, अपलोड कर सकते हैं या Pillow को दे सकते हैं।
• फ़ाइल खुद होस्ट करें। अगर ब्लॉग या ऐप को सार्वजनिक लिंक चाहिए, तो बाइट्स अपने स्टोरेज (S3, R2, CDN) पर भेजें और वह URL सेव करें।
• जल्दी प्रीव्यू के लिए डिस्क छोड़ें। f"data:image/png;base64,{b64}" से data URI बनाएँ और उसे <img> टैग में डालें।

💡 पुराना कोड माइग्रेट कर रहे हैं? अपने प्रोजेक्ट में .url और response_format खोजने से लगभग हर वह लाइन मिल जाती है जिसे बदलना है।

साइज़, क्वालिटी और आउटपुट फ़ॉर्मेट

ये पैरामीटर तय करते हैं कि आपको क्या मिलेगा और उसकी लागत कितनी होगी। डॉक्स में प्रकाशित पूरी सूची यह रही:

कुछ व्यावहारिक नियम:

• लैंडस्केप और पोर्ट्रेट। 1536x1024 और 1024x1536 ज़्यादातर ब्लॉग और सोशल फ़ॉर्मेट में फ़िट होते हैं। असली 16:9 के लिए 2048x1152 माँगें: दोनों किनारे 16 के गुणज हैं और पिक्सल संख्या अनुमत सीमा के भीतर अच्छी तरह रहती है।
• सस्ते में आज़माएँ, अच्छी क्वालिटी पर फ़िनिश करें। प्रॉम्प्ट के ड्राफ़्ट quality="low" पर बनाएँ, फिर जीतने वाले प्रॉम्प्ट को high पर दोबारा चलाएँ। आप आउटपुट टोकन के लिए भुगतान करते हैं, और ऊँची क्वालिटी ज़्यादा टोकन बनाती है।
• मंज़िल के हिसाब से फ़ॉर्मेट चुनें। एडिटिंग और पारदर्शिता के लिए PNG रखें, और जिन पेजों को जल्दी लोड होना है उनके लिए output_compression=85 के साथ webp पर जाएँ।

मास्क से मौजूदा इमेज एडिट करें

एक इमेज एडिट करें

images.edit एक सोर्स फ़ाइल और बदलाव बताने वाला प्रॉम्प्ट लेता है। जब आप कई रेफ़रेंस मिलाना चाहें, तो फ़ाइलों की सूची पास करें।

with open("living-room.png", "rb") as photo:
    edited = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=photo,
        prompt="Swap the grey sofa for a green velvet armchair, keep the window light unchanged",
    )

Path("living-room-edit.png").write_bytes(base64.b64decode(edited.data[0].b64_json))

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

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

मास्क जोड़ें

मास्क एडिट को एक हिस्से तक सीमित रखता है। यह एक PNG है जिसमें अल्फ़ा चैनल होता है और जिसके डाइमेंशन सोर्स जैसे ही होते हैं। पूरी तरह पारदर्शी पिक्सल वह एरिया बताते हैं जिसे दोबारा पेंट करना है; जो कुछ अपारदर्शी है वह सुरक्षित रहता है। Pillow इसे कुछ लाइनों में बना देता है:

from PIL import Image, ImageDraw

base = Image.open("living-room.png").convert("RGBA")
mask = Image.new("RGBA", base.size, (0, 0, 0, 255))          # opaque: keep
ImageDraw.Draw(mask).rectangle((620, 380, 1180, 900), fill=(0, 0, 0, 0))  # transparent: repaint
mask.save("mask.png")

with open("living-room.png", "rb") as photo, open("mask.png", "rb") as hole:
    edited = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=photo,
        mask=hole,
        prompt="A green velvet armchair with a wooden side table, matching the room's light",
    )

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

मास्क एक दिशा-निर्देश है, कोई सख़्त कटिंग नहीं। किनारे थोड़े बह सकते हैं, इसलिए जिस ऑब्जेक्ट को बदलना है उसके चारों ओर थोड़ा मार्जिन छोड़ें।

स्ट्रीमिंग प्रीव्यू और बैच

इंतज़ार के दौरान आंशिक इमेज

हाई क्वालिटी रेंडर में समय लग सकता है। stream=True और partial_images के साथ API अंतिम तस्वीर से पहले ड्राफ़्ट फ़्रेम भेजता है, ताकि इंटरफ़ेस स्पिनर की जगह प्रगति दिखा सके।

stream = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt="A vintage red bicycle leaning on a brick wall, golden hour, 35mm photograph",
    size="1536x1024",
    quality="high",
    stream=True,
    partial_images=2,
)

for event in stream:
    if event.type == "image_generation.partial_image":
        Path(f"preview-{event.partial_image_index}.png").write_bytes(base64.b64decode(event.b64_json))
    else:
        Path("final.png").write_bytes(base64.b64decode(event.b64_json))

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

प्रीव्यू टोकन की गिनती बढ़ा सकते हैं, इसलिए हर रिक्वेस्ट के लिए स्ट्रीमिंग चालू करने से पहले usage की तुलना स्ट्रीमिंग के साथ और उसके बिना करें।

बिना रेट एरर के async बैच

प्रॉम्प्ट की सूची के लिए AsyncOpenAI और एक semaphore मिलकर एक साथ चलने वाली रिक्वेस्ट की संख्या को नियंत्रित रखते हैं:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(max_retries=4, timeout=180)
gate = asyncio.Semaphore(3)

async def render(index: int, prompt: str) -> Path:
    async with gate:
        result = await client.images.generate(
            model="gpt-image-2.5-flare", prompt=prompt, size="1536x1024", quality="low",
        )
    path = Path(f"batch-{index:02d}.png")
    path.write_bytes(base64.b64decode(result.data[0].b64_json))
    return path

async def main(prompts: list[str]) -> list[Path]:
    return await asyncio.gather(*(render(i, p) for i, p in enumerate(prompts)))

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

Semaphore कॉन्करेंसी (concurrency) को सीमित करता है, प्रति मिनट इमेज को नहीं। कम उपयोग वाले टियर पर मिनट की सीमा सबसे पहले लगती है, इसलिए max_retries बढ़ाएँ और SDK को बैकऑफ़ करने दें। जब आउटपुट का इंतज़ार कोई नहीं कर रहा हो, तो इन मॉडलों में Batch endpoint समर्थित है और वह आउटपुट टोकन आधी कीमत पर बिल करता है।

लागत, सीमाएँ और एरर

मॉडल के अनुसार टोकन रेट

OpenAI इन मॉडलों की कीमत इमेज के हिसाब से नहीं, टोकन के हिसाब से तय करता है, और मौजूदा मॉडलों के लिए प्रति-इमेज टेबल प्रकाशित नहीं करता। प्रति 1M टोकन रेट:

साइज़ और क्वालिटी से तय होता है कि एक तस्वीर कितने आउटपुट टोकन इस्तेमाल करती है, इसीलिए low और high पर एक ही प्रॉम्प्ट की लागत बहुत अलग हो सकती है।

कोड में खर्च ट्रैक करें

रिस्पॉन्स में टोकन गिनती वाला एक usage ऑब्जेक्ट होता है। हर कॉल के बाद उसे डॉलर में बदलें और इनवॉइस से कभी चौंकेंगे नहीं:

RATES = {"text_in": 5.00, "image_in": 8.00, "image_out": 30.00}  # USD per 1M tokens

def cost_usd(usage) -> float:
    details = usage.input_tokens_details
    return (
        details.text_tokens * RATES["text_in"]
        + details.image_tokens * RATES["image_in"]
        + usage.output_tokens * RATES["image_out"]
    ) / 1_000_000

print(f"Last image: ${cost_usd(result.usage):.4f}")

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

रेट लिमिट आपके उपयोग टियर पर निर्भर करती है। gpt-image-2.5-flare के लिए मॉडल पेज लिखे जाने के समय ये सीमाएँ सूचीबद्ध करता है:

एरर जिनसे आपका सामना होगा

प्रोडक्शन में मायने रखने वाले तीन को पकड़ें:

import openai

try:
    result = client.images.generate(model="gpt-image-2.5-flare", prompt=prompt, size="1536x1024")
except openai.BadRequestError as err:
    print("Rejected:", err.message)
except openai.RateLimitError:
    print("Image limit reached, slow down")
except openai.APIConnectionError:
    print("Network problem, retry later")

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

PicassoIA पर GPT Image 2 कैसे इस्तेमाल करें

प्रॉम्प्ट के प्रयोगों पर API बजट खर्च करने से पहले उन्हें ब्राउज़र में चलाएँ। PicassoIA पर GPT Image 2 इमेज के भीतर पढ़ने योग्य टेक्स्ट रेंडर करता है, पारदर्शी बैकग्राउंड सपोर्ट करता है, रेफ़रेंस इमेज स्वीकार करता है और एक रन में 10 वेरिएशन तक बनाता है।

कोड के बिना प्रॉम्प्ट प्रोटोटाइप करें

1. मॉडल पेज खोलें और अपना प्रॉम्प्ट लिखें। जो टेक्स्ट इमेज के अंदर दिखना ज़रूरी है उसे कोट में रखें।
2. ड्राफ़्ट के लिए क्वालिटी low पर सेट करें। फ़ाइनल रेंडर के लिए high पर जाएँ।
3. आस्पेक्ट रेशियो चुनें: 3:2 या 2:3 1536x1024 और 1024x1536 को दर्शाते हैं, और 16:9 वाइडस्क्रीन फ़्रेम देता है।
4. आउटपुट फ़ॉर्मेट चुनें। WebP डिफ़ॉल्ट है, PNG पारदर्शिता को साफ़ रखता है।
5. इमेज की संख्या 1 से 10 के बीच सेट करें, फिर जनरेट करें।
6. अगर आप शून्य से बनाने के बजाय एडिट करना चाहते हैं, तो रेफ़रेंस इमेज अपलोड करें।

फ़ॉर्म फ़ील्ड Python कॉल से मेल खाते हैं, इसलिए जो रेसिपी ब्राउज़र में चलती है वह सीधे कोड में आ जाती है:

एक वैकल्पिक फ़ील्ड आपका अपना OpenAI credential स्वीकार करता है; उसे खाली छोड़ें तो PicassoIA proxy रिक्वेस्ट संभालता है।

दो और आदतें फ़ायदेमंद हैं। पहली, एक भाषा मॉडल से प्रॉम्प्ट का ड्राफ़्ट बनाएँ: कच्चा विचार GPT 5 या Claude Sonnet 4.6 में डालें और लेंस, रोशनी और फ़्रेमिंग के साथ तीन फ़ोटोग्राफ़िक वेरिएंट माँगें। दूसरी, वही प्रॉम्प्ट PicassoIA Image और Seedream 4.5 पर चलाएँ और देखें कि आपके प्रोजेक्ट में कौन-सी स्टाइल फ़िट बैठती है। बिना कोड के एडिट के लिए, PicassoIA Image Editor Pro फ़ोटो में बदलाव सीधे ब्राउज़र में करता है।

PicassoIA डेवलपर API

अगर आपकी पाइपलाइन को कोई अलग प्रोवाइडर चाहिए, तो PicassoIA का अपना डेवलपर API है जिसका ढाँचा Replicate जैसा है:

• Base URL: https://api.picassoia.com/v1
• Auth: एक Bearer टोकन जो pia_sk_ से शुरू होता है
• फ़्लो: POST /v1/models/{owner}/{name}/predictions से prediction बनाएँ, GET /v1/predictions/{id} पर poll करें, फिर नतीजा पढ़ें
• सीमा: प्रति अकाउंट 5 एक साथ चलने वाले predictions

ये जॉब एसिंक्रोनस हैं, इसलिए ऊपर लिखी एकल ब्लॉकिंग कॉल की जगह create-then-poll लूप आता है। इस पर कुछ बनाने से पहले PicassoIA API पेज पर प्लान की ज़रूरतें जाँच लें।

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

अब आपके पास एक काम करने वाली पाइपलाइन है: SDK इंस्टॉल करें, organization वेरिफ़ाई करें, इमेज माँगें, base64 डिकोड करें, size और quality को ट्यून करें, मास्क से एडिट करें, प्रीव्यू स्ट्रीम करें, सीमाओं के साथ बैच चलाएँ और खर्च लॉग करें। नतीजे सुधारने का सबसे तेज़ तरीका ज़्यादा कोशिशें करना है। दस प्रॉम्प्ट लिखें, उन्हें low पर चलाएँ, दो सबसे अच्छे रखें और उन्हें high पर दोबारा रेंडर करें।

अगर आप API छूने से पहले प्रॉम्प्ट टेस्ट करना चाहते हैं, तो PicassoIA पर GPT Image 2 खोलें, कुछ वेरिएशन बनाएँ, और PicassoIA मॉडल लाइब्रेरी में दूसरे मॉडलों से तुलना करें। जब आपकी पसंद की स्टिल इमेज तैयार हो जाएँ, तो PicassoIA का इफ़ेक्ट्स कलेक्शन उन पर मोशन और स्टाइल जोड़ सकता है। कोई ऐसा विषय चुनें जो आपके लिए मायने रखता हो, एक विस्तृत प्रॉम्प्ट लिखें और देखें कि क्या सामने आता है।