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

# डबिंग प्रोजेक्ट बनाएं

POST https://api.elevenlabs.io/v1/dubbing/project
Content-Type: multipart/form-data

अपलोड की गई फ़ाइल (`file`) या सोर्स URL (`source_url`) से डबिंग प्रोजेक्ट बनाएं।

सोर्स फ़ेच होने से पहले ही, प्रोजेक्ट रिकॉर्ड बनते ही रिस्पॉन्स लौटता है: प्रोजेक्ट `queued` से शुरू होता है और सोर्स का ट्रांसक्रिप्शन पूरा होने पर `ready` हो जाता है। हर इच्छित भाषा के लिए इसमें एक भाषा टारगेट जोड़ें या यहाँ पहले टारगेट को क्यू में डालने के लिए `target_language` दें।

प्रोजेक्ट बनाने पर कम-से-कम एक भाषा का शुल्क लगता है: कोई आउटपुट मौजूद होने से पहले ही प्रोजेक्ट बनाते समय कम-से-कम एक भाषा की डबिंग का शुल्क लिया जाता है। यह शुल्क पहले भाषा टारगेट के लिए अग्रिम भुगतान है — आपके द्वारा जोड़ा गया पहला टारगेट, या `target_language` से क्यू किया गया टारगेट, इसे इस्तेमाल करता है — और हर अतिरिक्त भाषा का अलग से शुल्क लिया जाता है।

लंबे सोर्स की तैयारी में कई मिनट लग सकते हैं, इसलिए प्रोजेक्ट के `ready` या `failed` होने पर सूचना पाने के लिए पोलिंग के बजाय `webhook_ids` पास करने की सलाह दी जाती है।

Reference: https://elevenlabs.io/docs/api-reference/dubbing/create-project

## Servers

- `https://api.elevenlabs.io` (Production, default)
- `https://api.us.elevenlabs.io` (Production US)
- `https://api.eu.residency.elevenlabs.io` (Production EU)
- `https://api.in.residency.elevenlabs.io` (Production India)
- `https://api.sg.residency.elevenlabs.io` (Production Singapore)

## Request

### Body (multipart/form-data)

This endpoint expects a multipart form with multiple files.

- `file` (file, optional) — डब करने के लिए स्रोत मीडिया फ़ाइल: अधिकतम 3 GiB की ऑडियो या वीडियो फ़ाइल। यह या `source_url` दें, दोनों नहीं।
- `source_url` (string, optional) — सार्वजनिक HTTP(S) URL, जिससे सर्वर-साइड पर source media फ़ेच किया जाता है और जिस पर अपलोड जैसी ही आकार व फ़ॉर्मैट सीमाएं लागू होती हैं। यह या `file` दें, दोनों नहीं।
- `reference` (string, optional) — आपकी तरफ़ project की पहचान के लिए वैकल्पिक free-form string (अधिकतम 500 characters)। इसे ज्यों-का-त्यों संग्रहीत और वापस भेजा जाता है; इससे dub प्रभावित नहीं होता।
- `source_language` (string, optional) — सोर्स मीडिया का BCP-47 भाषा टैग; यह ट्रांसक्रिप्शन मॉडल द्वारा समर्थित भाषा होनी चाहिए। क्षेत्र या स्क्रिप्ट का कोई भी सबटैग अनदेखा किया जाता है, क्योंकि ट्रांसक्रिप्शन प्रति-भाषा होता है। ऑटो-डिटेक्ट के लिए इसे छोड़ दें।
- `model_id` (V1DubbingProjectPostRequestBodyContentMultipartFormDataSchemaModelId, optional) — डबिंग मॉडल (`dubbing_v1` या `dubbing_v2`) जिससे इस प्रोजेक्ट के हर भाषा टारगेट को डब किया जाता है। डिफ़ॉल्ट `dubbing_v2` है। इसे बनाते समय तय किया जाता है — सोर्स इस मॉडल के लिए तैयार किया जाता है, इसलिए बाद में न प्रोजेक्ट और न ही कोई व्यक्तिगत टारगेट इसे बदल सकता है।
- `keyterms` (list of string, optional) — ट्रांसक्रिप्शन और अनुवाद को प्राथमिकता देने के लिए मुख्य शब्द (जैसे, प्रोडक्ट या ब्रांड नाम)। अधिकतम 1,000 शब्द; हर शब्द में अधिकतम 50 वर्ण और 5 शब्द; `<>{}[]\` वर्णों की अनुमति नहीं है। शब्दों से अतिरिक्त स्पेस हटाए जाते हैं और डुप्लिकेट हटाए जाते हैं। हर शब्द के लिए फ़ील्ड को एक बार दोहराएं या एक अकेला JSON array दें।
- `webhook_ids` (list of string, optional) — प्रोजेक्ट की प्रगति के दौरान सूचित किए जाने वाले workspace webhooks की ID — polling का विकल्प और हमारी सिफ़ारिश। हर webhook को प्रोजेक्ट के लिए `dubbing_project_ready` या `dubbing_project_failed` इवेंट और उसके अंतर्गत हर भाषा के लिए `dubbing_language_completed` या `dubbing_language_failed` इवेंट मिलता है; `dubbing_language_completed` में आउटपुट डाउनलोड URLs होते हैं। अधिकतम 3 ID, जिनमें से हर एक आपके workspace में पहले से कॉन्फ़िगर हो — इसे बनाने और इसके सिग्नेचर की पुष्टि करने का तरीका जानने के लिए [Webhooks](https://elevenlabs.io/docs/eleven-api/resources/webhooks) देखें। हर ID के लिए फ़ील्ड एक बार दोहराएं या एकल JSON array अथवा कॉमा से अलग की गई स्ट्रिंग पास करें। डिलीवरी best-effort है और दोहराई जा सकती है, इसलिए हम इवेंट को idempotently हैंडल करने की सलाह देते हैं।
- `target_language` (string, optional) — वैकल्पिक shortcut: इस BCP-47 language में एक language target भी बनाएं, जिसे project तैयार होने पर शुरू करने के लिए queue किया जाता है — यह project बनाने और फिर एक language target बनाने के बराबर है। यह [डबिंग मॉडल द्वारा समर्थित भाषाओं](https://elevenlabs.io/docs/help-center/product/dubbing/which-languages-are-supported-in-dubbing) में से एक होनी चाहिए और region-qualified tag समर्थित dialects में से एक होना चाहिए। यह पहला language target है, इसलिए यह project के न्यूनतम charge का उपयोग करता है, उसमें अतिरिक्त नहीं जुड़ता। इसकी ID `language_ids` में लौटाई जाती है।
- `transcript` (file, optional) — केवल Enterprise के लिए। स्रोत को ट्रांसक्राइब करने के बजाय इस्तेमाल करने के लिए वैकल्पिक JSON ट्रांसक्रिप्ट: एक `{"segments": [...]}` दस्तावेज़, जिसमें अधिकतम 20,000 सेगमेंट और 4 MiB हो सकते हैं। सेगमेंट फ़ील्ड और उनकी सीमाओं के लिए [अपना ट्रांसक्रिप्ट लाएं](https://elevenlabs.io/docs/eleven-api/guides/how-to/dubbing/bring-your-own-transcript) देखें। ट्रांसक्रिप्ट दिए जाने पर `source_language` आवश्यक है। अगर किसी सेगमेंट में `translation` है, तो `target_language` आवश्यक है और हर सेगमेंट में अनुवाद होना चाहिए; ये अनुवाद `target_language` के ज़रिए बनाए गए टारगेट को आरंभिक डेटा देते हैं, जो फिर मशीन अनुवाद को छोड़ देता है।

## Response

### 201

सफल रिस्पॉन्स

- `project_id` (string, required) — डबिंग प्रोजेक्ट का विशिष्ट पहचानकर्ता।
- `status` (enum, required) — प्रोजेक्ट की लाइफ़साइकल स्थिति: सोर्स उठाए जाने से पहले `queued`, ट्रांसक्राइब होने के दौरान `preparing`, ट्रांसक्रिप्शन पूरा होने और भाषा टारगेट शुरू हो सकने पर `ready`, या `failed`। किसी प्रोजेक्ट की स्थिति कभी `processing` के रूप में रिपोर्ट नहीं होती — यह मान भाषा टारगेट के लिए है।
  - Allowed values: `queued`, `preparing`, `processing`, `ready`, `failed`
- `revision` (integer, required) — सोर्स ट्रांसक्रिप्ट संपादित होने पर बढ़ने वाला मोनोटोनिक काउंटर (सेगमेंट जोड़ना/संपादित करना/हटाना)।
- `created_at` (string, required) — प्रोजेक्ट कब बनाया गया था।
- `updated_at` (string, required) — प्रोजेक्ट को आखिरी बार कब अपडेट किया गया था।
- `reference` (string, optional, nullable) — प्रोजेक्ट बनाते समय `reference` के रूप में दी गई आपकी मुक्त-रूप स्ट्रिंग, या अगर आपने कुछ नहीं दिया है तो null।
- `source_language` (string, optional, nullable) — सोर्स मीडिया का BCP-47 भाषा टैग (ऑटो-डिटेक्ट होने पर null)।
- `model_id` (string, optional, nullable) — डबिंग मॉडल जिससे इस प्रोजेक्ट के हर भाषा टारगेट को डब किया जाता है। इसे बनाते समय तय किया जाता है और हर भाषा के लिए अलग से नहीं चुना जा सकता।
- `media` (DubbingSourceMediaInfo, optional, nullable) — source media metadata, source के fetch और decode होने पर भरा जाता है (create के तुरंत बाद, project के `ready` होने से पहले); तब तक null।
- `language_ids` (list of string, optional, default: []) — इस प्रोजेक्ट के अंतर्गत भाषा टारगेट के पहचानकर्ता। एकल प्रोजेक्ट पाने पर और `target_language` द्वारा कोई टारगेट बनाए जाने पर यह भरा जाता है। सूची रिस्पॉन्स में यह हमेशा खाली होता है — इसके बजाय प्रोजेक्ट के भाषा टारगेट सूचीबद्ध करें।
- `webhook_ids` (list of string, optional, default: []) — इस प्रोजेक्ट और इसकी भाषाओं के `ready`, `completed` या `failed` होने पर सूचित किए जाने वाले workspace webhooks की ID।
- `error` (DubbingError, optional, nullable) — प्रोजेक्ट क्यों विफल हुआ; `status` के `failed` होने तक null। उन कुछ प्रोजेक्ट्स के लिए भी null, जो विफलता रिपोर्टिंग शुरू होने से पहले विफल हुए थे।
- `warnings` (list of VoicesNotPermittedWarning, optional) — सोर्स तैयार करते समय उठी गैर-गंभीर स्थितियाँ; कोई न होने पर खाली। यह नवीनतम तैयारी को दर्शाता है। किसी खास भाषा की डबिंग के दौरान उठी स्थितियाँ इसके बजाय उस भाषा पर रिपोर्ट होती हैं।

## Errors

### 422 Unprocessable Entity Error

वैलिडेशन एरर

- `detail` (list of ValidationError, optional)

## Types

### DubbingSourceMediaInfo

प्रोजेक्ट के सोर्स मीडिया का मेटाडेटा।

- `filename` (string, optional, nullable) — अपलोड किए गए source media का मूल फ़ाइलनाम (URL sources के लिए null)।
- `duration_s` (double, optional, nullable) — सोर्स मीडिया की अवधि, सेकंड में।
- `has_video` (boolean, optional, nullable) — क्या source media में video stream है।
- `mime_type` (string, optional, nullable) — अपलोड किए गए सोर्स मीडिया का MIME टाइप (URL सोर्स के लिए null)।

### DubbingError

- `message_type` ("error", required)
- `error` (string, required)

### VoicesNotPermittedWarning

- `type` ("voices_not_permitted", required) — इस चेतावनी की पहचान करता है; अन्य फ़ील्ड पढ़ने के लिए इस पर ब्रांच करें।
- `speaker_ids` (list of string, required) — वे speakers जिनकी voices को cloning की अनुमति नहीं थी। dub ने उनमें से हर एक के लिए replacement voice इस्तेमाल की; अन्य सभी speakers अप्रभावित हैं।
- `message` (string, required) — डिस्प्ले के लिए चेतावनी का मानव-पठनीय विवरण। शब्दावली कभी भी बदल सकती है, इसलिए हम इसके बजाय `type` पर ब्रांचिंग की सलाह देते हैं।

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)

### ValidationErrorLocItems

## Examples

**Request**

```json
{
  "file": "<file: <file1>>",
  "reference": "Q3 marketing video",
  "source_language": "en",
  "source_url": "https://example.com/promo.mp4",
  "transcript": "<file: <file1>>"
}
```

**Response**

```json
{
  "project_id": "proj_1601kwkyxp0hfzvtmyxwqxx6mcy3",
  "status": "queued",
  "revision": 0,
  "created_at": "2026-07-03T10:15:30Z",
  "updated_at": "2026-07-03T10:15:30Z",
  "reference": "Q3 marketing video",
  "source_language": "en",
  "model_id": "dubbing_v2",
  "language_ids": [],
  "webhook_ids": [],
  "warnings": []
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/dubbing/project"

files = {
    "file": "open('<file1>', 'rb')",
    "transcript": "open('<file1>', 'rb')"
}
payload = {
    "keyterms": ,
    "model_id": ,
    "reference": "Q3 marketing video",
    "source_language": "en",
    "source_url": "https://example.com/promo.mp4",
    "target_language": ,
    "webhook_ids": 
}

response = requests.post(url, data=payload, files=files)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/dubbing/project';
const form = new FormData();
form.append('file', '<file1>');
form.append('keyterms', '');
form.append('model_id', '');
form.append('reference', 'Q3 marketing video');
form.append('source_language', 'en');
form.append('source_url', 'https://example.com/promo.mp4');
form.append('target_language', '');
form.append('transcript', '<file1>');
form.append('webhook_ids', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.elevenlabs.io/v1/dubbing/project"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"keyterms\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"model_id\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"reference\"\r\n\r\nQ3 marketing video\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_language\"\r\n\r\nen\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_url\"\r\n\r\nhttps://example.com/promo.mp4\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"target_language\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"transcript\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_ids\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.elevenlabs.io/v1/dubbing/project")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"keyterms\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"model_id\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"reference\"\r\n\r\nQ3 marketing video\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_language\"\r\n\r\nen\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_url\"\r\n\r\nhttps://example.com/promo.mp4\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"target_language\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"transcript\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_ids\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.elevenlabs.io/v1/dubbing/project")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"keyterms\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"model_id\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"reference\"\r\n\r\nQ3 marketing video\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_language\"\r\n\r\nen\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_url\"\r\n\r\nhttps://example.com/promo.mp4\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"target_language\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"transcript\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_ids\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/dubbing/project', [
  'multipart' => [
    [
        'name' => 'file',
        'filename' => '<file1>',
        'contents' => null
    ],
    [
        'name' => 'reference',
        'contents' => 'Q3 marketing video'
    ],
    [
        'name' => 'source_language',
        'contents' => 'en'
    ],
    [
        'name' => 'source_url',
        'contents' => 'https://example.com/promo.mp4'
    ],
    [
        'name' => 'transcript',
        'filename' => '<file1>',
        'contents' => null
    ]
  ]
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/dubbing/project");
var request = new RestRequest(Method.POST);
request.AddParameter("undefined", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"keyterms\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"model_id\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"reference\"\r\n\r\nQ3 marketing video\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_language\"\r\n\r\nen\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"source_url\"\r\n\r\nhttps://example.com/promo.mp4\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"target_language\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"transcript\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"webhook_ids\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation
let parameters = [
  [
    "name": "file",
    "fileName": "<file1>"
  ],
  [
    "name": "keyterms",
    "value": 
  ],
  [
    "name": "model_id",
    "value": 
  ],
  [
    "name": "reference",
    "value": "Q3 marketing video"
  ],
  [
    "name": "source_language",
    "value": "en"
  ],
  [
    "name": "source_url",
    "value": "https://example.com/promo.mp4"
  ],
  [
    "name": "target_language",
    "value": 
  ],
  [
    "name": "transcript",
    "fileName": "<file1>"
  ],
  [
    "name": "webhook_ids",
    "value": 
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/dubbing/project")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```