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

# Stimme gestalten.

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

Erstellen Sie eine Stimme über einen Prompt. Diese Methode gibt eine Liste von Stimmvorschauen zurück. Jede Vorschau enthält eine generated_voice_id und ein Stimmbeispiel als base64-kodiertes MP3-Audio. Um eine Stimme zu erstellen, verwenden Sie die generated_voice_id der gewünschten Vorschau mit dem Endpunkt /v1/text-to-voice.

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) — Beschreibung für die erstellte Stimme.
- `model_id` (enum, optional, default: eleven_multilingual_ttv_v2) — Modell für die Stimmgenerierung. Mögliche Werte: eleven_multilingual_ttv_v2, eleven_ttv_v3.
  - Allowed values: `eleven_multilingual_ttv_v2`, `eleven_ttv_v3`
- `text` (string, optional, nullable) — Zu generierender Text; die Textlänge muss zwischen 100 und 1000 liegen.
- `auto_generate_text` (boolean, optional, default: false) — Ob automatisch ein für die Stimmbeschreibung geeigneter Text erstellt werden soll.
- `loudness` (double, optional, default: 0.5) — Steuert die Lautstärke der generierten Stimme. -1 ist am leisesten, 1 am lautesten, 0 entspricht etwa -24 LUFS.
- `seed` (integer, optional, nullable) — Zufallszahl zur Steuerung der Stimmgenerierung. Derselbe Seed mit denselben Eingaben erzeugt dieselbe Stimme.
- `guidance_scale` (double, optional, default: 5) — Steuert, wie genau die KI dem Prompt folgt. Niedrigere Werte geben der KI mehr kreative Freiheit, höhere Werte zwingen sie, sich stärker an den Prompt zu halten. Hohe Werte können die Stimme künstlich oder roboterhaft klingen lassen. Bei niedrigerer Guidance Scale empfehlen wir längere, detailliertere Prompts.
- `stream_previews` (boolean, optional, default: false) — Legt fest, ob die Text-to-Voice-Vorschauen in die Antwort aufgenommen werden sollen. Bei true werden nur die generierten IDs zurückgegeben, die dann über den Endpunkt /v1/text-to-voice/:generated_voice_id/stream gestreamt werden können.
- `should_enhance` (boolean, optional, default: false) — Ob die Stimmbeschreibung mithilfe von KI erweitert werden soll, um mehr Details hinzuzufügen und die Qualität der Stimmgenerierung zu verbessern. Wenn aktiviert, erweitert das System einfache Prompts automatisch zu detaillierteren Stimmbeschreibungen. Standardmäßig False.
- `remixing_session_id` (string, optional, nullable) — Die ID der Remixing-Sitzung.
- `remixing_session_iteration_id` (string, optional, nullable) — Die ID der Iteration der Remixing-Sitzung, der diese Generierungen zugeordnet werden sollen. Wenn nicht angegeben, wird eine neue Iteration erstellt.
- `quality` (double, optional, nullable) — Höhere Qualität führt zu besserer Sprachausgabe, aber weniger Vielfalt.
- `reference_audio_base64` (string, optional, nullable) — Referenzaudio für die Stimmgenerierung. Das Audio muss base64-codiert sein. Nur bei Verwendung des Modells eleven_ttv_v3 unterstützt.
- `prompt_strength` (double, optional, nullable) — Steuert das Verhältnis zwischen Prompt und Referenz-Audio bei der Generierung von Stimmproben. 0 bedeutet fast keinen Prompt-Einfluss, 1 bedeutet fast keinen Einfluss des Referenz-Audios. Wird nur vom Modell eleven_ttv_v3 unterstützt.

## Response

### 200

Erfolgreiche Antwort

- `previews` (list of VoicePreviewResponseModel, required) — Die Vorschauen der generierten Stimmen.
- `text` (string, required) — Der für die Stimmvorschau verwendete Text.

## Errors

### 409 Conflict Error

Eine Generierung für diese Vorschau läuft bereits. Wiederholen Sie die Anfrage.

- `any`

### 422 Unprocessable Entity Error

Validierungsfehler

- `detail` (list of ValidationError, optional)

## Types

### VoicePreviewResponseModel

- `audio_base_64` (string, required) — Das Base64-kodierte Audio der Vorschau.
- `generated_voice_id` (string, required) — Die ID der generierten Stimme. Verwenden Sie sie, um aus der Vorschau eine Stimme zu erstellen.
- `media_type` (string, required) — Der Medientyp der Vorschau.
- `duration_secs` (double, required) — Die Dauer der Vorschau in Sekunden.
- `language` (string, required, nullable) — Die Sprache der Vorschau.

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