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

# Criar uma voz.

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

Crie uma voz por meio de um prompt. Este método retorna uma lista de prévias de voz. Cada prévia tem um generated_voice_id e uma amostra da voz como áudio mp3 codificado em base64. Para criar uma voz, use o generated_voice_id da prévia escolhida com o endpoint /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) — Descrição a ser usada para a voz criada.
- `model_id` (enum, optional, default: eleven_multilingual_ttv_v2) — Modelo a ser usado para a geração de voz. Valores possíveis: eleven_multilingual_ttv_v2, eleven_ttv_v3.
  - Allowed values: `eleven_multilingual_ttv_v2`, `eleven_ttv_v3`
- `text` (string, optional, nullable) — Texto a gerar; o comprimento deve estar entre 100 e 1000.
- `auto_generate_text` (boolean, optional, default: false) — Indica se deve gerar automaticamente um texto adequado para a descrição da voz.
- `loudness` (double, optional, default: 0.5) — Controla o nível de volume da voz gerada. -1 é o mais baixo, 1 é o mais alto e 0 corresponde a aproximadamente -24 LUFS.
- `seed` (integer, optional, nullable) — Número aleatório que controla a geração de voz. A mesma seed com as mesmas entradas produz a mesma voz.
- `guidance_scale` (double, optional, default: 5) — Controla o quanto a IA segue o prompt de perto. Valores menores dão à IA mais liberdade criativa, enquanto valores maiores a fazem seguir mais o prompt. Valores altos podem fazer a voz soar artificial ou robótica. Recomendamos usar prompts mais longos e detalhados com uma Guidance Scale menor.
- `stream_previews` (boolean, optional, default: false) — Determina se as prévias do Text to Voice devem ser incluídas na resposta. Se for true, apenas os IDs gerados serão retornados e poderão ser transmitidos pelo endpoint /v1/text-to-voice/:generated_voice_id/stream.
- `should_enhance` (boolean, optional, default: false) — Indica se deve aprimorar a descrição da voz usando IA para adicionar mais detalhes e melhorar a qualidade da geração de voz. Quando ativado, o sistema expandirá automaticamente prompts simples em descrições de voz mais detalhadas. O padrão é False.
- `remixing_session_id` (string, optional, nullable) — O ID da sessão de remixagem.
- `remixing_session_iteration_id` (string, optional, nullable) — O ID da iteração da sessão de remixagem à qual estas gerações devem ser anexadas. Se não for fornecido, uma nova iteração será criada.
- `quality` (double, optional, nullable) — Uma qualidade mais alta resulta em uma voz melhor, mas com menos variedade.
- `reference_audio_base64` (string, optional, nullable) — Áudio de referência a ser usado para a geração de voz. O áudio deve ser codificado em base64. Compatível apenas com o modelo eleven_ttv_v3.
- `prompt_strength` (double, optional, nullable) — Controla o equilíbrio entre o prompt e o áudio de referência ao gerar amostras de voz. 0 significa quase nenhuma influência do prompt; 1 significa quase nenhuma influência do áudio de referência. Compatível apenas com o modelo eleven_ttv_v3.

## Response

### 200

Resposta bem-sucedida

- `previews` (list of VoicePreviewResponseModel, required) — As prévias das vozes geradas.
- `text` (string, required) — O texto usado para visualizar as vozes.

## Errors

### 409 Conflict Error

Já há uma geração desta prévia em andamento. Tente novamente.

- `any`

### 422 Unprocessable Entity Error

Erro de validação

- `detail` (list of ValidationError, optional)

## Types

### VoicePreviewResponseModel

- `audio_base_64` (string, required) — O áudio da prévia codificado em base64.
- `generated_voice_id` (string, required) — O ID da voz gerada. Use-o para criar uma voz a partir da prévia.
- `media_type` (string, required) — O tipo de mídia da prévia.
- `duration_secs` (double, required) — A duração da prévia em segundos.
- `language` (string, required, nullable) — O idioma da prévia.

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