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

# Een stem ontwerpen.

POST https://api.elevenlabs.io/v1/text-to-voice/design
Content-Type: application/json

Ontwerp een stem met een prompt. Deze methode retourneert een lijst met stemvoorbeelden. Elk voorbeeld heeft een generated_voice_id en een stemfragment als base64-gecodeerde mp3-audio. Gebruik de generated_voice_id van het gewenste voorbeeld met het endpoint /v1/text-to-voice om een stem te maken.

Reference: https://elevenlabs.io/docs/api-reference/text-to-voice/design

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

### Query parameters

- `output_format` (enum, optional) — Output format of the generated audio. Formatted as codec_sample_rate_bitrate. So an mp3 with 22.05kHz sample rate at 32kbs is represented as mp3_22050_32. MP3 with 192kbps bitrate requires you to be subscribed to Creator tier or above. PCM with 44.1kHz sample rate requires you to be subscribed to Pro tier or above. Note that the μ-law format (sometimes written mu-law, often approximated as u-law) is commonly used for Twilio audio inputs.
  - Allowed values: `mp3_22050_32`, `mp3_24000_48`, `mp3_44100_32`, `mp3_44100_64`, `mp3_44100_96`, `mp3_44100_128`, `mp3_44100_192`, `pcm_8000`, `pcm_16000`, `pcm_22050`, `pcm_24000`, `pcm_32000`, `pcm_44100`, `pcm_48000`, `ulaw_8000`, `alaw_8000`, `opus_48000_32`, `opus_48000_64`, `opus_48000_96`, `opus_48000_128`, `opus_48000_192`

### Body (application/json)

This endpoint expects a VoiceDesignRequestModel.

- `voice_description` (string, required) — Beschrijving voor de gemaakte stem.
- `model_id` (enum, optional, default: eleven_multilingual_ttv_v2) — Model dat voor het genereren van de stem moet worden gebruikt. Mogelijke waarden: eleven_multilingual_ttv_v2, eleven_ttv_v3.
  - Allowed values: `eleven_multilingual_ttv_v2`, `eleven_ttv_v3`
- `text` (string, optional, nullable) — Te genereren tekst; de tekstlengte moet tussen 100 en 1000 liggen.
- `auto_generate_text` (boolean, optional, default: false) — Of er automatisch een tekst moet worden gegenereerd die geschikt is voor de stembeschrijving.
- `loudness` (double, optional, default: 0.5) — Bepaalt het volumeniveau van de gegenereerde stem. -1 is het zachtst, 1 het hardst en 0 komt overeen met ongeveer -24 LUFS.
- `seed` (integer, optional, nullable) — Willekeurig getal dat de stemgeneratie aanstuurt. Dezelfde seed met dezelfde invoer produceert dezelfde stem.
- `guidance_scale` (double, optional, default: 5) — Bepaalt hoe nauw de AI de prompt volgt. Lagere waarden geven de AI meer ruimte om creatief te zijn, terwijl hogere waarden de AI dwingen zich sterker aan de prompt te houden. Hoge waarden kunnen ervoor zorgen dat de stem kunstmatig of robotachtig klinkt. We raden aan langere, gedetailleerdere prompts te gebruiken bij een lagere Guidance Scale.
- `stream_previews` (boolean, optional, default: false) — Bepaalt of de Text to Voice-voorbeelden in het antwoord moeten worden opgenomen. Als dit waar is, worden alleen de gegenereerde ID's geretourneerd. Deze kunnen vervolgens worden gestreamd via het endpoint /v1/text-to-voice/:generated_voice_id/stream.
- `should_enhance` (boolean, optional, default: false) — Of de stembeschrijving met AI moet worden verbeterd om meer details toe te voegen en de kwaliteit van stemgeneratie te verbeteren. Wanneer ingeschakeld, breidt het systeem eenvoudige prompts automatisch uit tot uitgebreidere stembeschrijvingen. Standaard is False.
- `remixing_session_id` (string, optional, nullable) — De remixsessie-id.
- `remixing_session_iteration_id` (string, optional, nullable) — De id van de iteratie van de remixsessie waaraan deze generaties moeten worden gekoppeld. Als deze niet is opgegeven, wordt een nieuwe iteratie gemaakt.
- `quality` (double, optional, nullable) — Hogere kwaliteit resulteert in betere stemoutput, maar minder variatie.
- `reference_audio_base64` (string, optional, nullable) — Referentieaudio voor de stemgeneratie. De audio moet base64-gecodeerd zijn. Alleen ondersteund bij gebruik van het model eleven_ttv_v3.
- `prompt_strength` (double, optional, nullable) — Bepaalt de balans tussen prompt en referentieaudio bij het genereren van stemvoorbeelden. 0 betekent vrijwel geen invloed van de prompt, 1 betekent vrijwel geen invloed van referentieaudio. Alleen ondersteund bij gebruik van het model eleven_ttv_v3.

## Response

### 200

Geslaagde response

- `previews` (list of VoicePreviewResponseModel, required) — De previews van de gegenereerde stemmen.
- `text` (string, required) — De tekst die wordt gebruikt om de stemmen te beluisteren.

## Errors

### 409 Conflict Error

Er is al een generatie voor dit voorbeeld bezig. Probeer de request opnieuw.

- `any`

### 422 Unprocessable Entity Error

Validatiefout

- `detail` (list of ValidationError, optional)

## Types

### VoicePreviewResponseModel

- `audio_base_64` (string, required) — De base64-gecodeerde audio van het voorbeeld.
- `generated_voice_id` (string, required) — De ID van de gegenereerde stem. Gebruik deze om een stem te maken op basis van de preview.
- `media_type` (string, required) — Het mediatype van het voorbeeld.
- `duration_secs` (double, required) — De duur van het voorbeeld in seconden.
- `language` (string, required, nullable) — De taal van het voorbeeld.

### ValidationError

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

### ValidationErrorLocItems

## Examples

**Request**

```json
{
  "voice_description": "A sassy squeaky mouse"
}
```

**Response**

```json
{
  "previews": [
    {
      "audio_base_64": "string",
      "generated_voice_id": "string",
      "media_type": "string",
      "duration_secs": 1.1,
      "language": "string"
    }
  ],
  "text": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/text-to-voice/design"

payload = { "voice_description": "A sassy squeaky mouse" }
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript
const url = 'https://api.elevenlabs.io/v1/text-to-voice/design';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"voice_description":"A sassy squeaky mouse"}'
};

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/text-to-voice/design"

	payload := strings.NewReader("{\n  \"voice_description\": \"A sassy squeaky mouse\"\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/text-to-voice/design")

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  \"voice_description\": \"A sassy squeaky mouse\"\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/text-to-voice/design")
  .header("Content-Type", "application/json")
  .body("{\n  \"voice_description\": \"A sassy squeaky mouse\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/text-to-voice/design', [
  'body' => '{
  "voice_description": "A sassy squeaky mouse"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/text-to-voice/design");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"voice_description\": \"A sassy squeaky mouse\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["voice_description": "A sassy squeaky mouse"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.elevenlabs.io/v1/text-to-voice/design")! 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()
```