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

# Doeltaal voor nasynchronisatie maken

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

Voeg een taal toe waarin je een project wilt nasynchroniseren en plaats de nasynchronisatie in de wachtrij.

Deze aanroep produceert nagesynchroniseerde audio en wordt per generatie gefactureerd. Het doel wordt gemaakt als `queued` en start zodra het project `ready` is. Je kunt het dus op elk moment toevoegen nadat het project is gemaakt. Het neemt het nasynchronisatiemodel van het project over en kan geen ander model kiezen.

Een project dat is gemaakt met `webhook_ids` stuurt een `dubbing_language_completed`-event met de download-URL's van de uitvoer. Daarom raden we aan je te abonneren in plaats van dit doel te pollen tot het voltooid is.

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) — ID van het bovenliggende nasynchronisatieproject.

### 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-taaltag voor de taal waarin het project moet worden nagesynchroniseerd (bijvoorbeeld `fr` of `es-MX`). Moet een van de [talen zijn die het nasynchronisatiemodel van het project ondersteunt](https://elevenlabs.io/docs/help-center/product/dubbing/which-languages-are-supported-in-dubbing), en een tag met regioaanduiding moet een van de ondersteunde dialecten zijn.
- `voice_settings` (VoiceSettings, optional, nullable) — Steminstellingen die op elke spreker in deze taal worden toegepast. Laat weg om de standaardinstellingen te gebruiken.
- `translations` (map from string to string, optional, nullable) — Alleen voor Enterprise. Optionele vertalingen om te gebruiken in plaats van machinevertaling. Een toewijzing van de `external_id` van elk bronsegment (of de `id` als je er geen hebt opgegeven) naar de vertaalde tekst; elk bronsegment moet precies één keer worden opgenomen. Maximaal 20.000 vermeldingen, samen maximaal 4 MiB tekst. Zie [Gebruik je eigen transcript](https://elevenlabs.io/docs/eleven-api/guides/how-to/dubbing/bring-your-own-transcript).

## Response

### 201

Geslaagde response

- `language_id` (string, required) — Unieke identificatiecode van het taaldoel.
- `project_id` (string, required) — ID van het bovenliggende nasynchronisatieproject.
- `target_language` (string, required) — BCP-47-taaltag waarnaar dit doel wordt nagesynchroniseerd.
- `status` (enum, required) — Levenscyclusstatus: `queued` (wacht tot het project klaar is of op een worker), `processing` tijdens de nasynchronisatie, `completed` zodra de uitvoer beschikbaar is, `stale` wanneer het transcript is gewijzigd nadat de uitvoer is geproduceerd, of `failed`.
  - Allowed values: `queued`, `processing`, `completed`, `stale`, `failed`
- `revision` (integer, required) — Monotone teller die wordt verhoogd wanneer het transcript van dit doel verandert (door een bronbewerking die het beïnvloedt of een bewerking van de vertaling).
- `created_at` (string, required) — Wanneer het taaldoel is gemaakt.
- `updated_at` (string, required) — Wanneer het taaldoel voor het laatst is bijgewerkt.
- `model_id` (string, optional, nullable) — Nasynchronisatiemodel waarmee dit doel van nasynchronisatie wordt voorzien, overgenomen van het project en niet per taal selecteerbaar.
- `voice_settings` (VoiceSettings, optional, nullable) — Steminstellingen die op elke spreker in deze taal worden toegepast, of null als de standaardinstellingen gelden.
- `outputs` (DubbingLanguageOutputs, optional, nullable) — Ondertekende output-URL's; null totdat het doel output heeft geproduceerd (aanwezig zodra `completed`, en behouden zolang `stale` — vergelijk `output_revision` met `revision` om te bepalen of de output actueel is).
- `output_revision` (integer, optional, nullable) — De `revision` waaruit de huidige nagesynchroniseerde uitvoer is gegenereerd; gelijk aan `revision` wanneer deze actueel is en lager wanneer deze `stale` is. Dit is null totdat een generatie is voltooid.
- `error` (DubbingError, optional, nullable) — Waarom deze taal is mislukt; null tenzij `status` `failed` is, en ook null voor de enkele talen die mislukten voordat foutrapportage werd ingevoerd. Een code van `project_failed` betekent dat het bovenliggende project is mislukt; raadpleeg dus het project voor de onderliggende oorzaak.
- `warnings` (list of VoicesNotPermittedWarning, optional) — Niet-fatale omstandigheden die zijn opgetreden tijdens het nasynchroniseren van deze taal, of leeg als er geen zijn. Weerspiegelt de nieuwste generatie. Omstandigheden die zijn opgetreden tijdens het voorbereiden van de bron worden in plaats daarvan bij het project gerapporteerd.

## Errors

### 422 Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### VoiceSettings

- `cloning_strength` (integer, optional, default: 7) — Hoe sterk de nagesynchroniseerde sprekers de bronstemmen klonen, van 0 tot 10.

### DubbingLanguageOutputs

Ondertekende download-URL's met beperkte geldigheidsduur voor de output van een taaldoel.

- `lossless_audio` (string, optional, nullable) — Ondertekende URL voor de nagesynchroniseerde lossless audiotrack in FLAC. De link verloopt een uur nadat deze is uitgegeven; lees het taaldoel opnieuw uit voor een nieuwe link.
- `subtitles` (string, optional, nullable) — Ondertekende URL voor de vertaalde regels als WebVTT-ondertiteling, getimed op de bronspraak. Null als er geen beschikbaar zijn, zoals voor talen die zijn nagesynchroniseerd voordat ondertiteling werd geproduceerd. De link verloopt een uur nadat deze is uitgegeven.

### DubbingError

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

### VoicesNotPermittedWarning

- `type` ("voices_not_permitted", required) — Identificeert deze waarschuwing; gebruik dit om te vertakken en de andere velden te lezen.
- `speaker_ids` (list of string, required) — Speakers waarvan de stemmen niet mochten worden gekloond. De dub gebruikte voor elk van hen een vervangende stem; alle andere speakers blijven ongewijzigd.
- `message` (string, required) — Voor mensen leesbare beschrijving van de waarschuwing, voor weergave. De formulering kan op elk moment veranderen, dus we raden aan in plaats daarvan te vertakken op `type`.

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