AI वीडियो एडिटिंग API और SDK: अपने ऐप में एडिट को ऑटोमेट करें

ज़्यादातर वीडियो एडिट के लिए टाइमलाइन पर किसी इंसान की ज़रूरत नहीं होती। 200 प्रोडक्ट क्लिप्स का बैकग्राउंड बदलना, एक लिखित ब्रीफ़ को पाँच वर्टिकल कट्स में बदलना, या हर अपलोड को 15 सेकंड तक काटना: ये काम कोड के लिए हैं। AI वीडियो एडिटिंग API आपके ऐप को यह काम HTTP रिक्वेस्ट के ज़रिए सबमिट करने और तैयार क्लिप्स वापस लेने देता है, और SDK, चाहे वह आपका खुद लिखा छोटा सा ही क्यों न हो, इन कॉल्स को व्यवस्थित रखता है। यह आर्टिकल दिखाता है कि ऐसा API आज क्या कर सकता है, PicassoIA डेवलपर API कैसे काम करता है, और जेनरेटिव एडिट्स को सादे FFmpeg स्टेप्स के साथ जोड़कर एक ऑटोमेटेड वीडियो पाइपलाइन कैसे बनाई जाती है। जहाँ कोई फ़ीचर सिर्फ़ वेब ऐप में है, वहाँ टेक्स्ट यह साफ़ बताता है।

एडिटिंग API असल में क्या करता है

कोई भी कोड लिखने से पहले "एडिट" शब्द को दो कामों में बाँटें, क्योंकि दोनों के लिए अलग टूल चाहिए।

जेनरेटिव एडिट्स बनाम टाइमलाइन एडिट्स

टाइमलाइन एडिट्स डिटरमिनिस्टिक होते हैं। 1.0 सेकंड पर काटना, दो क्लिप्स जोड़ना, कैप्शन बर्न करना, 9:16 में रीसाइज़ करना: इनपुट एक जैसा हो तो आउटपुट भी हमेशा एक जैसा होता है, और FFmpeg इसे आपके अपने सर्वर पर करता है। जेनरेटिव एडिट्स प्रॉबेबिलिस्टिक होते हैं। मॉडल प्रॉम्प्ट से पिक्सेल दोबारा रेंडर करता है, इसलिए "सोफ़ा पर्पल लेदर का बनाएँ" या "इस फ़ोटो को एनिमेट करें" जैसे प्रॉम्प्ट हर रन पर थोड़े अलग दिख सकते हैं, जब तक आप सीड तय न करें।

एक प्रोडक्शन पाइपलाइन में लगभग हमेशा दोनों चाहिए। आम कामों का बँटवारा इस तरह होता है:

SDK कहाँ फ़िट होता है

SDK वह लेयर है जो कच्चे HTTP को आपके बिज़नेस लॉजिक से दूर रखती है। यह टोकन जोड़ती है, जॉब बनाती है, नतीजों के लिए पोल करती है, सही विफलताओं पर रीट्राई करती है, अटके हुए जॉब्स को कैंसिल करती है, और एक साथ चलने वाले जॉब्स की संख्या सीमित रखती है। चूँकि वीडियो जॉब्स एसिंक्रोनस होते हैं (आप बनाते हैं, इंतज़ार करते हैं, फिर लेते हैं), ज़्यादातर पेचीदा कोड उसी इंतज़ार में होता है। API पेज Python, Node और cURL के उदाहरण देता है। अपना हल्का क्लाइंट बनाने के लिए इतना काफ़ी है, और बाद के सेक्शन यही करते हैं।

PicassoIA आज क्या देता है

डेवलपर API https://api.picassoia.com/v1 पर उपलब्ध है। आप pia_sk_ से शुरू होने वाले Bearer टोकन से प्रमाणित होते हैं, जो picassoia.com के API पेज पर बनता है (एक अकाउंट में अधिकतम दो हो सकते हैं)। इसका ढाँचा Replicate जैसा है: आप एक प्रेडिक्शन बनाते हैं, उसे पोल करते हैं और नतीजा पढ़ते हैं।

API के पीछे चार मॉडल

💡 इस बँटवारे के हिसाब से योजना बनाएँ। अक्टूबर 2026 तक, कैटलॉग के वीडियो एडिटिंग मॉडल, जैसे P Video Edit, Aleph 2 और Lucy Edit 2, API के बजाय वेब ऐप में चलते हैं। जनरेट और री-रेंडर के लिए API का इस्तेमाल करें, और मौजूदा फ़ुटेज के प्रॉम्प्ट-आधारित एडिट के लिए वेब ऐप का।

वे सीमाएँ जिनके हिसाब से डिज़ाइन करना है

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

💡 एक्सेस के नियम और प्लान की ज़रूरतें बदलती रहती हैं, इसलिए अपनी टीम से कोई रोडमैप वादा करने से पहले API पेज पर इन्हें ज़रूर जाँच लें।

अपनी पहली रिक्वेस्ट भेजें

नीचे की हर कॉल एक एनवायरनमेंट वेरिएबल PICASSOIA_TOKEN पढ़ती है, ताकि टोकन आपके सोर्स कोड में कभी न जाए।

cURL से जॉब बनाना

curl -X POST https://api.picassoia.com/v1/models/picassoia/picassoia-video/predictions \
  -H "Authorization: Bearer $PICASSOIA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "prompt": "Slow push-in on a ceramic mug of coffee on a sunlit desk, steam rising, soft room tone",
      "image": "https://example.com/first-frame.jpg",
      "resolution": "720p"
    }
  }'

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

रिस्पॉन्स में एक प्रेडिक्शन id और एक status मिलता है। input ऑब्जेक्ट मॉडल के स्कीमा के हिसाब से होता है। PicassoIA Video के लिए इसका मतलब है एक ज़रूरी prompt और वैकल्पिक image, resolution (480p या 720p, डिफ़ॉल्ट 720p), aspect_ratio, seed और save_audio। जब आप इमेज भेजते हैं, तो वह शुरुआती फ़्रेम बन जाती है और क्लिप उसका आस्पेक्ट रेशियो ले लेती है। जब तक आप save_audio बंद न करें, हर क्लिप 24 fps पर 5 सेकंड की होती है और उसमें सिंक्रोनाइज़्ड ऑडियो रहता है।

क्लिप तैयार होने तक पोल करना

जॉब्स एसिंक्रोनस होते हैं, इसलिए पहला रिस्पॉन्स एक रसीद है, वीडियो नहीं। हर कुछ सेकंड में GET /v1/predictions/{id} से प्रेडिक्शन माँगें, जब तक स्टेटस सफल या विफल न दिखाए, फिर आउटपुट URL पढ़ें। मॉडल पेज के उदाहरण रन लगभग 30 सेकंड से 2 मिनट में पूरे होते हैं, इसलिए हर 3 से 5 सेकंड पर पोल करना काफ़ी है। अगर किसी जॉब की अब ज़रूरत नहीं, तो कैंसिल एंडपॉइंट कॉल करें ताकि वह आपके पाँच स्लॉट में से एक न रोके।

एक छोटा SDK रैपर बनाएँ

40 लाइनों से कम का रैपर

जिन कॉल्स की आपको ज़रूरत है, उन्हें एक मॉड्यूल में लपेटें। यह Node वर्ज़न (18 या उससे नया, ताकि fetch पहले से मौजूद हो) यह काम करता है:

const BASE = "https://api.picassoia.com/v1";
const headers = {
  Authorization: `Bearer ${process.env.PICASSOIA_TOKEN}`,
  "Content-Type": "application/json",
};

export async function createPrediction(model, input) {
  const res = await fetch(`${BASE}/models/${model}/predictions`, {
    method: "POST",
    headers,
    body: JSON.stringify({ input }),
  });
  if (!res.ok) throw new Error(`Create failed: ${res.status} ${await res.text()}`);
  return res.json();
}

export async function waitFor(id, { everyMs = 4000, timeoutMs = 10 * 60_000 } = {}) {
  const started = Date.now();
  while (Date.now() - started < timeoutMs) {
    const res = await fetch(`${BASE}/predictions/${id}`, { headers });
    const prediction = await res.json();
    if (prediction.status === "succeeded") return prediction;
    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${id} ${prediction.status}`);
    }
    await new Promise((r) => setTimeout(r, everyMs));
  }
  await fetch(`${BASE}/predictions/${id}/cancel`, { method: "POST", headers });
  throw new Error(`Prediction ${id} timed out`);
}

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

तीन आदतें इसे प्रोडक्शन में सुरक्षित रखती हैं। सिर्फ़ वही रीट्राई करें जो दूसरी कोशिश में सफल हो सके: नेटवर्क ड्रॉप और 5xx रिस्पॉन्स को बढ़ते अंतराल के साथ दो या तीन मौके मिलें, जबकि 4xx एरर जैसे गलत इनपुट या गलत टोकन पर रीट्राई न करें, क्योंकि दोहराने से कुछ नहीं बदलता। हमेशा टाइम आउट सेट करें और समय खत्म होने पर कैंसिल करें, जैसा ऊपर के कोड में है, ताकि कोई अटका जॉब कभी स्लॉट न रोके। प्रेडिक्शन आईडी को अपनी जॉब आईडी के साथ लॉग करें, क्योंकि कुछ गड़बड़ लगने पर सबसे पहले यही चाहिए होगी। शिप करने से पहले सटीक रिस्पॉन्स फ़ील्ड API डॉक्स से मिलाकर पक्के कर लें।

एक साथ पाँच जॉब्स से नीचे रहें

अकाउंट की सीमा पाँच एक साथ चलने वाले प्रेडिक्शन है, जो टोकन और MCP कनेक्शन में साझा होते हैं। Promise.all के साथ 40 क्लिप्स का बैच एक साथ भेजा जाए तो वह तुरंत सीमा तक पहुँच जाएगा। रैपर के आगे एक छोटा पूल रखें और उसे 4 पर सीमित करें, ताकि मैन्युअल टेस्ट या उसी अकाउंट पर चलने वाले किसी दूसरे टूल के लिए एक स्लॉट खाली रहे:

export function pool(limit = 4) {
  let active = 0;
  const queue = [];
  const next = () => {
    if (active >= limit || queue.length === 0) return;
    active++;
    const { task, resolve, reject } = queue.shift();
    task().then(resolve, reject).finally(() => { active--; next(); });
  };
  return (task) => new Promise((resolve, reject) => { queue.push({ task, resolve, reject }); next(); });
}

const run = pool(4);
const clips = await Promise.all(
  shots.map((shot) => run(async () => {
    const job = await createPrediction("picassoia/picassoia-video", shot);
    return waitFor(job.id);
  }))
);

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

अपने ऐप के अंदर एडिट्स को ऑटोमेट करें

रैपर तैयार होने के बाद, एक ऑटोमेटेड एडिट कुछ स्टेप्स की छोटी चेन है:

1. योजना: एक LLM ब्रीफ़ को JSON एडिट लिस्ट में बदलता है।
2. स्टिल्स: API के ज़रिए इमेज जनरेट या एडिट करें।
3. शॉट्स: उन स्टिल्स से नई क्लिप्स रेंडर करें।
4. टाइमलाइन का काम: FFmpeg से ट्रिम, मर्ज और कैप्शन करें।
5. समीक्षा और डिलीवरी: हर फ़ाइल जाँचें, फिर प्रकाशित करें।

अगले तीन पैटर्न इस चेन के बीच का हिस्सा भरते हैं।

पहला फ़्रेम एडिट करें, फिर एनिमेट करें

API आपका फ़ुटेज लेकर उस पर टेक्स्ट एडिट लागू नहीं कर सकता, लेकिन उसके करीब पहुँच सकता है। सोर्स क्लिप से एक फ़्रेम निकालें, उस स्टिल को PicassoIA Image Editor Pro से एडिट करें, फिर PicassoIA Video या Seedance 2.5 Lite से एक नया शॉट रेंडर करें जो एडिट किए गए फ़्रेम से शुरू होता है।

1. एक फ़्रेम लें: ffmpeg -ss 2 -i source.mp4 -frames:v 1 frame.jpg
2. उसे स्टोरेज में अपलोड करें ताकि उसका सार्वजनिक URL हो।
3. उसे images एरे में भेजें और प्रॉम्प्ट में उसे "image 1" कहें। एडिटर तीन रेफ़रेंस इमेज तक लेता है, और उसके पेज के उदाहरण एडिट लगभग एक से दो सेकंड में लौटते हैं, इसलिए वीडियो पर रेंडर खर्च करने से पहले आप खराब एडिट को रद्द कर सकते हैं।
4. एडिट की गई इमेज को image के रूप में मोशन प्रॉम्प्ट के साथ किसी वीडियो मॉडल को भेजें।

const edit = await waitFor((await createPrediction("picassoia/picassoia-image-editor-pro", {
  prompt: "Change the sofa in image 1 to light purple leather. Keep everything else unchanged.",
  images: [frameUrl],
})).id);
const firstFrame = Array.isArray(edit.output) ? edit.output[0] : edit.output;

const clip = await waitFor((await createPrediction("picassoia/picassoia-video", {
  prompt: "Slow push-in toward the sofa, soft window light, a hand places a cushion.",
  image: firstFrame,
  resolution: "720p",
})).id);

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

यह मूल पिक्सेल एडिट करने के बजाय शॉट को दोबारा रेंडर करता है, इसलिए मोशन आपके सोर्स फ़ुटेज से अलग होगा। इसे फ़्रेम-दर-फ़्रेम रीटच नहीं, बल्कि एक वैरिएशन बनाने का तरीका समझें। Seedance 2.5 Lite last_frame_image और 10 सेकंड की अवधि भी स्वीकार करता है, जो तब काम आता है जब शॉट को किसी खास फ़्रेम पर खत्म होना हो।

LLM से एडिट प्लान लिखवाएँ

हर एडिट को हार्ड-कोड करना स्केल नहीं करता। किसी भाषा मॉडल को सादी भाषा की ब्रीफ़ को JSON एडिट लिस्ट में बदलने दें, फिर अपने कोड से वह लिस्ट चलवाएँ। GPT 5 Structured साफ़ JSON लौटाने के लिए बना है, और जब आप वेब ऐप में प्लान हाथ से टेस्ट करते हैं तब Claude Sonnet 5 और Gemini 3.5 Flash अच्छे ड्राफ़्टिंग साथी हैं। प्रोडक्शन में, अपने ऐप में पहले से इस्तेमाल हो रहे LLM प्रोवाइडर को कॉल करें।

{
  "shots": [
    { "source": "clip_01.mp4", "start": 1.0, "end": 4.5, "caption": "New arrivals" },
    { "generate": "Slow dolly toward a sunlit storefront, shallow depth of field", "seconds": 5 }
  ]
}

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

कोई भी प्लान बिना जाँचे न चलाएँ। उसे स्कीमा से वैलिडेट करें, अनजान फ़ील्ड ठुकराएँ, अवधि को सीमा में रखें और शॉट्स की गिनती सीमित करें। मॉडल सुझाव देता है; फ़ैसला आपका कोड करता है।

FFmpeg से ट्रिम, मर्ज और कैप्शन

टाइमलाइन स्टेप्स डिटरमिनिस्टिक और सस्ते रहते हैं। इन्हें child_process के साथ Node से, या किसी भी जॉब रनर से चलाएँ:

# trim 3.5 seconds starting at 1.0
ffmpeg -ss 1.0 -t 3.5 -i clip_01.mp4 -c:v libx264 -c:a aac trimmed.mp4

# merge the clips listed in list.txt (same codec, size and frame rate)
ffmpeg -f concat -safe 0 -i list.txt -c copy merged.mp4

# burn captions from an SRT file
ffmpeg -i merged.mp4 -vf subtitles=captions.srt -c:a copy final.mp4

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

-c copy से मर्ज तभी काम करता है जब हर क्लिप का कोडेक, साइज़ और फ़्रेम रेट एक जैसा हो। PicassoIA Video की सभी क्लिप्स 5 सेकंड और 24 fps पर आती हैं, लेकिन अगर आप उन्हें फ़ोन की फ़ुटेज के साथ मिलाते हैं, तो पहले सब कुछ एक ही स्पेक में री-एनकोड करें। वेब ऐप में वही काम हाथ से Trim Video, Video Merge और Autocaption के ज़रिए किए जा सकते हैं।

PicassoIA पर P Video Edit का इस्तेमाल

जब आपको अपनी पहले से शूट की गई फ़ुटेज पर प्रॉम्प्ट-आधारित एडिट चाहिए, तो टूल P Video Edit है। यह PicassoIA वेब ऐप में चलता है और 15 सेकंड तक की क्लिप स्वीकार करता है। यह एक सादे टेक्स्ट निर्देश का पालन करके वीडियो बदलता है, इसलिए "आसमान को सूर्यास्त बनाएँ" या "जैकेट लाल कर दें" जैसे अनुरोध के लिए टाइमलाइन की ज़रूरत नहीं होती।

वेब ऐप में स्टेप-दर-स्टेप

1. P Video Edit पेज खोलें और अपनी क्लिप अपलोड करें (अधिकतम 15 सेकंड)।
2. एक निर्देश लिखें, उदाहरण के लिए: Change the material of the sofa to light purple leather. Do not change anything else.
3. वैकल्पिक: जब कोई रंग, टेक्सचर या ऑब्जेक्ट बिल्कुल मेल खाना हो, तो अधिकतम चार रेफ़रेंस इमेज (jpg, jpeg, png या webp) जोड़ें।
4. फ़ाइनल रेंडर से पहले तेज़, कम क्वालिटी वाला प्रीव्यू पाने के लिए Draft चालू करें।
5. छोटे निर्देशों के लिए Prompt Upsampling चालू रखें। जब आपका प्रॉम्प्ट पहले से सटीक हो, तब इसे बंद करें।
6. मूल साउंडट्रैक सिंक में रहे, इसलिए Save Audio चालू रखें।
7. चलाएँ, नतीजा देखें, प्रॉम्प्ट बदलें और फिर चलाएँ। अगर कोई नतीजा हू-ब-हू दोहराना हो, तो seed सेट करें।

मॉडल पेज के हर उदाहरण रन में लगभग एक से दो मिनट लगे।

ऐसे प्रॉम्प्ट जो सीन को बरकरार रखें

पहले बताएँ कि क्या बदलना है, फिर बताएँ कि क्या नहीं बदलना। मॉडल पेज का एक उदाहरण प्रॉम्प्ट इसी पैटर्न पर चलता है: Change only the SUV body paint to yellow. इसका अंत होता है: Keep the environment, lighting and camera movement unchanged. हर रन में एक ही बदलाव रखें, और ज़्यादा ज़रूरत हो तो रनों को चेन करें।

कैटलॉग में और भी एडिटर हैं। इन्हें उसी क्लिप पर एक टेस्ट रन के लायक माना जा सकता है:

लागत, विफलताएँ और सुरक्षा उपाय

विफलताओं और लागत की योजना बनाएँ

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

रेंडर से पहले इनपुट जाँचें

अगर यूज़र प्रॉम्प्ट टाइप कर सकते हैं या इमेज अपलोड कर सकते हैं, तो पहले उन्हें जाँचें। Llama Guard 4 12B एक कंटेंट मॉडरेशन मॉडल है जिसे आप वेब ऐप में आज़मा सकते हैं, और यही सोच किसी भी मॉडरेशन सर्विस पर लागू होती है जो आपके टूल्स के सेट में पहले से है। साथ ही हर यूज़र के लिए रेट लिमिट भी जोड़ें, ताकि एक ग्राहक पाँचों स्लॉट न घेर ले।

आज अपना खुद का एडिट चलाएँ

पूरी पाइपलाइन देखने का सबसे तेज़ तरीका है उसके हिस्सों को हाथ से चलाना। PicassoIA खोलें, PicassoIA Image से एक स्टिल बनाएँ, PicassoIA Image Editor Pro से एक डिटेल बदलें, फिर नतीजे को PicassoIA Video से एनिमेट करें। कुछ मिनटों के प्रयोग से पता चल जाएगा कि कौन-से प्रॉम्प्ट टिकते हैं, इससे पहले कि आप इंटीग्रेशन का कोड लिखें। उसी स्टिल पर Seedance 2.5 Lite से दूसरा पास चलाएँ और मोशन की तुलना करें।

जब नतीजे सही लगने लगें, तो वही स्टेप्स इस आर्टिकल के रैपर के साथ अपने ऐप में जोड़ें। सभी मॉडल, वीडियो एडिटर सहित, picassoia.com/en/all-models पर देखें, और आज ही अपनी इमेज बनाएँ।