> 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.

# टेम्प्लेट्स क्विकस्टार्ट

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

![फ़ोन फ़ोटो और पैकशॉट](/docs/_fern-img/6afed41d4d791df68c87f183bd8db1d4aca8b4be3e946cc518534bda902f9528.webp)

**टेम्प्लेट** एक प्रकाशित [ElevenCreative Flow](/docs/hi/eleven-creative/products/flows) है: मॉडल्स की एक श्रृंखला जो तय **इनपुट्स** लेती है और तय **आउटपुट्स** बनाती है। जो टेम्प्लेट आप चलाएंगे, [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy), एक इमेज लेता है और एक इमेज लौटाता है। इसके लेखक ने मॉडल्स और प्रॉम्प्ट्स पहले ही चुन लिए हैं, इसलिए आपके कोड को सिर्फ़ फ़ोटो भेजनी है।

> **Warning**
>
> टेम्प्लेट चलाने के लिए Pro प्लान या उससे ऊपर का प्लान चाहिए।

## सेट अप करें

#### API कुंजी बनाएं

[डैशबोर्ड में यहां API key बनाएं](https://elevenlabs.io/app/settings/api-keys), जिसका इस्तेमाल आप [API एक्सेस करने](/docs/hi/api-reference/authentication) के लिए सुरक्षित रूप से करेंगे।

key को मैनेज्ड सीक्रेट के रूप में स्टोर करें और अपनी पसंद के अनुसार इसे SDKs को `.env` फ़ाइल के ज़रिए एनवायरनमेंट वेरिएबल के रूप में या सीधे अपने ऐप के कॉन्फ़िगरेशन में पास करें।

**`.env`**

```js title=".env"
ELEVENLABS_API_KEY=<your_api_key_here>
```

कुंजी को **Image & Video** अनुमति दें।

#### SDK इंस्टॉल करें

#### SDK

हम अपने API key को environment variable से लोड करने के लिए `dotenv` library का भी इस्तेमाल करेंगे।

```python
pip install elevenlabs
pip install python-dotenv
```

```typescript
npm install @elevenlabs/elevenlabs-js
npm install dotenv
```

#### CLI

ElevenLabs CLI इंस्टॉल करें। Homebrew (macOS) और Scoop (Windows) की सलाह दी जाती है।

**`Homebrew (macOS)`**

```bash title="Homebrew (macOS)"
brew install elevenlabs/tap/elevenlabs
```

**`Scoop (Windows)`**

```powershell title="Scoop (Windows)"
scoop bucket add elevenlabs https://github.com/elevenlabs/scoop-bucket
scoop install elevenlabs
```

**`npm`**

```bash title="npm"
npm install -g @elevenlabs/cli
```

**`curl`**

```bash title="curl"
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/elevenlabs/cli/releases/latest/download/elevenlabs-cli-installer.sh | sh
```

> **Tip**
>
> AI कोडिंग असिस्टेंट के साथ काम कर रहे हैं? अपने प्रोजेक्ट में `elevenlabs generate-skills` चलाएं। इससे हर कमांड ग्रुप के लिए `skills/` में एक
> `SKILL.md` लिखा जाएगा, ताकि आपके असिस्टेंट को डॉक्यूमेंटेशन पेस्ट किए बिना CLI की पूरी जानकारी मिल सके। उन्हें कहीं और रखने के लिए `--output-dir` इस्तेमाल करें। यह CLI की अपनी
> एम्बेडेड API डेफ़िनिशन पढ़ता है, इसलिए इसे API key की ज़रूरत नहीं होती और यह ऑफ़लाइन भी काम करता है — साथ ही आपके इंस्टॉल किए गए CLI वर्शन के अनुसार बना रहता है।

फिर authenticate करें — CLI को authorize करने के लिए इससे आपका browser खुलेगा:

```bash
elevenlabs auth login
```

#### फ़ोटो लें

सैंपल फ़ोटो को उस फ़ोल्डर में डाउनलोड करें जहाँ आप अपनी स्क्रिप्ट बनाएंगे:

```bash
curl -o garment.jpg https://storage.googleapis.com/eleven-public-cdn/documentation_assets/templates/garment.jpg
```

## टेम्प्लेट का कोड ढूंढें

ElevenLabs ऐप में [Phone Photo to Packshot](https://elevenlabs.io/app/templates/Yz4DETxRv4uXyIo5PnEy) खोलें और **API** टैब चुनें। हर टेम्प्लेट में यह टैब होता है, जिसमें उसे cURL, Python और TypeScript में चलाने का कोड होता है।

![टेम्प्लेट API टैब](/docs/_fern-img/801c9d2e2736964b35f5bad954092c973b21eedc03801128f1ed8bf31ea095b1.webp)

टैब आपको तीन चरणों से गुज़ारता है: API कुंजी लें, नतीजा पाने का तरीका चुनें और टेम्प्लेट चलाएं। **Choose how to get the result** के अंतर्गत, **Wait for the result** डिफ़ॉल्ट रूप से चुना होता है। तीसरे चरण का कोड पहले cURL में खुलता है; **Python** या **TypeScript** चुनें और चरण **Run and wait for the result** बन जाता है। इसका स्निपेट रन शुरू करता है, उसके पूरा होने का इंतज़ार करता है और हर आउटपुट प्रिंट करता है। यह टेम्प्लेट के हर इनपुट के लिए `inputs` में एक वैल्यू भेजता है, जिसकी कुंजी इनपुट की id होती है, और हर नतीजे को उसकी आउटपुट id से `outputs` से पढ़ता है। इस टेम्प्लेट में एक इनपुट, `garment_photo`, और एक आउटपुट, `packshot`, है। आपके कोड को सिर्फ़ इन दो ids की ज़रूरत है।

## टेम्प्लेट चलाएं

`packshot.py` या `packshot.mts` बनाएं। यह API टैब के स्निपेट में ये बदलावों वाला संस्करण है:

* API कुंजी आपकी `.env` फ़ाइल से लोड होती है।
* पहले से ElevenLabs पर अपलोड की गई फ़ाइल की ID, `YOUR_ASSET_ID`, की जगह फ़ोटो को base64 के रूप में भेजा जाता है।
* रन जारी रहने के दौरान स्क्रिप्ट एक लाइन प्रिंट करती है और पैकशॉट के URL को प्रिंट करने के बजाय उसे `packshot.jpg` में सेव करती है।

**`packshot.py`**

```python title="packshot.py" maxLines=0
import base64
import os
import urllib.request

from dotenv import load_dotenv
from elevenlabs import ElevenLabs, TemplateInputReference_InlineBase64

load_dotenv()

client = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

with open("garment.jpg", "rb") as f:
    photo = base64.b64encode(f.read()).decode()

print("Running the template, this takes up to a minute...")

# Starts a run and waits for it to finish, checking back as often as the API
# asks. In production, receive the result by webhook instead.
run = client.flows.templates.runs.create_and_wait(
    template_id="Yz4DETxRv4uXyIo5PnEy",
    # Pins the version this tutorial was written against.
    version_id="Kqs4nRrpndEjQ54BhbwE",
    inputs={
        "garment_photo": TemplateInputReference_InlineBase64(
            content_base_64=photo,
            mime_type="image/jpeg",
        ),
    },
)

packshot = run.outputs["packshot"]
# Checking `type` tells your editor this output is an image, which has a content_url.
if packshot.type == "image" and packshot.status == "completed" and packshot.content_url:
    urllib.request.urlretrieve(packshot.content_url, "packshot.jpg")
    print("Saved packshot.jpg")
else:
    print("The run failed:", packshot.failure_reason)

```

**`packshot.mts`**

```typescript title="packshot.mts" maxLines=0
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";
import { readFile, writeFile } from "fs/promises";

const client = new ElevenLabsClient({
  apiKey: process.env.ELEVENLABS_API_KEY,
});

const photo = await readFile("garment.jpg");

console.log("Running the template, this takes up to a minute...");

// Starts a run and waits for it to finish, checking back as often as the API
// asks. In production, receive the result by webhook instead.
const run = await client.flows.templates.runs.createAndWait("Yz4DETxRv4uXyIo5PnEy", {
  // Pins the version this tutorial was written against.
  versionId: "Kqs4nRrpndEjQ54BhbwE",
  inputs: {
    garment_photo: {
      type: "inline_base64",
      contentBase64: photo.toString("base64"),
      mimeType: "image/jpeg",
    },
  },
});

const packshot = run.outputs["packshot"];
// Checking `type` tells TypeScript this output is an image, which has a contentUrl.
if (packshot.type === "image" && packshot.status === "completed" && packshot.contentUrl) {
  const response = await fetch(packshot.contentUrl);
  await writeFile("packshot.jpg", Buffer.from(await response.arrayBuffer()));
  console.log("Saved packshot.jpg");
} else {
  console.error("The run failed:", packshot.failureReason);
}

```

`create_and_wait` (TypeScript में `createAndWait`) रन शुरू करता है, फिर API के सुझाए अंतराल पर उसकी स्थिति जांचता है, जब तक हर आउटपुट पूरा न हो जाए। विफल रन को raise करने के बजाय लौटाया जाता है, इसलिए स्क्रिप्ट उसे पढ़ने से पहले आउटपुट का `status` जांचती है। `version_id` उस टेम्प्लेट के संस्करण को पिन करता है जिसके लिए यह ट्यूटोरियल लिखा गया था, ताकि बाद में टेम्प्लेट में किया गया बदलाव स्क्रिप्ट को न तोड़ सके।

स्क्रिप्ट चलाएं। इस टेम्प्लेट का एक रन लगभग 1,020 क्रेडिट इस्तेमाल करता है, जो इसे ऐप में चलाने के समान है।

```python
python packshot.py
```

```typescript
npx tsx packshot.mts
```

30 सेकंड से एक मिनट बाद, स्क्रिप्ट यह प्रिंट करती है:

```text
Running the template, this takes up to a minute...
Saved packshot.jpg
```

`packshot.jpg` खोलें। फ़ोटो का कपड़ा अब सादे स्टूडियो बैकग्राउंड के सामने एक मैनिकिन पर है और बिस्तर व लाइटिंग हट गए हैं।

> **Note**
>
> `create_and_wait` स्क्रिप्ट्स और टेम्प्लेट्स आज़माने के लिए है। प्रोडक्शन में, पूरे हो चुके रन
> इसके बजाय [webhook](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks) से प्राप्त करें, ताकि रन जारी रहने के दौरान आपका
> एप्लिकेशन रिक्वेस्ट खुली न रखे। तरीका जानने के लिए [अपनी टीम का टेम्प्लेट चलाएं](/docs/hi/eleven-api/guides/how-to/templates/run-a-template) देखें।

## अपनी फ़ोटो के साथ चलाएं

अपने फ़ोन से किसी भी कपड़े की फ़ोटो लें। फ़ोटो का अच्छा होना ज़रूरी नहीं है: आपके बिस्तर पर टी-शर्ट या कुर्सी पर जैकेट भी चलेगी। इसे `garment.jpg` नाम से सेव करें और स्क्रिप्ट फिर से चलाएं।

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

## आपने क्या सीखा

* टेम्प्लेट नाम वाले **इनपुट्स** लेता है और नाम वाले **आउटपुट्स** बनाता है, और उसका **API** टैब उसे चलाने का कोड दिखाता है।
* `flows.templates.runs.create_and_wait` हर इनपुट id के लिए एक वैल्यू के साथ **रन** शुरू करता है और उसके पूरा होने पर लौटता है। आप हर आउटपुट को उसकी id से पढ़ते हैं और उसका `status` जांचते हैं।
* प्रोडक्शन में, **webhook** हर पूरा रन डिलीवर करता है, इसलिए किसी को उसका इंतज़ार नहीं करना पड़ता।

## अगले चरण

#### [अपनी टीम का टेम्प्लेट चलाएं](/docs/hi/eleven-api/guides/how-to/templates/run-a-template)

टेम्प्लेट के API टैब से उसका कोड कॉपी करें, हर तरह का इनपुट भरें, नतीजा
webhook से पाएं और एक संस्करण पिन करें।

#### [Webhooks](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks)

प्रोडक्शन webhook सेट अप करें, हस्ताक्षरों को मैन्युअल रूप से सत्यापित करें, और रिट्राई व डुप्लिकेट इवेंट्स को संभालें।

#### [टेम्प्लेट बनाएं](/docs/hi/eleven-creative/products/flows#creating-a-template)

आपकी टीम Flow को टेम्प्लेट में कैसे बदलती है: उसके इनपुट्स और आउटपुट्स चुनना, और उसे शेयर करना।

#### [API रेफरेंस](/docs/hi/api-reference/flows/templates/runs/create)

टेम्प्लेट रन का हर पैरामीटर।