> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# अपनी टीम का टेम्प्लेट चलाएं

> **Note**
>
> **कैसे करें गाइड** · मानता है कि आपने [टेम्प्लेट्स क्विकस्टार्ट](/docs/hi/eleven-api/guides/cookbooks/templates) पूरा कर लिया है।

यह गाइड आपकी टीम के बनाए टेम्प्लेट को चलाने के बारे में है: उसका कोड कॉपी करना, हर तरह का इनपुट भेजना, नतीजा पाने वाले webhooks चुनना, संस्करण पिन करना और आउटपुट्स पढ़ना।

## शुरू करने से पहले

* टेम्प्लेट आपके वर्कस्पेस के साथ शेयर किया गया है। इसका लेखक टेम्प्लेट की शेयरिंग सेटिंग्स में **Workspace** के तहत यह तय करता है; **Just me** के रूप में शेयर किया गया टेम्प्लेट सिर्फ़ उसका लेखक चला सकता है।
* आपके वर्कस्पेस में टेम्प्लेट रन के लिए subscribed webhook है। Image & Video webhooks गाइड में [शुरू करने से पहले](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks#before-you-begin) इसे सेट अप करने का तरीका है।
* आपका वर्कस्पेस Pro प्लान या उससे ऊपर के प्लान पर है और आपकी API कुंजी को **Image & Video** अनुमति मिली हुई है।

## टेम्प्लेट का कोड कॉपी करें

ElevenLabs ऐप में टेम्प्लेट खोलें और उसका **API** टैब चुनें। Flows में, टेम्प्लेट का लेखक टेम्प्लेट के साइडबार में **API** बटन से यही कोड खोल सकता है।

टैब टेम्प्लेट के प्रकाशित इनपुट्स और आउटपुट्स से अपने स्निपेट्स बनाता है। **Choose how to get the result** के तहत **Webhook** चुनें, फिर कोड के ऊपर **Python** या **TypeScript** चुनें। टैब एक **Start a run** स्निपेट और एक **Handle the result** स्निपेट दिखाता है। **Start a run** को वहां कॉपी करें जहाँ आपका एप्लिकेशन रन शुरू करता है और **Handle the result** को अपने webhook हैंडलर में कॉपी करें। **Start a run** का हर प्लेसहोल्डर एक इनपुट के लिए होता है और **Handle the result** हर आउटपुट को उसकी id से पढ़ता है।

> **Note**
>
> जब टेम्प्लेट ऐसे मॉडल का इस्तेमाल करता है जिसे API उपलब्ध नहीं कराता, टैब चेतावनी देता है। अगर कोई प्रकाशित संस्करण
> API के ज़रिए नहीं चल सकता, तो स्निपेट्स नहीं दिखते; अगर सिर्फ़ सबसे नया संस्करण नहीं चल सकता, तो स्निपेट्स
> चल सकने वाला सबसे नया संस्करण चलाते हैं। Flows में, लेखक चेतावनी में **Show on canvas** चुनकर
> उन नोड्स को हाइलाइट करता है, हर नोड को [उपलब्ध मॉडल](/docs/hi/eleven-api/guides/cookbooks/image-and-video#available-models) पर स्विच करता है और फिर से प्रकाशित करता है।

## हर इनपुट भेजें

जिस संस्करण को आप चलाते हैं, उसके हर इनपुट को एक वैल्यू देनी होती है, जिसकी कुंजी इनपुट की id होती है। वैल्यू का रूप इनपुट के प्रकार पर निर्भर करता है:

| इनपुट प्रकार                   | वैल्यू                                                                                        |
| ------------------------------ | --------------------------------------------------------------------------------------------- |
| `string`                       | टेक्स्ट स्वयं।                                                                                |
| `number`, `integer`, `boolean` | उस प्रकार की JSON वैल्यू।                                                                     |
| `image`, `video`, `audio`      | अपलोड की गई एसेट, पिछले जनरेशन या base64 डेटा का रेफरेंस।                                     |
| `voice`                        | आपके वर्कस्पेस में किसी वॉइस का रेफरेंस।                                                      |
| `array`                        | हर एलिमेंट के लिए एक वैल्यू वाली सूची, हर वैल्यू उसी रूप में जो उसके एलिमेंट प्रकार को चाहिए। |

`object` प्रकार के इनपुट अभी API से नहीं भेजे जा सकते; API टैब उनके बारे में चेतावनी देता है।

```python
run = client.flows.templates.runs.create(
    template_id="Yz4DETxRv4uXyIo5PnEy",
    version_id="Kqs4nRrpndEjQ54BhbwE",
    inputs={
        "headline": "Autumn collection, 20% off",
        "duration_secs": 8,
        "product_photo": TemplateInputReference_Asset(asset_id="Rk3pQm8vTzL1yWcN0bJd"),
        "previous_shot": TemplateInputReference_Generation(generation_id="JWr5N6X9ZTqf8jD2LmQb"),
        "phone_photo": TemplateInputReference_InlineBase64(
            content_base_64=photo,
            mime_type="image/jpeg",
        ),
        "narrator": TemplateInputReference_Voice(voice_id="JBFqnCBsd6RMkjVDRZzb"),
    },
    webhook=WebhookTarget_All(),
)
```

```typescript
const run = await client.flows.templates.runs.create("Yz4DETxRv4uXyIo5PnEy", {
  versionId: "Kqs4nRrpndEjQ54BhbwE",
  inputs: {
    headline: "Autumn collection, 20% off",
    duration_secs: 8,
    product_photo: { type: "asset", assetId: "Rk3pQm8vTzL1yWcN0bJd" },
    previous_shot: { type: "generation", generationId: "JWr5N6X9ZTqf8jD2LmQb" },
    phone_photo: {
      type: "inline_base64",
      contentBase64: photo.toString("base64"),
      mimeType: "image/jpeg",
    },
    narrator: { type: "voice", voiceId: "JBFqnCBsd6RMkjVDRZzb" },
  },
  webhook: { type: "all" },
});
```

इनपुट ids दोनों SDKs में वही स्पेलिंग रखती हैं जो टेम्प्लेट उन्हें देता है; सिर्फ़ रेफरेंस के फ़ील्ड्स, जैसे `assetId`, TypeScript में camelCase होते हैं।

डिकोड होने के बाद base64 डेटा 25 MB तक सीमित होता है और रन के बाद रखा नहीं जाता। एक ही फ़ाइल को कई रनों में भेजने के लिए उसे एक बार अपलोड करें और उसकी एसेट ID भेजें, जैसा [रेफरेंसेस और एसेट्स](/docs/hi/eleven-api/guides/how-to/image-and-video/references) में बताया गया है।

## नतीजा पाएं

एक [webhook](/docs/hi/eleven-api/resources/webhooks) पूरे हो चुके रन को `flows_template_run` इवेंट के रूप में प्राप्त करता है। API टैब के **Webhook** स्निपेट्स `{"type": "all"}` भेजते हैं, जो टेम्प्लेट रन के लिए subscribed वर्कस्पेस के हर webhook को पूरा रन भेजता है। इसे खास webhooks को भेजने के लिए, उनकी IDs सूचीबद्ध करें:

```python
webhook=WebhookTarget_Ids(ids=["Q8mVr2LpXcT4nB6yJdKw"])
```

```typescript
webhook: { type: "ids", ids: ["Q8mVr2LpXcT4nB6yJdKw"] }
```

सूचीबद्ध हर webhook को टेम्प्लेट रन के लिए subscribed होना चाहिए। ऐसा रन जो webhook मांगता है लेकिन कोई subscribed नहीं है, अस्वीकार कर दिया जाता है, ताकि कोई रन अपने नतीजे की डिलीवरी के लिए जगह के बिना पूरा न हो।

एक बार चलने वाली स्क्रिप्ट या बैच जॉब के लिए, [टेम्प्लेट्स क्विकस्टार्ट](/docs/hi/eleven-api/guides/cookbooks/templates) में इस्तेमाल किया गया `create_and_wait`, इसके बजाय रन के पूरा होने का इंतज़ार करता है।

## संस्करण पिन करें

स्निपेट्स उस सबसे नए प्रकाशित संस्करण का `version_id` भेजते हैं जिसे API चला सकता है। इसे पिन रखें: जब लेखक दोबारा प्रकाशित करता है, तो पिन किया हुआ रन आपके परीक्षण किए संस्करण को चलाता रहता है, जबकि `latest` नए संस्करण पर स्विच हो जाता है, जो इनपुट्स का नाम बदल सकता है या नए इनपुट्स जोड़ सकता है।

नए संस्करण पर जाने के लिए, API टैब फिर से खोलें, उसके इनपुट्स की तुलना अपने कोड द्वारा भेजे जाने वाले इनपुट्स से करें और `version_id` अपडेट करें। कोड से जांचने के लिए, `flows.templates.get` टेम्प्लेट के वे प्रकाशित संस्करण लौटाता है जिन्हें API चला सकता है, सबसे नए से शुरू करके, और हर एक के इनपुट्स व आउटपुट्स के साथ।

## आउटपुट्स पढ़ें

पूरे हो चुके रन के `outputs` में टेम्प्लेट के हर आउटपुट के लिए एक एंट्री होती है, जिसकी कुंजी आउटपुट की id है। हर आउटपुट का अपना `status` होता है, इसलिए एक आउटपुट विफल हो सकता है जबकि बाकी पूरे हो जाएं। विफल आउटपुट में `failure_reason` और `error_message` होते हैं। पूरे हो चुके मीडिया आउटपुट में `content_url` और `content_mime_type` होते हैं, और पूरे हो चुके `string` आउटपुट में `content` होता है।

```python
run = TemplateRunResponse.model_validate(event["data"])

for output_id, output in run.outputs.items():
    if output.status == "failed":
        print(output_id, "failed:", output.failure_reason, output.error_message)
    elif output.type == "image" or output.type == "video" or output.type == "audio":
        print(output_id, output.content_url, output.content_mime_type)
    elif output.type == "string":
        print(output_id, output.content)
```

```typescript
const run = event.data;

for (const [outputId, output] of Object.entries(run.outputs)) {
  if (output.status === "failed") {
    console.error(outputId, "failed:", output.failure_reason, output.error_message);
  } else if (output.type === "image" || output.type === "video" || output.type === "audio") {
    console.log(outputId, output.content_url, output.content_mime_type);
  } else if (output.type === "string") {
    console.log(outputId, output.content);
  }
}
```

TypeScript SDK में `constructEvent` इवेंट का भेजा गया JSON लौटाता है, इसलिए उसके फ़ील्ड्स snake_case में होते हैं।

रिट्राई और डुप्लिकेट इवेंट्स के लिए [डिलीवरी व्यवहार](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks#delivery-behavior) देखें।