AI इमेज जनरेटर ऐप बनाने की व्यावहारिक योजना: रिक्वेस्ट लूप, एक हफ़्ते में शिप होने वाला स्टैक, काम करने वाले Node कोड के साथ इमेज API जोड़ने का तरीका, और मासिक बजट जो लॉन्च से पहले दिखाता है कि हर जनरेशन पर असल में कितना खर्च आता है।
AI इमेज जनरेटर ऐप बाहर से देखने पर एक बड़ा प्रोडक्ट लगता है और अंदर से एक छोटा। एक व्यक्ति एक वाक्य टाइप करता है, आपका सर्वर उसे एक मॉडल को सौंपता है, कुछ सेकंड बाद एक तस्वीर वापस आती है, और आप उसे कहीं सहेज देते हैं जहाँ व्यक्ति उसे दोबारा ढूँढ सके। बाकी सब पॉलिश है: अकाउंट, गैलरी, क्रेडिट, और दुरुपयोग रोकने का तरीका। ज़्यादातर बिल्डरों को जो बात चौंकाती है वह कोड नहीं है। वह बिल है। प्रति इमेज लागत, जिसे इस बात से गुणा किया जाए कि लोग बटन कितनी बार दबाते हैं, यही तय करता है कि ऐप कमाई करता है या पैसा जलाता है।
यह लेख एक ऐसा टूल्स का सेट बताता है जिसे आप एक हफ़्ते में बना सकते हैं, दिखाता है कि API कॉल्स PicassoIA API के साथ काम करने वाले कोड से कैसे जुड़ती हैं, और मासिक लागत का ईमानदार हिसाब देता है ताकि आप लॉन्च के दिन से पहले प्रोडक्ट की कीमत तय कर सकें।
ब्रांडिंग हटा दें तो हर इमेज जनरेटर ऐप एक ही काम करता है: वह टेक्स्ट अनुरोध को एक फ़ाइल में बदलता है, और यह काम इस तरह करता है कि व्यक्ति को जमी हुई स्क्रीन पर इंतज़ार न करना पड़े। एक बार जब आप ऐप को गैलरी के साथ जुड़ा एक रिक्वेस्ट लूप के रूप में देख लेते हैं, तो बिल्ड काफ़ी छोटा हो जाता है।
succeeded दिखाए, तब वह फ़ाइल को आपके अपने स्टोरेज में कॉपी करता है।
आगे आप जो भी फ़ीचर जोड़ेंगे, वह इन्हीं पाँच चरणों के ऊपर बैठेगा। क्रेडिट चरण 2 से जुड़ते हैं। गैलरी चरण 5 से जुड़ती है। वीडियो जनरेशन वही लूप है, बस चरण 4 धीमा होता है।
सबसे छोटा वर्ज़न चुनें जिसके लिए कोई व्यक्ति पैसे दे। हर अतिरिक्त इनपुट प्रकार बैकएंड पर काम बढ़ाता है।
| प्रोडक्ट का आकार | यूज़र क्या करते हैं | आपके लिए अतिरिक्त काम |
|---|---|---|
| सिर्फ़ प्रॉम्प्ट बॉक्स | एक वाक्य टाइप करें, एक तस्वीर पाएँ | क्यू, गैलरी, कोटा |
| प्रॉम्प्ट के साथ एडिटिंग | एक फ़ोटो अपलोड करें और उसे बदलें | अपलोड लिमिट, फ़ाइल जाँच, PicassoIA Image Editor Pro जैसा एडिटिंग मॉडल |
| इमेज के साथ छोटा वीडियो | एक नतीजे को क्लिप में बदलें | लंबे जॉब, बड़ी फ़ाइलें, PicassoIA Video जैसा वीडियो मॉडल |
💡 एक इनपुट बॉक्स और एक बटन से शुरू करें। बाद में जोड़े गए फ़ीचर उन फ़ीचर्स से सस्ते पड़ते हैं जिन्हें यूज़र्स उन पर निर्भर हो जाने के बाद निकालना पड़े।
यहाँ सीधे-सादे टूल्स ही जीतते हैं। मॉडल कठिन काम करता है, इसलिए आपके टूल्स के सेट को बस भरोसेमंद, चलाने में सस्ता और आसानी से बदलने लायक होना चाहिए, ताकि अगले महीने कोई बेहतर मॉडल आए तो बदलाव आसान रहे।
Next.js जैसा React फ़्रेमवर्क एक ही प्रोजेक्ट में प्रॉम्प्ट पेज, गैलरी और सर्वर रूट्स दे देता है। अगर आपके ज़्यादातर यूज़र फ़ोन पर होंगे, तो पहले इसे प्रोग्रेसिव वेब ऐप के रूप में शिप करें, और React Native या Flutter की तरफ़ तभी जाएँ जब आपको कैमरा या फ़ाइल तक गहरी पहुँच चाहिए। स्क्रीन खुद सरल है: एक टेक्स्ट बॉक्स, एक साइज़ पिकर, एक बटन और एक ग्रिड।
Node या Python में से वह चुनें जो आपकी टीम पहले से लिखती है। जिस एक चीज़ को आप छोड़ नहीं सकते वह है जॉब क्यू। सामान्य वेब रिक्वेस्ट की तुलना में इमेज जनरेशन धीमी होती है, और इमेज API एक साथ चलने वाले जॉब्स की संख्या सीमित करते हैं। एक क्यू (Redis with BullMQ, या Python पर Celery) आपको हर क्लिक तुरंत स्वीकार करने देती है और API को सुरक्षित रफ़्तार से काम भेजती है।
Postgres में एक generations टेबल रखें, जिसमें ये कॉलम हों: id, user_id, prompt, model, status, cost_usd, image_url, created_at। यही एक टेबल गैलरी, कोटा जाँच और आपकी लागत रिपोर्ट को चलाती है।
हर तैयार इमेज को CDN के पीछे अपनी बकेट में कॉपी करें। किसी प्रोवाइडर के अस्थायी URL के हमेशा चालू रहने पर निर्भर न रहें। ओरिजिनल के साथ एक छोटा WebP थंबनेल भी सहेजें, ताकि गैलरी मोबाइल पर तेज़ लोड हो।
| लेयर | सरल विकल्प | कब आगे बढ़ें |
|---|---|---|
| फ़्रंट एंड | Next.js या सादा React | जब आपको नेटिव डिवाइस फ़ीचर्स चाहिए |
| API लेयर | Node (Fastify) या FastAPI | जब ट्रैफ़िक के लिए अलग वर्कर चाहिए |
| क्यू | Redis with BullMQ या Celery | जब आप एक से ज़्यादा प्रोवाइडर को कॉल करते हैं |
| डेटाबेस | Postgres | जब रिपोर्टिंग भारी हो जाए |
| स्टोरेज | S3-compatible बकेट और CDN | जब यूज़र्स कई रीजन में हों |
| साइन-इन | Email links या OAuth | जब आप टीम अकाउंट बेचते हैं |
आप मॉडल को हर कॉल के हिसाब से किराए पर ले सकते हैं या अपने GPUs चला सकते हैं। पहली रिलीज़ के लिए जवाब लगभग हमेशा पहला ही होता है।
होस्टेड API का मतलब है कोई ड्राइवर नहीं, स्केलिंग का काम नहीं, एक ही इंटरफ़ेस के पीछे कई मॉडल, और आप हर इमेज के हिसाब से भुगतान करते हैं। किराए का GPU मतलब है एक तय घंटे का बिल और कामों की लंबी सूची: मॉडल वेट्स, मेमोरी लिमिट, अपडेट, क्यू, रात 3 बजे का क्रैश।
हिसाब ही फ़ैसला करता है। मान लें किराए के GPU की लागत $1.50 प्रति घंटा है और वह प्रति घंटे 120 इमेज बनाता है। अगर वह कभी खाली नहीं बैठता, तो हर तस्वीर की लागत लगभग $0.0125 है। अगर वह सिर्फ़ 20% समय व्यस्त रहता है, तो आप असल में प्रति घंटे 24 इमेज बना रहे हैं और हर एक की लागत $0.0625 है। ये उदाहरण के आँकड़े हैं, लेकिन नतीजे का आकार यही रहता है: सेल्फ़-होस्टिंग तभी फ़ायदेमंद है जब ट्रैफ़िक स्थिर और भारी हो।
PicassoIA पर टेक्स्ट-टू-इमेज कलेक्शन में 200 से ज़्यादा मॉडल हैं, जो उपयोगी है क्योंकि कोई एक मॉडल हर काम में सबसे अच्छा नहीं है। एक डिफ़ॉल्ट चुनें और एक या दो विकल्प एक सेटिंग के पीछे रखें, ताकि क्वालिटी, स्पीड या कीमत बदलने पर आप स्विच कर सकें।
| मॉडल | इसे आज़माएँ |
|---|---|
| PicassoIA Image | सामान्य डिफ़ॉल्ट, PicassoIA API के ज़रिए उपलब्ध |
| P Image | कम लागत में तेज़ फ़ोटोग्राफ़िक नतीजे |
| FLUX Schnell | तेज़ ड्राफ़्ट और प्रीव्यू |
| FLUX 2 Pro | उच्च क्वालिटी की अंतिम इमेज |
| Seedream 5 Pro | विस्तृत दृश्य, जिन्हें आपके डिफ़ॉल्ट से तुलना करना उपयोगी है |
| GPT Image 2 | ऐसे प्रॉम्प्ट जिनमें साफ़ निर्देश हों या तस्वीर में छोटा टेक्स्ट हो |
| Imagen 4 Fast | एक त्वरित विकल्प, जिसका लुक अलग है |
ज़्यादातर लोग प्रॉम्प्ट "समुद्र तट पर एक कुत्ता" जैसा लिखते हैं। एक छोटा लैंग्वेज मॉडल इसे इमेज कॉल से पहले एक समृद्ध प्रॉम्प्ट में फैला सकता है, और उसकी लागत एक सेंट के एक हिस्से जितनी है। Claude Sonnet 5 और Gemini 3.5 Flash दोनों इस काम के लिए ठीक हैं, और जब आपको रीराइट को सब्जेक्ट, लाइटिंग और लेंस जैसे फ़ील्ड्स में बाँटना हो, तो GPT 5 Structured साफ़ JSON लौटाता है।
उसी मॉडल परिवार का एक दूसरा काम भी हो सकता है: इमेज मॉडल तक पहुँचने से पहले प्रॉम्प्ट की जाँच करना। इस पर आगे और बात होगी।
PicassoIA एक Replicate-style REST API देता है, इसलिए फ़्लो वही है जो रिक्वेस्ट लूप में था: प्रेडिक्शन बनाएँ, उसे पोल करें, नतीजा लाएँ। नीचे दिए एंडपॉइंट्स और लिमिट्स सार्वजनिक API पेज से लिए गए हैं, और शिप करने से पहले विवरण की पुष्टि उसी पेज पर करें।
कोई कोड लिखने से पहले, मॉडल को हाथ से टेस्ट करें। इसमें दस मिनट लगते हैं और दिनों का अंदाज़ा लगाने से बचाते हैं।
💡 अगर आपका ऐप फ़ोटो एडिट करता है, तो स्टॉक सैंपल की जगह असली अपलोड के साथ PicassoIA Image Editor Pro पर भी यही टेस्ट दोहराएँ।
बेस URL https://api.picassoia.com/v1 है। हर रिक्वेस्ट में एक Authorization: Bearer हेडर होता है, जिसमें pia_sk_ से शुरू होने वाला एक सीक्रेट रहता है। आप इसे अकाउंट के API पेज पर बनाते हैं, और एक अकाउंट में अधिकतम दो हो सकते हैं, इसलिए एक-एक करके रोटेट करें। वह सीक्रेट कभी ब्राउज़र या मोबाइल कोड में न डालें। वह आपके सर्वर पर, एनवायरनमेंट वेरिएबल में होना चाहिए। API एक्सेस के लिए प्लान की आवश्यकताएँ और कीमतें उसी पेज पर सूचीबद्ध हैं और बदल सकती हैं, इसलिए उस पर आधारित बजट बनाने से पहले उन्हें पढ़ लें।
चार मॉडल API के ज़रिए उपलब्ध हैं:
| मॉडल | आउटपुट |
|---|---|
| PicassoIA Image | टेक्स्ट से इमेज |
| PicassoIA Image Editor Pro | एडिट की गई इमेज |
| PicassoIA Video | टेक्स्ट या इमेज से वीडियो |
| Seedance 2.5 Lite | ऑडियो के साथ वीडियो |
सीमाओं के हिसाब से योजना बनाएँ:
| लिमिट | मान |
|---|---|
| एक साथ चलने वाले प्रेडिक्शन | 5 प्रति अकाउंट, सभी सीक्रेट्स और MCP कनेक्शन में साझा |
| रिक्वेस्ट बॉडी | 10 MB |
| प्रॉम्प्ट की लंबाई | 4,000 कैरेक्टर |
| जॉब टाइमआउट | 3 घंटे |
पाँच जॉब्स की यह सीमा आपके पूरे आर्किटेक्चर को आकार देती है, इसी कारण पहले बताई गई क्यू ज़रूरी है, वैकल्पिक नहीं।
एंडपॉइंट्स हैं: जॉब शुरू करने के लिए POST /v1/models/{owner}/{name}/predictions, उसे पढ़ने के लिए GET /v1/predictions/{id}, उसे रोकने के लिए POST /v1/predictions/{id}/cancel और हाल के जॉब्स की सूची के लिए GET /v1/predictions। Node 18 या उससे नए में पूरा लूप यह रहा:
const BASE = "https://api.picassoia.com/v1";
const headers = {
Authorization: `Bearer ${process.env.PICASSOIA_TOKEN}`,
"Content-Type": "application/json",
};
async function call(url, options) {
const res = await fetch(url, { headers, ...options });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
return res.json();
}
export async function generate(prompt) {
const created = await call(
`${BASE}/models/picassoia/picassoia-image/predictions`,
{
method: "POST",
body: JSON.stringify({ input: { prompt, aspect_ratio: "16:9" } }),
}
);
let job = created;
while (!["succeeded", "failed", "canceled"].includes(job.status)) {
await new Promise((r) => setTimeout(r, 2000));
job = await call(`${BASE}/predictions/${created.id}`);
}
if (job.status !== "succeeded") throw new Error(job.error ?? job.status);
return Array.isArray(job.output) ? job.output[0] : job.output;
}
उस कोड पर दो नोट्स। पहला, इनपुट फ़ील्ड के नाम मॉडल-दर-मॉडल अलग होते हैं, इसलिए हर मॉडल का पेज पढ़कर उनसे हूबहू मेल करें। दूसरा, प्रोडक्शन में पोलिंग शुरू होने से पहले created.id को अपने डेटाबेस में सहेजें, ताकि सर्वर रीस्टार्ट होने पर कोई भुगतान किया गया जॉब न खोए।
लागत दो समूहों में बँटती है: वेरिएबल लागत जो हर क्लिक के साथ बढ़ती है, और फ़िक्स्ड लागत जो स्थिर रहती है। वेरिएबल लागत ही खतरनाक है।
मुख्य फ़ॉर्मूला छोटा है:
मासिक लागत = यूज़र × हर यूज़र की जनरेशन × प्रति इमेज लागत + फ़िक्स्ड लागत
जिस शब्द पर नज़र रखनी है वह है जनरेशन। लोग हर उस एक तस्वीर के लिए बटन कई बार दबाते हैं जिसे वे रखते हैं, इसलिए अपनी बीटा के पहले दिन से हर रखी गई इमेज पर जनरेशन मापें और उसी आँकड़े से बजट बनाएँ, सहेजी गई तस्वीरों की संख्या से नहीं।
मान लें 2,000 सक्रिय यूज़र हैं जिनमें से हर एक महीने में 20 जनरेशन करता है। यानी 40,000 इमेज। नीचे की कीमतें योजना के अनुमान हैं, इसलिए आप जिस मॉडल को चुनें उसकी मौजूदा दर डाल लें। इस आकार के लिए होस्टिंग, डेटाबेस और स्टोरेज की फ़िक्स्ड लागत $100 प्रति माह रखी गई है।
| स्थिति | अनुमानित प्रति इमेज कीमत | इमेज का बिल | $100 फ़िक्स्ड के साथ | $2,700 राजस्व के साथ नतीजा |
|---|---|---|---|---|
| तेज़ ड्राफ़्ट मॉडल | $0.01 | $400 | $500 | +$2,200 |
| मिड-रेंज मॉडल | $0.04 | $1,600 | $1,700 | +$1,000 |
| प्रीमियम मॉडल | $0.08 | $3,200 | $3,300 | -$600 |
राजस्व का आँकड़ा मानता है कि 2,000 में से 300 यूज़र हर महीने $9 देते हैं। प्रीमियम वाली पंक्ति में घाटा होता है, भले ही ऐप स्वस्थ दिखे, क्योंकि फ़्री यूज़र भी तस्वीरें बनाते हैं। तीन उपाय एक साथ अच्छी तरह काम करते हैं: फ़्री टियर पर सीमा लगाएँ, हर मॉडल की असली कीमत के हिसाब से क्रेडिट बेचें, और ड्राफ़्ट रिक्वेस्ट सस्ते मॉडल को भेजें, जबकि प्रीमियम मॉडल को अंतिम रेंडर के लिए रखें।
ऐसी लागतें जिन्हें लोग भूल जाते हैं:
स्पीड और सुरक्षा शुरू में जोड़ना सस्ता है और लॉन्च के बाद जोड़ना दर्दनाक।
हर PicassoIA अकाउंट पर पाँच एक साथ चलने वाले प्रेडिक्शन के साथ, आपका ऐप कितनी सहजता से चलेगा यह क्यू तय करती है। मान लें एक इमेज में लगभग 10 सेकंड लगते हैं। तब पाँच जॉब्स एक साथ लगभग 30 इमेज प्रति मिनट, या 1,800 प्रति घंटा देते हैं। ऊपर के बजट की 40,000 इमेज औसतन लगभग 55 प्रति घंटा बैठती हैं। औसत से पाँच गुना भीड़ वाला रश आवर, लगभग 280 इमेज, भी काफ़ी गुंजाइश के साथ समा जाता है।
क्यू को स्वस्थ रखने वाले नियम:
प्रॉम्प्ट को इमेज मॉडल तक पहुँचने से पहले जाँचें। Llama Guard 4 12B जैसा एक सेफ़्टी क्लासिफ़ायर टेक्स्ट पढ़ता है और उन श्रेणियों को चिह्नित करता है जिन्हें आप ब्लॉक करना चुनते हैं। यह सस्ता और तेज़ है, और आपके अकाउंट को परेशानी से बचाता है।
अगर यूज़र फ़ोटो अपलोड कर सकते हैं, तो अपलोड की भी समीक्षा करें। हर इनकार को यूज़र id और कारण के साथ लॉग करें, क्योंकि उन लॉग्स के पैटर्न बताते हैं कि कौन आपकी सीमाएँ परख रहा है।
दो अपग्रेड जो अपनी लागत खुद वसूल लेते हैं:
अगर दायरा कसा रहे तो एक छोटी टीम सात दिनों में निजी बीटा शिप कर सकती है।
| दिन | काम |
|---|---|
| 1 | एक डिफ़ॉल्ट मॉडल चुनें और हाथ से 20 असली प्रॉम्प्ट टेस्ट करें |
| 2 | बैकएंड रूट बनाएँ जो प्रेडिक्शन बनाए और उसे पोल करे |
| 3 | स्टोरेज, थंबनेल और गैलरी पेज जोड़ें |
| 4 | साइन-इन, दैनिक कोटा और हर जनरेशन की लागत लॉगिंग जोड़ें |
| 5 | प्रॉम्प्ट मॉडरेशन और प्रति-यूज़र रेट लिमिट जोड़ें |
| 6 | क्रेडिट या एक सरल पेमेंट लिंक जोड़ें |
| 7 | 20 टेस्टर्स को आमंत्रित करें और लॉग्स साथ मिलकर पढ़ें |
सबसे ज़्यादा समय खाने वाली गलतियाँ: यह साबित करने से पहले कस्टम मॉडल पाइपलाइन बनाना कि कोई प्रोडक्ट चाहता भी है, बीस जगहों पर एक मॉडल का नाम हार्डकोड करना, और हर जनरेशन की लागत लॉग करना भूल जाना। आखिरी वाली को चौथे दिन ठीक करें, तो आगे के हर फ़ैसले आसान हो जाते हैं, क्योंकि आप देख पाएँगे कि कौन से प्रॉम्प्ट, यूज़र और मॉडल बिल को बढ़ाते हैं।
किसी मॉडल को परखने का सबसे तेज़ तरीका है उसे इस्तेमाल करना। PicassoIA Image खोलें, वह प्रॉम्प्ट टाइप करें जो एक असली यूज़र टाइप करेगा, और देखें कि क्या आता है। फिर पूरी मॉडल सूची से दो या तीन और मॉडलों पर वही प्रॉम्प्ट आज़माएँ और क्वालिटी, स्पीड और स्टाइल की साथ-साथ तुलना करें।
जब नतीजे सही लगें, तो PicassoIA API पेज पढ़ें, अपना पहला सीक्रेट बनाएँ और ऊपर वाला Node स्निपेट चलाएँ। एक प्रॉम्प्ट, एक प्रेडिक्शन, और आपकी अपनी स्टोरेज में सहेजी एक इमेज: पूरा ऐप छोटे रूप में यही है, और उसके बाद का सब कुछ स्केलिंग है। आज ही प्रयोग शुरू करें, और आपके अपने कोड से बनी पहली तस्वीर आपको किसी भी योजना से ज़्यादा बता देगी।
अपनी भाषा चुनें
