AI UGC Video Generator API से UGC विज्ञापन अपने-आप बनाएँ

कुछ समय पहले ब्रांड्स ने पॉलिश्ड स्टूडियो विज्ञापनों पर भरोसा करना छोड़ दिया था, और दर्शकों ने उन्हें देखना उससे भी पहले छोड़ दिया था। जो चीज़ किसी की उँगली को स्क्रॉल करते-करते रोकती है, वह है रसोई में खड़ी एक महिला, जो अपने शब्दों में बताती है कि एक सीरम उसके लिए आखिरकार क्यों काम कर गया। यही UGC (user generated content) शैली का विज्ञापन है, और इसी वजह से परफ़ॉर्मेंस टीमें अब उन स्प्रेडशीट्स की जगह, जिनमें क्रिएटर्स प्रोडक्ट सैंपल का इंतज़ार करते रहते हैं, एक AI UGC video generator API चाहती हैं।

यह लेख एक ऐसी पाइपलाइन का खाका देता है जिसे आप इसी हफ़्ते बना सकते हैं। इसमें एक प्रोडक्ट ब्रीफ़ अंदर जाता है और वर्टिकल, क्रिएटर-स्टाइल विज्ञापनों का ढेर बाहर आता है। आपको Python और Node में काम करने वाला रिक्वेस्ट कोड मिलेगा, PicassoIA डेवलपर API की असली सीमाएँ मिलेंगी, हर मॉडल क्या करता है, इसकी एक टेबल मिलेगी, और वे चेक भी मिलेंगे जो स्वचालित विज्ञापनों को ईमानदार और ब्रांड के अनुरूप रखते हैं।

UGC ऐड्स को API की ज़रूरत क्यों है

क्रिएटिव वॉल्यूम की समस्या

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

उस मैट्रिक्स के लिए इंसानी क्रिएटर्स बुक करने का मतलब है ब्रीफ़, शिपिंग, फ़ीडबैक के कई दौर और लंबा इंतज़ार। साठ वेरिएंट हाथ से काटने के लिए किसी एडिटर को कहने का मतलब है कि यह काम हर हफ़्ते नहीं, बल्कि हर तिमाही में एक बार ही हो पाता है।

💡 टिप: क्रिएटिव को इन्वेंट्री की तरह समझें। अगर नया बैच पहुँचने में तीन हफ़्ते लगते हैं, तो आप हमेशा कल के विजेता ही चला रहे होते हैं।

यहाँ दोनों तरीकों की व्यावहारिक तुलना है:

API क्या बदलता है

यह क्लिक करने का काम बदलता है। एक क्लिप के लिए डैशबोर्ड ठीक है, लेकिन कोई भी साठ प्रॉम्प्ट एक फ़ॉर्म में नहीं चिपकाना चाहता। API के साथ ब्रीफ़ एक स्प्रेडशीट, प्रोडक्ट फ़ीड या डेटाबेस रो में रहती है, और एक स्क्रिप्ट हर रो को एक रिक्वेस्ट में बदल देती है।

यह काम असिंक्रोनस होता है: आप एक प्रिडिक्शन बनाते हैं, उसकी स्थिति जाँचते (poll) हैं, फिर तैयार फ़ाइल लेते हैं। डेवलपर डॉक्स में वेबहुक का ज़िक्र नहीं है, इसलिए पोलिंग ही पूरा तंत्र है, और इससे इंटीग्रेशन छोटा रहता है।

बैच रन के आम ट्रिगर कुछ ऐसे दिखते हैं:

• आपके कैटलॉग में कोई नया प्रोडक्ट आता है जिसे लॉन्च सेट चाहिए।
• कोई जीतता हुआ विज्ञापन थकान दिखाने लगता है और उसके दस जुड़वाँ वेरिएंट चाहिए।
• कोई मौसमी ऑफ़र हर सक्रिय क्लिप का हुक बदल देता है।
• किसी नए बाज़ार को उसी स्क्रिप्ट के स्थानीय वर्ज़न चाहिए।

API प्रोडक्शन की जगह लेता है, फ़ैसला लेने की नहीं। कौन-से क्लेम सच हैं और कौन-सी क्लिप चलाने लायक़ अच्छी है, यह अब भी कोई इंसान तय करता है।

ब्रीफ़ से विज्ञापन तक की पाइपलाइन

इसे चार चरणों में सोचें, और हर चरण का एक इनपुट और एक आउटपुट हो। जब कोई चरण फ़ेल हो, तो सिर्फ़ उसी चरण को दोबारा चलाएँ, पूरी चेन को नहीं।

चरण 1: स्क्रिप्ट वेरिएंट

लाइनें लिखने के लिए कोई भी लार्ज लैंग्वेज मॉडल (LLM) इस्तेमाल करें, क्योंकि वीडियो API को इससे फ़र्क नहीं पड़ता कि शब्द कहाँ से आए हैं। उसे एक सख़्त ढाँचा दें: पहले दो सेकंड में एक हुक, एक समस्या, एक प्रूफ़ पॉइंट और एक कॉल टू एक्शन।

UGC असली इसलिए लगता है क्योंकि वह छोटा और ठोस होता है। "मैंने तीन प्रोडक्ट खरीदना बंद कर दिया और यही एक रखा" हर बार "अब तक का सबसे अच्छा सीरम" से बेहतर असर करता है। हर प्रोडक्ट के लिए एक दर्जन हुक माँगें, फिर उनमें से पाँच रखें जो किसी इंसान के बोलने जैसे लगें।

💡 टिप: हर स्क्रिप्ट में एक ही क्लेम रखें। हर अतिरिक्त क्लेम एक और वाक्य है जिसे कुछ भी लाइव होने से पहले सत्यापित करना होगा।

चरण 2: पर्सोना और सीन इमेज

पहला फ़्रेम तय करता है कि पूरी क्लिप कैसी दिखेगी, क्योंकि वीडियो मॉडल उसी से आगे की एनिमेशन बनाता है। पर्सोना फ़्रेम बनाने के लिए PicassoIA Image इस्तेमाल करें: एक ऐसा व्यक्ति जो रहने लायक़ कमरे में हो, खिड़की की रोशनी हो, हैंडहेल्ड फ़्रेमिंग हो, और हाथ में एक बिना ब्रैंड वाला प्रोडक्ट हो।

जब असली प्रोडक्ट दिखाना ज़रूरी हो, तब PicassoIA Image Editor Pro लाएँ। यह एक से चार इनपुट इमेज ले सकता है, इसलिए आप अपना असली पैकशॉट सीन में डाल सकते हैं और लेबल सही रख सकते हैं।

प्रॉम्प्ट एक फ़ोटोग्राफ़र की तरह लिखें: लेंस, रोशनी की दिशा, त्वचा और कपड़े की बनावट। चमकदार लुक को नकारें। UGC को कमियों वाले, असली कमरे और प्राकृतिक रोशनी चाहिए।

चरण 3: नेटिव ऑडियो के साथ वीडियो

फ़्रेम को Seedance 2.5 Lite में डालें, साथ में एक मोशन प्रॉम्प्ट दें जो बताए कि व्यक्ति क्लिप के दौरान क्या करता और कहता है। save_audio विकल्प डिफ़ॉल्ट रूप से चालू है, इसलिए बोली और कमरे की आवाज़ फ़ाइल के अंदर ही आ जाती है, किसी अलग पाइपलाइन स्टेप में नहीं।

क्रिया को क्रम में लिखें: वह बॉटल उठाती है, लेंस की ओर देखती है, लाइन बोलती है, मुस्कुराती है। स्क्रिप्ट की लंबाई भी क्लिप के हिसाब से रखें। दस सेकंड के वीडियो में स्वाभाविक रफ़्तार से लगभग 25 से 30 बोले गए शब्द आते हैं, इसलिए लंबी लाइन या तो जल्दी-जल्दी बोली जाएगी या कट जाएगी।

कैमरा मूवमेंट कम रखें। हल्का हैंडहेल्ड बहाव UGC की पहचान है, और भारी सिनेमैटिक मूव भ्रम तोड़ देते हैं।

चरण 4: रिव्यू और शिप

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

आज इस्तेमाल किए जा सकने वाले मॉडल

API मॉडल एक नज़र में

यह लिखे जाने के समय PicassoIA API चार मॉडल देता है। नीचे के इनपुट सार्वजनिक डेवलपर डॉक्स से लिए गए हैं।

विज्ञापनों के लिए दो बातें मायने रखती हैं। PicassoIA Video पर अधिकतम अवधि रिज़ॉल्यूशन पर निर्भर करती है: 480p पर 20 सेकंड तक, 720p पर 10 तक और 1080p पर 5 तक। Seedance 2.5 Lite पर वैकल्पिक last_frame_image आपको यह तय करने देता है कि क्लिप कहाँ खत्म हो, जो तब काम आता है जब आखिरी फ़्रेम में प्रोडक्ट दिखना ज़रूरी हो।

💡 टिप: जब आप इमेज पास करते हैं, तो aspect_ratio डिफ़ॉल्ट रूप से match_input_image पर होता है। आपकी स्टिल तय करती है कि विज्ञापन वर्टिकल होगा या स्क्वेयर, इसलिए किसी वीडियो जॉब पर पैसे लगाने से पहले पर्सोना फ़्रेम का आकार जाँच लें।

ऐप में वॉइस और लिप सिंक

व्यापक कैटलॉग API में नहीं, वेब ऐप में है। वहीं आपको समर्पित वॉइस और टॉकिंग-हेड टूल मिलते हैं, उन स्थितियों के लिए जहाँ नेटिव ऑडियो काफ़ी न हो।

• Speech 2.8 HD और ElevenLabs v3 स्टूडियो-क्वालिटी वॉइसओवर के लिए।
• Omni Human 1.5 और Fabric 1.0 किसी स्टिल फ़ोटो को बात करवाने के लिए।
• Lipsync 2 Pro किसी मौजूदा क्लिप की मुँह की हरकत को नए ऑडियो ट्रैक से मिलाने के लिए।

एक व्यावहारिक बँटवारा: API से ज़्यादातर क्लिप नेटिव ऑडियो के साथ बनवाएँ, और सबसे अच्छे पाँच या दस परफ़ॉर्मर्स को वॉइस और लिप सिंक की पॉलिश के लिए ऐप में ले जाएँ।

Python में आपका पहला रिक्वेस्ट

ऑथेंटिकेशन और बेस URL

सब कुछ https://api.picassoia.com/v1 पर जाता है, और हर रिक्वेस्ट के साथ एक Authorization: Bearer pia_sk_… हेडर होता है। सीक्रेट अपने अकाउंट के API पेज पर बनाएँ। एक अकाउंट में एक समय में दो सीक्रेट रह सकते हैं, इसलिए पुराने को हटाने से पहले नया बनाकर रोटेट करें।

सीक्रेट को अपने सर्वर पर एनवायरनमेंट वेरिएबल में रखें। इसे कभी ब्राउज़र बंडल या मोबाइल ऐप में न भेजें।

💡 पहले एक्सेस जाँचें: डॉक्स बताते हैं कि प्रिडिक्शन फ़िलहाल कोई क्रेडिट नहीं लेते, लेकिन अगर आपके प्लान में API एक्सेस शामिल नहीं है, तो एक प्रिडिक्शन बनाने पर 403 plan_required जवाब आएगा। API के आसपास कुछ भी डिज़ाइन करने से पहले एक अकेला टेस्ट रिक्वेस्ट भेजें।

बनाएँ, पोल करें, लें

नई जॉब का एंडपॉइंट POST /v1/models/{owner}/{name}/predictions है, और आपके फ़ील्ड एक input ऑब्जेक्ट में लिपटे होते हैं। रिस्पॉन्स में एक id होता है, एक status (starting, processing, succeeded, failed या canceled), और एक output जो या तो URL होता है या URL की सूची।

पोलिंग के लिए GET /v1/predictions/{id} इस्तेमाल होता है। eta.next_poll_in_seconds फ़ील्ड बताता है कि अगली जाँच कब करना ठीक है, ताकि आप एंडपॉइंट पर लगातार दबाव न डालें।

import os, time, requests

API = "https://api.picassoia.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['PICASSOIA_TOKEN']}"}

def run(model, payload):
    r = requests.post(f"{API}/models/{model}/predictions",
                      json={"input": payload}, headers=HEADERS)
    pred = r.json()
    if not r.ok:
        raise RuntimeError(f"{pred['code']}: {pred['detail']}")
    while pred["status"] not in ("succeeded", "failed", "canceled"):
        time.sleep((pred.get("eta") or {}).get("next_poll_in_seconds", 2))
        pred = requests.get(pred["urls"]["get"], headers=HEADERS).json()
    if pred["status"] != "succeeded":
        raise RuntimeError(pred["error"] or pred["status"])
    return pred["output"]

def first(output):
    return output[0] if isinstance(output, list) else output

def make_ad(brief):
    frame = first(run("picassoia/picassoia-image", {"prompt": brief["persona_prompt"]}))
    return first(run("picassoia/seedance-2.5-lite", {
        "prompt": brief["motion_prompt"],
        "image": frame,
        "duration": 10,
        "resolution": "720p",
    }))

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

failed को डेटा मानें, कोई सरप्राइज़ नहीं। error स्ट्रिंग लॉग करें, फ़ेल हुई जॉब को उसी इनपुट के साथ एक बार दोबारा चलाएँ, फिर थोड़े छोटे प्रॉम्प्ट के साथ एक और बार, और उसके बाद उसे किसी इंसान के लिए रख दें। plan_required या गलत फ़ॉर्मेट वाली रिक्वेस्ट को कभी दोबारा न चलाएँ, क्योंकि जवाब नहीं बदलेगा। तैयार फ़ाइलें मिलते ही अपने स्टोरेज में कॉपी कर लें, यह मानकर न चलें कि आउटपुट लिंक हमेशा रहेगा।

Node में वही फ़्लो

Node वर्ज़न उसी लूप जैसा है, बस fetch के साथ। अपने फ़ील्ड input में लपेटें, urls.get को पोल करें, और eta.next_poll_in_seconds का सम्मान करें।

const API = 'https://api.picassoia.com/v1'
const headers = {
  Authorization: `Bearer ${process.env.PICASSOIA_TOKEN}`,
  'Content-Type': 'application/json',
}
const sleep = (s) => new Promise((r) => setTimeout(r, s * 1000))

async function run(model, input) {
  const res = await fetch(`${API}/models/${model}/predictions`, {
    method: 'POST', headers, body: JSON.stringify({ input }),
  })
  let pred = await res.json()
  if (!res.ok) throw new Error(`${pred.code}: ${pred.detail}`)
  while (!['succeeded', 'failed', 'canceled'].includes(pred.status)) {
    await sleep(pred.eta?.next_poll_in_seconds ?? 2)
    pred = await (await fetch(pred.urls.get, { headers })).json()
  }
  if (pred.status !== 'succeeded') throw new Error(pred.error ?? pred.status)
  return pred.output
}

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

दिन में बहुत सारे विज्ञापनों तक स्केल करना

पाँच जॉब की सीमा के भीतर काम करना

अकाउंट में एक साथ पाँच प्रिडिक्शन कतार में या चलते हुए की अनुमति है, और यह बजट हर सीक्रेट और हर MCP कनेक्शन में साझा है। अगर आपकी टीम का कोई साथी MCP क्लाइंट से भी जनरेट कर रहा है, तो आपकी स्क्रिप्ट उसके साथ प्रतिस्पर्धा करेगी।

आपके कोड के लिए नियम सीधा है: कभी पाँच से ज़्यादा वर्कर न चलाएँ, और आदर्श रूप से एक स्लॉट खाली रखें। थ्रेड पूल यह कुछ पंक्तियों में कर देता है।

from multiprocessing.pool import ThreadPool

with ThreadPool(4) as pool:
    results = pool.map(make_ad, briefs)

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

थ्रूपुट का अंदाज़ा लगाना आसान है। एक घंटे के सेकंड को एक विज्ञापन में लगने वाले समय से भाग दें, फिर अपने वर्कर्स की संख्या से गुणा करें। अगर एक इमेज और एक वीडियो मिलकर लगभग चार मिनट लेते हैं, तो चार वर्कर्स लगभग 60 विज्ञापन प्रति घंटे पूरे कर देंगे।

वैलिडेशन में बाकी सीमाएँ भी जोड़ने लायक़ हैं: रिक्वेस्ट बॉडी 10 MB तक, डेटा URL इमेज प्रति इमेज 5 MB तक, प्रॉम्प्ट 4,000 अक्षर तक, और हर प्रिडिक्शन के लिए तीन घंटे का टाइमआउट। जो जॉब टाइमआउट से आगे चलती है उसे डेड मानकर दोबारा चलाना चाहिए, उसका इंतज़ार नहीं करना चाहिए।

ऐसे प्रॉम्प्ट टेम्पलेट जो सुरक्षित रूप से बदलें

विविधता ही मूल बात है, लेकिन बेतरतीब विविधता ब्रांड के अनुरूप न रहने वाली क्लिप बनाती है। अपने टेम्पलेट को उन एक्सिस में बाँटें जिन्हें आप बदलते हैं और उन एक्सिस में जिन्हें आप लॉक करते हैं।

हर आउटपुट के साथ अंतिम प्रॉम्प्ट और seed स्टोर करें। जब कोई क्लिप जीतती है, तो आप उसके जुड़वाँ वेरिएंट एक फ़ील्ड बदलकर बना सकते हैं, यह अंदाज़ा लगाने के बजाय कि उसे क्या कामयाब बना रहा था।

Seedance 2.5 Lite कैसे इस्तेमाल करें

कोड लिखने से पहले कुछ क्लिप हाथ से चलाकर देखें कि आपके प्रॉम्प्ट असल में क्या बनाते हैं। Seedance 2.5 Lite ऐसा करने का सबसे तेज़ तरीका है।

1. मॉडल पेज खोलें और अपने PicassoIA अकाउंट में साइन इन करें।
2. अपना पर्सोना फ़्रेम अपलोड करें। एक साफ़, अच्छी रोशनी वाली स्टिल जिसमें प्रोडक्ट दिख रहा हो, सबसे अच्छा पहला फ़्रेम देती है।
3. मोशन प्रॉम्प्ट लिखें। क्रिया क्रम में बताएँ, बोली जाने वाली लाइन को कोट्स में रखें, और कैमरा लगभग स्थिर रखें।
4. रिज़ॉल्यूशन और अवधि चुनें। जल्दी टेस्ट करने के लिए 480p से शुरू करें, फिर जिस वर्ज़न को प्रकाशित करना है उसके लिए 720p पर जाएँ।
5. ऑडियो चालू रखें। save_audio डिफ़ॉल्ट रूप से सही है, और बोलने वाले विज्ञापन के लिए यही चाहिए।
6. वैकल्पिक रूप से आखिरी फ़्रेम सेट करें। जब क्लिप एक साफ़ प्रोडक्ट शॉट पर खत्म होनी हो, तब last_frame_image अपलोड करें।
7. जब नतीजा सही लगे तब सीड फ़िक्स करें, फिर एक बार में एक ही चीज़ बदलें।
8. सबमिट करें और क्लिप डाउनलोड करें, फिर उसे आवाज़ के साथ देखकर उस पर राय बनाएँ।

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

क्वालिटी कंट्रोल और डिस्क्लोज़र

प्रकाशन से पहले स्वचालित चेक

उबाऊ रिजेक्शन अपने-आप करें, ताकि इंसान सिर्फ़ उन्हीं क्लिप्स की समीक्षा करे जो पहले से पास हो चुकी हों:

• फ़ाइल लोड होती है। URL पर रिक्वेस्ट करें, 200 स्टेटस और वीडियो कंटेंट टाइप की उम्मीद करें।
• अवधि मेल खाती है जो आपने माँगी थी।
• ऑडियो मौजूद है जब save_audio चालू था।
• प्रॉम्प्ट और सीड आउटपुट के साथ स्टोर होते हैं ताकि नतीजा दोबारा बनाया जा सके।
• क्लेम फ़िल्टर स्क्रिप्ट टेक्स्ट पर चलता है और ऐसी मेडिकल, आय या गारंटी वाली भाषा को रोकता है जिसे आप साबित नहीं कर सकते।
• इंसान हर बैच के नमूने पर चेहरे, हाथ और प्रोडक्ट लेबल की स्पॉट चेक करता है।

लेबलिंग और सहमति

डिस्क्लोज़र को पाइपलाइन का हिस्सा मानें, बाद में सोची गई बात नहीं। विज्ञापन प्लेटफ़ॉर्म और नियामक AI से बनी सामग्री पर लेबल होने की अपेक्षा तेज़ी से रखने लगे हैं, और नियम अक्सर बदलते हैं, इसलिए बैच लॉन्च करने से पहले हर प्लेटफ़ॉर्म की मौजूदा विज्ञापन नीति पढ़ें।

किसी सिंथेटिक पर्सोना को कभी भी ऐसे असली ग्राहक के रूप में पेश न करें जो असली नतीजों के बारे में बता रहा हो। किसी असली व्यक्ति के चेहरे या आवाज़ को उसकी लिखित सहमति के बिना दोबारा न बनाएँ। नकली टेस्टिमोनियल विज्ञापन अकाउंट गँवाने का सबसे तेज़ तरीका है, और वह इसी का हकदार है।

आज ही अपना पहला बैच बनाएँ

अब आपके पास पूरा लूप है: ब्रीफ़, स्क्रिप्ट, पर्सोना फ़्रेम, ऑडियो वाली क्लिप, रिव्यू। यह जानने का सबसे सस्ता तरीका कि यह आपके प्रोडक्ट में फ़िट होता है या नहीं, आज दोपहर तीन वेरिएंट चलाना है।

Picasso IA पर Seedance 2.5 Lite खोलें, PicassoIA Image से एक पर्सोना फ़्रेम अपलोड करें, और एक ही प्रोडक्ट के लिए तीन अलग हुक लिखें। शुरुआत की तुलना साथ-साथ करें। जब उनमें से कोई साफ़ तौर पर आगे निकल जाए, तो आपके पास टेम्पलेट है, और ऊपर का Python उसे पचास और में बदल देगा।

आज ही Picasso IA पर अपनी पहली पर्सोना इमेज बनाएँ, उसे UGC स्टाइल के विज्ञापन में एनिमेट करें, और देखें कि एक अच्छा टेम्पलेट कितनी दूर तक जा सकता है। एकमात्र प्रयोग जो असफल होता है वह है जो आप कभी चलाते ही नहीं।