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

# Synchronisationssprachziel erstellen

POST https://api.elevenlabs.io/v1/dubbing/project/{project_id}/language
Content-Type: application/json

Fügen Sie einem Projekt eine Sprache für die Synchronisation hinzu und stellen Sie die Synchronisation in die Warteschlange.

Dieser Aufruf erzeugt synchronisiertes Audio und wird pro Generierung abgerechnet. Das Ziel wird mit dem Status `queued` erstellt und startet, sobald das Projekt `ready` ist. Es kann also jederzeit nach der Projekterstellung hinzugefügt werden. Es übernimmt das Synchronisationsmodell des Projekts und kann kein anderes auswählen.

Ein mit `webhook_ids` erstelltes Projekt sendet ein `dubbing_language_completed`-Ereignis mit den Download-URLs der Ausgabe. Wir empfehlen daher, es zu abonnieren, statt dieses Ziel bis zum Abschluss abzufragen.

Reference: https://elevenlabs.io/docs/api-reference/dubbing/language-targets/create-language-target

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

### Path parameters

- `project_id` (string, required) — Kennung des übergeordneten Synchronisationsprojekts.

### Body (application/json)

This endpoint expects a Body_Create_Dubbing_Language_Target_v1_dubbing_project__project_id__language_post.

- `target_language` (string, required) — BCP-47-Sprach-Tag, in den das Projekt synchronisiert werden soll (z. B. `fr` oder `es-MX`). Muss eine der [vom Synchronisationsmodell des Projekts unterstützten Sprachen](https://elevenlabs.io/docs/help-center/product/dubbing/which-languages-are-supported-in-dubbing) sein. Ein regionsspezifisches Tag muss einem der unterstützten Dialekte entsprechen.
- `voice_settings` (VoiceSettings, optional, nullable) — Stimmeneinstellungen, die auf jeden Sprecher dieser Sprache angewendet werden. Weglassen, um die Standardwerte zu verwenden.
- `translations` (map from string to string, optional, nullable) — Nur Enterprise. Optionale Übersetzungen zur Verwendung anstelle der maschinellen Übersetzung. Eine Zuordnung von der `external_id` jedes Quellsegments (oder dessen `id`, falls keine angegeben wurde) zum übersetzten Text; jedes Quellsegment muss genau einmal abgedeckt sein. Maximal 20.000 Einträge mit insgesamt maximal 4 MiB Text. Siehe [Eigenes Transkript verwenden](https://elevenlabs.io/docs/eleven-api/guides/how-to/dubbing/bring-your-own-transcript).

## Response

### 201

Erfolgreiche Antwort

- `language_id` (string, required) — Eindeutige Kennung des Sprachziels.
- `project_id` (string, required) — Kennung des übergeordneten Synchronisationsprojekts.
- `target_language` (string, required) — BCP-47-Sprach-Tag, in den dieses Ziel synchronisiert wird.
- `status` (enum, required) — Lebenszyklusstatus: `queued` (wartet darauf, dass das Projekt bereit ist oder auf einen Worker), `processing` während der Synchronisierung, `completed`, sobald die Ausgabe verfügbar ist, `stale`, wenn das Transkript nach der Erstellung der Ausgabe geändert wurde, oder `failed`.
  - Allowed values: `queued`, `processing`, `completed`, `stale`, `failed`
- `revision` (integer, required) — Monotoner Zähler, der bei jeder Änderung des Transkripts dieses Ziels erhöht wird (eine es betreffende Quellbearbeitung oder eine Änderung seiner Übersetzung).
- `created_at` (string, required) — Zeitpunkt der Erstellung des Sprachziels.
- `updated_at` (string, required) — Zeitpunkt der letzten Aktualisierung des Sprachziels.
- `model_id` (string, optional, nullable) — Synchronisierungsmodell, mit dem dieses Ziel synchronisiert wird, vom Projekt übernommen und nicht pro Sprache auswählbar.
- `voice_settings` (VoiceSettings, optional, nullable) — Stimmeneinstellungen, die auf jeden Sprecher dieser Sprache angewendet werden, oder null, wenn die Standardwerte gelten.
- `outputs` (DubbingLanguageOutputs, optional, nullable) — Signierte Ausgabe-URLs; null, bis das Ziel eine Ausgabe erzeugt hat (vorhanden bei `completed` und beibehalten bei `stale` – vergleichen Sie `output_revision` mit `revision`, um festzustellen, ob die Ausgabe aktuell ist).
- `output_revision` (integer, optional, nullable) — Die `revision`, aus der die aktuelle synchronisierte Ausgabe generiert wurde; sie entspricht `revision`, wenn sie aktuell ist, und ist niedriger, wenn sie `stale` ist. Bis eine Generierung abgeschlossen ist, lautet der Wert null.
- `error` (DubbingError, optional, nullable) — Warum diese Sprache fehlgeschlagen ist; null, sofern `status` nicht `failed` ist, sowie für die wenigen Sprachen, die vor Einführung der Fehlerberichterstattung fehlgeschlagen sind. Der Code `project_failed` bedeutet, dass das übergeordnete Projekt fehlgeschlagen ist. Prüfen Sie daher das Projekt auf die zugrunde liegende Ursache.
- `warnings` (list of VoicesNotPermittedWarning, optional) — Nicht schwerwiegende Bedingungen, die bei der Synchronisation dieser Sprache aufgetreten sind; leer, wenn keine vorliegen. Spiegelt die neueste Generierung wider. Bedingungen bei der Vorbereitung der Quelle werden stattdessen im Projekt gemeldet.

## Errors

### 422 Unprocessable Entity Error

Validierungsfehler

- `detail` (list of ValidationError, optional)

## Types

### VoiceSettings

- `cloning_strength` (integer, optional, default: 7) — Wie stark die synchronisierten Sprecher die Quellstimmen klonen, von 0 bis 10.

### DubbingLanguageOutputs

Signierte, zeitlich begrenzte Download-URLs für die Ausgaben eines Sprachziels.

- `lossless_audio` (string, optional, nullable) — Signierte URL für die synchronisierte verlustfreie Audiospur im FLAC-Format. Der Link läuft eine Stunde nach seiner Ausstellung ab; lesen Sie das Sprachziel erneut ab, um eine aktuelle URL zu erhalten.
- `subtitles` (string, optional, nullable) — Signierte URL für die übersetzten Zeilen als WebVTT-Untertitel, zeitlich auf die Ausgangssprache abgestimmt. Null, wenn keine verfügbar sind, etwa für Sprachen, die synchronisiert wurden, bevor Untertitel erstellt wurden. Der Link läuft eine Stunde nach seiner Ausstellung ab.

### DubbingError

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

### VoicesNotPermittedWarning

- `type` ("voices_not_permitted", required) — Kennzeichnet diese Warnung; verwenden Sie sie zur Verzweigung, um die anderen Felder zu lesen.
- `speaker_ids` (list of string, required) — Sprecher, deren Stimmen nicht zum Klonen freigegeben waren. Für jeden von ihnen wurde bei der Synchronisierung eine Ersatzstimme verwendet; alle anderen Sprecher bleiben unverändert.
- `message` (string, required) — Menschenlesbare Beschreibung der Warnung zur Anzeige. Der Wortlaut kann sich jederzeit ändern. Wir empfehlen daher, stattdessen nach `type` zu verzweigen.

### ValidationError

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

### ValidationErrorLocItems

## Examples

**Request**

```json
{
  "target_language": "es"
}
```

**Response**

```json
{
  "language_id": "lang_1001kwkyxp0je6ktn4knsfrasx5s",
  "project_id": "proj_1601kwkyxp0hfzvtmyxwqxx6mcy3",
  "target_language": "es",
  "status": "queued",
  "revision": 0,
  "created_at": "2026-07-03T10:16:00Z",
  "updated_at": "2026-07-03T10:16:00Z",
  "model_id": "dubbing_v2",
  "warnings": []
}
```

**SDK Code**

```python
import requests

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

payload = { "target_language": "es" }
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/dubbing/project/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"target_language":"es"}'
};

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/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language"

	payload := strings.NewReader("{\n  \"target_language\": \"es\"\n}")

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

	req.Header.Add("Content-Type", "application/json")

	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/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"target_language\": \"es\"\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/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language")
  .header("Content-Type", "application/json")
  .body("{\n  \"target_language\": \"es\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/dubbing/project/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language', [
  'body' => '{
  "target_language": "es"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/dubbing/project/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"target_language\": \"es\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["target_language": "es"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/dubbing/project/proj_1601kwkyxp0hfzvtmyxwqxx6mcy3/language")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()
```