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

# इमेज और वीडियो क्विकस्टार्ट

इमेज और वीडियो API एसिंक्रोनस है। आप जनरेशन सबमिट करते हैं और उसके पूरा होने पर साइन किए गए URL से नतीजा डाउनलोड करते हैं। इमेज और वीडियो के लिए अलग एंडपॉइंट हैं, लेकिन दोनों के लिए रिक्वेस्ट और रिस्पॉन्स का ढाँचा एक जैसा है।

नतीजा पाने के दो तरीके हैं। [वेबहुक डिलीवरी](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks) सुझाया गया तरीका है और नीचे दिए गए उदाहरणों में इसी का इस्तेमाल किया गया है: जनरेशन के टर्मिनल स्टेटस पर पहुँचते ही ElevenLabs आपके एंडपॉइंट को कॉल करता है, इसलिए इंतज़ार में कुछ खर्च नहीं होता। जब कॉलबैक पाने के लिए आपके पास कोई एंडपॉइंट न हो, तो पोलिंग वैकल्पिक तरीका है और हर उदाहरण बताता है कि इस पर कैसे जाएँ।

> **Warning**
>
> इमेज और वीडियो API के लिए Pro प्लान या उससे ऊपर का प्लान चाहिए। इस टियर से नीचे के वर्कस्पेस से की गई कॉल
> `402 paid_plan_required` एरर के साथ अस्वीकार हो जाती हैं। आपकी API कुंजी में वर्कस्पेस के लिए इमेज और वीडियो या
> Flows अनुमति भी होनी चाहिए।

## इमेज जनरेट करें

#### 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>
```

#### 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
```

#### जनरेशन सबमिट करें

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

`webhook`, तैयार नतीजे को आपके वर्कस्पेस के वेबहुक पर भेजने का अनुरोध करता है, इसलिए जनरेशन क्यू में लगते ही
कॉल वापस आ जाती है। इसके लिए जनरेशन इवेंट की सदस्यता वाला वेबहुक चाहिए; इसे सेट अप करने के लिए [इमेज और वीडियो वेबहुक](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks) देखें, या फ़ील्ड हटाकर पोल करें।

#### SDK

```python
# example.py
import os

from dotenv import load_dotenv
from elevenlabs import ImageGenerationRequest_Gemini3ProImage, WebhookTarget_All
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))

generation = elevenlabs.flows.image.create(
    request=ImageGenerationRequest_Gemini3ProImage(
        prompt="A corgi in a tiny lifeguard chair on a sunlit beach at golden hour, photorealistic",
        aspect_ratio="16:9",
        resolution="2K",
        webhook=WebhookTarget_All(),
    )
)

print(generation.id, generation.status)
```

```typescript
// example.mts
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import "dotenv/config";

const elevenlabs = new ElevenLabsClient();

const generation = await elevenlabs.flows.image.create({
  modelId: "gemini-3-pro-image",
  prompt:
    "A corgi in a tiny lifeguard chair on a sunlit beach at golden hour, photorealistic",
  aspectRatio: "16:9",
  resolution: "2K",
  webhook: { type: "all" },
});

console.log(generation.id, generation.status);
```

#### CLI

CLI उसी रिक्वेस्ट को JSON के रूप में सबमिट करता है, फिर जनरेशन पूरी होने तक पोल करता है और नतीजा डाउनलोड करता है:

```bash
# 1. Submit the generation (note the returned id)
elevenlabs flows image create --json '{
  "model_id": "gemini-3-pro-image",
  "prompt": "A corgi in a tiny lifeguard chair on a sunlit beach at golden hour, photorealistic",
  "aspect_ratio": "16:9",
  "resolution": "2K"
}'

# 2. Poll until the status is "completed"
elevenlabs flows image get --generation-id <id> --query status

# 3. Read the signed content URL, then download the image
elevenlabs flows image get --generation-id <id> --query content_url
curl -o corgi.png "<content_url>"
```

रिस्पॉन्स में जनरेशन ID के अलावा कुछ नहीं होता। नई बनाई गई जनरेशन का स्टेटस हमेशा
`pending` होता है:

```json
{
  "id": "JWr5N6X9ZTqf8jD2LmQb",
  "status": "pending"
}
```

#### नतीजा पाएँ

क्योंकि रिक्वेस्ट में `webhook` चुना गया था, जनरेशन के `completed` या `failed` होने पर ElevenLabs आपके
एंडपॉइंट पर `flows_generation` इवेंट पोस्ट करता है। इवेंट का `data`, GET एंडपॉइंट के रिस्पॉन्स के जैसा ही होता है,
और [इमेज और वीडियो वेबहुक](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks) उसे पाने वाले हैंडलर के बारे में
बताता है।

कॉलबैक पाने के लिए कोई एंडपॉइंट न हो तो ऊपर दी गई रिक्वेस्ट से `webhook` हटा दें और उसकी जगह पोल करें।
जनरेशन को तब तक फ़ेच करें जब तक उसका स्टेटस `completed` या `failed` न हो जाए। इमेज के लिए रिक्वेस्ट के बीच
कम से कम दो सेकंड रखें — हर मोडेलिटी के लिए इस्तेमाल होने वाले अंतराल जानने हेतु [पोलिंग दिशानिर्देश](#polling-guidelines) देखें।

```python maxLines=0
import time

import requests

while True:
    result = elevenlabs.flows.image.get(generation.id)
    if result.status in ("completed", "failed"):
        break
    time.sleep(2)

if result.status == "failed":
    raise RuntimeError(f"{result.failure_reason}: {result.error_message}")

with open("corgi.png", "wb") as f:
    f.write(requests.get(result.content_url).content)
```

```typescript maxLines=0
import { writeFile } from "fs/promises";

let result = await elevenlabs.flows.image.get(generation.id);

while (result.status === "pending" || result.status === "generating") {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  result = await elevenlabs.flows.image.get(generation.id);
}

if (result.status === "failed") {
  throw new Error(`${result.failureReason}: ${result.errorMessage}`);
}

const response = await fetch(result.contentUrl);
await writeFile("corgi.png", Buffer.from(await response.arrayBuffer()));
```

दोनों ही तरीकों में, पूरी हो चुकी जनरेशन में ये फ़ील्ड होते हैं:

```json
{
  "id": "JWr5N6X9ZTqf8jD2LmQb",
  "status": "completed",
  "content_url": "https://storage.googleapis.com/generations/JWr5N6X9ZTqf8jD2LmQb",
  "content_mime_type": "image/png"
}
```

#### कोड चलाएँ

```python
python example.py
```

```typescript
npx tsx example.mts
```

जनरेशन क्यू में लगती है और उसकी ID प्रिंट होती है। वेबहुक डिलीवरी में इमेज आपके एंडपॉइंट पर आती है;
पोलिंग वेरिएंट में यह `corgi.png` में सेव होती है।

## वीडियो जनरेट करें

वीडियो जनरेशन में `flows.video` इस्तेमाल होता है और यह उसी सबमिट-और-कलेक्ट पैटर्न का पालन करता है। वीडियो में
कई मिनट लग सकते हैं, इसलिए यह उदाहरण नतीजे का इंतज़ार करने के बजाय `webhook` के साथ वेबहुक डिलीवरी चुनता है।

```python
from elevenlabs import VideoGenerationRequest_Veo31FastGenerate001, WebhookTarget_All

generation = elevenlabs.flows.video.create(
    request=VideoGenerationRequest_Veo31FastGenerate001(
        prompt="A corgi rides a tiny surfboard across a sunlit wave at golden hour, cinematic",
        duration_secs=8,
        aspect_ratio="16:9",
        resolution="1080p",
        generate_audio=True,
        webhook=WebhookTarget_All(),
    )
)

print(generation.id)
```

```typescript
const generation = await elevenlabs.flows.video.create({
  modelId: "veo-3.1-fast-generate-001",
  prompt: "A corgi rides a tiny surfboard across a sunlit wave at golden hour, cinematic",
  durationSecs: 8,
  aspectRatio: "16:9",
  resolution: "1080p",
  generateAudio: true,
  webhook: { type: "all" },
});

console.log(generation.id);
```

जनरेशन क्यू में लगते ही कॉल वापस आ जाती है और तैयार नतीजा जनरेशन इवेंट की सदस्यता वाले आपके वर्कस्पेस के हर
वेबहुक पर भेज दिया जाता है। वीडियो आउटपुट MP4 होता है, इसलिए पूरे हुए पेलोड में
`content_mime_type` का मान `video/mp4` होता है। वेबहुक कॉन्फ़िगर करने और इसे पाने वाला हैंडलर लिखने के लिए
[इमेज और वीडियो वेबहुक](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks) देखें।

> **Warning**
>
> `webhook` के लिए जनरेशन इवेंट की सदस्यता वाला कम से कम एक वर्कस्पेस वेबहुक चाहिए। ऐसा न होने पर,
> नतीजे के लिए कोई जगह न होने वाली जनरेशन शुरू करने के बजाय क्रिएट कॉल अस्वीकार हो जाती है।
> `flows.video.get` के साथ पोलिंग पर जाने के लिए फ़ील्ड हटा दें और हर 10 सेकंड में एक बार से ज़्यादा पोल न करें।

## नतीजे पाना

वेबहुक और पोलिंग एक ही payload लौटाते हैं, इसलिए चुनाव इस बात का है कि आप उसके लिए कैसे इंतज़ार करते हैं, न कि
आपको क्या मिलता है।

|                 | वेबहुक डिलीवरी                                          | पोलिंग                                                 |
| --------------- | ------------------------------------------------------- | ------------------------------------------------------ |
| सबसे सही        | दोनों मोडैलिटीज़ और हर प्रोडक्शन उपयोग के लिए डिफ़ॉल्ट  | बिना पब्लिक endpoint वाली स्क्रिप्ट्स और एनवायरनमेंट्स |
| ज़रूरी है       | generation events को subscribed एक HTTPS endpoint       | कुछ नहीं                                               |
| इंतज़ार की लागत | कोई नहीं; generation पूरा होने पर आपको कॉल किया जाता है | हर poll और हर generation के लिए एक request             |

जहाँ भी संभव हो, वेबहुक का इस्तेमाल करें। जब callback पाने के लिए आपके पास कोई जगह न हो, तब पोलिंग चुनें और
ऐसा करने पर नीचे दिए गए intervals का पालन करें।

### वेबहुक टारगेट चुनना

`webhook` दो forms स्वीकार करता है। `WebhookTarget_All` generation
events को subscribed हर वेबहुक तक पहुँचता है, और यह सही डिफ़ॉल्ट है क्योंकि वेबहुक rotate या replace होने पर भी काम करता है।
`WebhookTarget_Ids` डिलीवरी को खास वेबहुक तक सीमित करता है, जब एक workspace कई
consumers को भेजता हो और किसी job को उनमें से सिर्फ़ एक तक पहुँचना हो:

```python
from elevenlabs import WebhookTarget_Ids

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

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

हर ID पहले से generation events को subscribed होनी चाहिए; unsubscribed वेबहुक का नाम देने पर उसे
चुपचाप अनदेखा करने के बजाय request reject हो जाती है। डिलीवर किया गया payload GET endpoint के
लौटाए गए payload जैसा ही होता है, इसलिए एक के लिए लिखा handler दूसरे के लिए भी काम करता है।
[वेबहुक गाइड](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks) में वेबहुक configure करना,
signature verify करना और event handle करना बताया गया है।

### पोलिंग दिशानिर्देश

किसी generation का runtime model, resolution और वीडियो के लिए duration पर निर्भर करता है, इसलिए fixed loop के बजाय
अपने अनुरोध के अनुसार interval पर poll करें:

* **इमेज**: हर 2 सेकंड में एक बार से ज़्यादा poll न करें। ज़्यादातर कुछ सेकंड में पूरे हो जाते हैं।
* **वीडियो**: हर 10 सेकंड में एक बार से ज़्यादा poll न करें। सेकंड नहीं, मिनटों की अपेक्षा रखें और
  interval को `duration_secs` और `resolution` के हिसाब से बढ़ाएं।

दोनों पर दो नियम लागू होते हैं। generation में ज़्यादा समय लगने पर back off करें — interval को दोगुना करके करीब एक
मिनट तक ले जाने से धीमा generation सैकड़ों requests में नहीं बदलेगा। और loop की एक सीमा रखें,
ताकि अटका हुआ generation अनंत loop के बजाय आपके अपने code में timeout के रूप में खत्म हो।

इससे तेज़ पोलिंग से आपको कुछ नहीं मिलता: सिर्फ़ दो बार पूछने से generation का status जल्दी नहीं बदलता।
लगातार बहुत तेज़ पोलिंग पर
[429 responses](/docs/hi/eleven-api/resources/errors#rate-limiting-and-concurrency) मिल सकते हैं, जिन्हें आपको
exponential backoff के साथ handle करना चाहिए।

## Generation लाइफ़साइकल

एक generation चार statuses से गुजरता है। दो terminal statuses में अलग-अलग fields होते हैं, इसलिए
बाकी response पढ़ने से पहले `status` के आधार पर branch करें।

| Status       | मतलब                                                                          |
| ------------ | ----------------------------------------------------------------------------- |
| `pending`    | generation queue में है। हर नए बनाए गए generation का यही status होता है।      |
| `generating` | model चल रहा है।                                                              |
| `completed`  | output तैयार है। response में `content_url` और `content_mime_type` होते हैं।  |
| `failed`     | generation ने कोई output नहीं बनाया। response में failure की जानकारी होती है। |

> **Warning**
>
> `content_url` एक signed URL है, जो response लौटने के करीब एक घंटे बाद expire हो जाता है। signed URL को store करने के बजाय
> नए URL के लिए generation को फिर से fetch करें।

## Failures हैंडल करना

एक failed generation, पढ़ने योग्य `error_message` के साथ `failure_reason` category रिपोर्ट करता है:

```json
{
  "id": "JWr5N6X9ZTqf8jD2LmQb",
  "status": "failed",
  "failure_reason": "moderated",
  "error_message": "The prompt was rejected by content moderation. You were not charged for this generation."
}
```

| `failure_reason`     | कारण                                                          |
| -------------------- | ------------------------------------------------------------- |
| `timeout`            | model ने समय पर result नहीं लौटाया।                           |
| `model_error`        | model provider ने error लौटाया या कोई output नहीं दिया।       |
| `moderated`          | prompt या किसी input को content moderation ने reject कर दिया। |
| `invalid_parameters` | generation के model तक पहुँचने पर parameters reject हो गए।    |
| `dependency_failed`  | जिस referenced generation पर यह निर्भर है, वह fail हो गया।    |
| `charging_failed`    | workspace से generation के लिए शुल्क नहीं लिया जा सका।        |
| `internal_error`     | एक अनपेक्षित error हुआ।                                       |

Failed generations के लिए शुल्क नहीं लिया जाता। जिन parameter समस्याओं का पहले ही पता लगाया जा सकता है — जैसे
unsupported field, model की allowed range से बाहर का value या reference
inputs का अमान्य combination — उन्हें generation शुरू होने से पहले create request ही reject कर देती है।

## कीमत

Generations के लिए credits में शुल्क लिया जाता है। लागत model, आपके चुने हुए parameters जैसे
resolution और duration, और दिए गए inputs पर निर्भर करती है। API के ज़रिए generation की लागत उतनी ही होती है
जितनी ElevenLabs ऐप में होती है, जहाँ submit करने से पहले लागत दिखाई जाती है। किसी खास model और setting combination की लागत
कैसे दिखाई जाती है, इसके लिए [playground में Image & Video](/docs/hi/eleven-creative/playground/image-video) देखें।

## अपनी generations की सूची देखें

हर endpoint उससे बनाई गई generations की सूची देता है, सबसे नई पहले। नतीजे आपके
workspace और इस API तक सीमित होते हैं, इसलिए ElevenLabs ऐप में बनाई गई generations दिखाई नहीं देतीं।

```python
page = elevenlabs.flows.image.list(page_size=20, status="completed")

for item in page.generations:
    print(item.id, item.content_url)

while page.has_more:
    page = elevenlabs.flows.image.list(page_size=20, status="completed", cursor=page.next_cursor)
    for item in page.generations:
        print(item.id, item.content_url)
```

```typescript
let page = await elevenlabs.flows.image.list({ pageSize: 20, status: "completed" });

for (const item of page.generations) {
  console.log(item.id, item.contentUrl);
}

while (page.hasMore) {
  page = await elevenlabs.flows.image.list({
    pageSize: 20,
    status: "completed",
    cursor: page.nextCursor,
  });
  for (const item of page.generations) {
    console.log(item.id, item.contentUrl);
  }
}
```

`page_size` 1 से 100 तक स्वीकार करता है और डिफ़ॉल्ट रूप से 30 होता है। सिर्फ़ किसी एक
lifecycle state की generations लौटाने के लिए `status` और सिर्फ़ एक model की generations लौटाने के लिए `model_id` दें। `next_cursor` को
opaque मानें: उसका सटीक value वापस दें और `has_more` के `false` होने पर रुक जाएं।

## उपलब्ध मॉडल

API, ElevenLabs ऐप में उपलब्ध models के एक subset को उपलब्ध कराता है। हर model सिर्फ़ उसके लिए सूचीबद्ध
parameters स्वीकार करता है — किसी दूसरे model द्वारा supported field भेजने पर validation error मिलता है।

> **Warning**
>
> ByteDance models डिफ़ॉल्ट रूप से disabled होते हैं और उपयोग से पहले स्पष्ट approval की ज़रूरत होती है। access
> मिलने तक, इनमें से किसी एक का नाम देने वाली request `model_access_denied` error के साथ reject हो जाती है। Enterprise
> customers access का अनुरोध करने के लिए support से संपर्क कर सकते हैं।

### इमेज मॉडल

| `model_id`                    | रेफ़रेंस इमेज             | आउटपुट कंट्रोल्स                                                   |
| ----------------------------- | ------------------------- | ------------------------------------------------------------------ |
| `gpt-image-1`                 | अधिकतम 5, साथ में `mask`  | `aspect_ratio` (1:1, 3:2, 2:3), `quality`, `background`            |
| `gpt-image-1.5`               | अधिकतम 5, साथ में `mask`  | `aspect_ratio` (1:1, 3:2, 2:3), `quality`, `background`            |
| `gpt-image-2`                 | अधिकतम 10, साथ में `mask` | 15 aspect ratios, `resolution` (1K, 2K, 4K), `quality`             |
| `gpt-image-2.5-sunburst`      | अधिकतम 10, साथ में `mask` | 15 aspect ratios, `resolution` (1K, 2K, 4K), `quality` (`max` तक)  |
| `gpt-image-2.5-flare`         | अधिकतम 10, साथ में `mask` | 15 aspect ratios, `resolution` (1K, 2K, 4K), `quality` (`max` तक)  |
| `gemini-2.5-flash-image`      | अधिकतम 5                  | `aspect_ratio`                                                     |
| `gemini-3-pro-image`          | अधिकतम 10                 | `aspect_ratio`, `resolution` (1K, 2K, 4K)                          |
| `gemini-3.1-flash-image`      | अधिकतम 14                 | `aspect_ratio` (1:4, 4:1, 1:8, 8:1 समेत), `resolution` (512 से 4K) |
| `gemini-3.1-flash-lite-image` | अधिकतम 14                 | `aspect_ratio`, `resolution` (1K)                                  |
| `bytedance-seedream-5-lite`   | अधिकतम 10                 | `aspect_ratio`, `resolution` (2K, 3K), `seed`                      |
| `bytedance-seedream-5-pro`    | अधिकतम 10                 | `aspect_ratio`, `resolution` (1K, 2K), `seed`                      |

GPT Image 2.5 models `quality` के लिए `low`, `medium`, `high`, `xhigh` और `max` values स्वीकार करते हैं, और
diff़ॉल्ट रूप से `high` होता है। GPT Image 2 की अधिकतम value `high` है और डिफ़ॉल्ट रूप से `medium` होता है।

### वीडियो मॉडल

| `model_id`                   | मीडिया इनपुट्स                                                           | आउटपुट कंट्रोल्स                                                                                         |
| ---------------------------- | ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
| `veo-3.1-generate-001`       | `start_frame`, `end_frame`, `role` के साथ अधिकतम 3 `images`              | `duration_secs` (4, 6, 8), `aspect_ratio` (16:9, 9:16), `resolution` (720p, 1080p, 4K), `generate_audio` |
| `veo-3.1-fast-generate-001`  | `start_frame`, `end_frame`, `role` के साथ अधिकतम 3 `images`              | `duration_secs` (4, 6, 8), `aspect_ratio` (16:9, 9:16), `resolution` (720p, 1080p, 4K), `generate_audio` |
| `bytedance-seedance-v2`      | `start_frame`, `end_frame`, अधिकतम 9 `images`, 3 `videos`, 3 `audios`    | `duration_secs` (4 से 15), 7 aspect ratios, `resolution` (480p से 4k), `generate_audio`                  |
| `bytedance-seedance-v2-fast` | `start_frame`, `end_frame`, अधिकतम 9 `images`, 3 `videos`, 3 `audios`    | `duration_secs` (4 से 15), 7 aspect ratios, `resolution` (480p, 720p), `generate_audio`                  |
| `bytedance-seedance-v2-mini` | `start_frame`, `end_frame`, अधिकतम 9 `images`, 3 `videos`, 3 `audios`    | `duration_secs` (4 से 15), 7 aspect ratios, `resolution` (480p, 720p), `generate_audio`                  |
| `bytedance-seedance-v2.5`    | `start_frame`, `end_frame`, अधिकतम 30 `images`, 10 `videos`, 10 `audios` | `duration_secs` (4 से 30), 7 aspect ratios, `resolution` (480p, 720p), `generate_audio`                  |
| `creatify-aurora`            | `image` और `audio`, दोनों ज़रूरी                                         | `resolution` (480p, 720p), `guidance_scale`, `audio_guidance_scale`                                      |

model capabilities, availability और pricing के लिए
[Image & Video overview](/docs/hi/overview/capabilities/image-video) देखें।

## अगले चरण

#### [रेफ़रेंसेज़ और एसेट्स](/docs/hi/eleven-api/guides/how-to/image-and-video/references)

किसी पिछले generation, uploaded asset या inline media के साथ generation को निर्देशित करें।

#### [वेबहुक](/docs/hi/eleven-api/guides/how-to/image-and-video/webhooks)

उसके लिए poll करने के बजाय generation का result पाएँ।

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

इमेज, वीडियो और asset endpoints देखें।