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

# Skapa tal med tidsangivelser

POST https://api.elevenlabs.io/v1/text-to-speech/{voice_id}/with-timestamps
Content-Type: application/json

Generera tal från text med exakt tidsinformation på teckennivå för synkronisering mellan ljud och text.

Reference: https://elevenlabs.io/docs/api-reference/text-to-speech/convert-with-timestamps

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

- `voice_id` (string, required) — Röst-ID som ska användas. Du kan använda https://api.elevenlabs.io/v1/voices för att lista alla tillgängliga röster.

### Query parameters

- `enable_logging` (boolean, optional, default: true) — När enable_logging är satt till false används nollkvarhållningsläge för begäran. Det innebär att historikfunktioner, inklusive sammanfogning av begäranden, inte är tillgängliga för denna begäran. Nollkvarhållningsläge får endast användas av företagskunder.
- `optimize_streaming_latency` (integer, optional, nullable, deprecated) — Du kan aktivera latensoptimeringar på bekostnad av viss kvalitet. Bästa möjliga slutliga latens varierar beroende på modell. Möjliga värden: 0 - standardläge (inga latensoptimeringar) 1 - normala latensoptimeringar (cirka 50 % av den möjliga latensförbättringen med alternativ 3) 2 - kraftiga latensoptimeringar (cirka 75 % av den möjliga latensförbättringen med alternativ 3) 3 - maximala latensoptimeringar 4 - maximala latensoptimeringar, men även med textnormaliseraren avstängd för ännu större latensbesparingar (bästa latens, men kan uttala till exempel siffror och datum fel). Standardvärdet är None.
- `output_format` (enum, optional, default: mp3_44100_128) — 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 and WAV formats 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: `alaw_8000`, `mp3_22050_32`, `mp3_24000_48`, `mp3_44100_128`, `mp3_44100_192`, `mp3_44100_32`, `mp3_44100_64`, `mp3_44100_96`, `opus_48000_128`, `opus_48000_192`, `opus_48000_32`, `opus_48000_64`, `opus_48000_96`, `pcm_16000`, `pcm_22050`, `pcm_24000`, `pcm_32000`, `pcm_44100`, `pcm_48000`, `pcm_8000`, `ulaw_8000`, `wav_16000`, `wav_22050`, `wav_24000`, `wav_32000`, `wav_44100`, `wav_48000`, `wav_8000`

### Body (application/json)

This endpoint expects a Body_text_to_speech_full_with_timestamps.

- `text` (string, required) — Texten som ska konverteras till tal.
- `model_id` (string, optional, default: eleven_multilingual_v2) — Identifierare för modellen som ska användas. Du kan fråga efter modellerna med GET /v1/models. Modellen måste ha stöd för Text to Speech, vilket du kan kontrollera med egenskapen can_do_text_to_speech.
- `language_code` (string, optional, nullable) — Språkkod (ISO 639-1) som används för att tillämpa ett språk för modellen och textnormalisering. Om modellen inte stöder den angivna språkkoden ignoreras den. Parametern stöds inte för multilingual_v2-modeller.
- `voice_settings` (VoiceSettingsResponseModel, optional, nullable) — Röstinställningar som åsidosätter lagrade inställningar för den angivna rösten. De tillämpas endast på den angivna begäran.
- `pronunciation_dictionary_locators` (list of PronunciationDictionaryVersionLocatorRequestModel, optional) — En lista med pekare till uttalslexikon (id, version_id) som ska tillämpas på texten. De tillämpas i ordning. Du kan ha upp till 3 pekare per begäran
- `seed` (integer, optional, nullable) — Om angivet försöker systemet sampla deterministiskt, så att upprepade förfrågningar med samma seed och parametrar bör ge samma resultat. Determinism garanteras inte. Måste vara ett heltal mellan 0 och 4294967295.
- `previous_text` (string, optional, nullable) — Texten som kom före texten i den aktuella begäran. Kan användas för att förbättra talets kontinuitet när flera genereringar sammanfogas eller för att påverka talets kontinuitet i den aktuella genereringen.
- `next_text` (string, optional, nullable) — Texten som kommer efter texten i den aktuella begäran. Kan användas för att förbättra talets kontinuitet när flera genereringar sammanfogas eller för att påverka talets kontinuitet i den aktuella genereringen.
- `previous_request_ids` (list of string, optional) — En lista med request_id för proverna som genererades före den här genereringen. Kan användas för att förbättra talets kontinuitet när en stor uppgift delas upp i flera begäranden. Resultatet blir bäst när samma modell används för alla genereringar. Om både previous_text och previous_request_ids skickas ignoreras previous_text. Högst 3 request_ids kan skickas.
- `next_request_ids` (list of string, optional) — A list of request_id of the samples that come after this generation. next_request_ids is especially useful for maintaining the speech's continuity when regenerating a sample that has had some audio quality issues. For example, if you have generated 3 speech clips, and you want to improve clip 2, passing the request id of clip 3 as a next_request_id (and that of clip 1 as a previous_request_id) will help maintain natural flow in the combined speech. The results will be best when the same model is used across the generations. In case both next_text and next_request_ids is send, next_text will be ignored. A maximum of 3 request_ids can be send.
- `use_pvc_as_ivc` (boolean, optional, default: false) — Om IVC-versionen av en professionell röst ska användas. Det kan förbättra uttrycksfullheten och minska latensen.
- `apply_text_normalization` (enum, optional, default: auto) — Den här parametern styr textnormalisering med tre lägen: 'auto', 'on' och 'off'. När den är inställd på 'auto' avgör systemet automatiskt om textnormalisering ska användas (t.ex. att skriva ut siffror med bokstäver). Med 'on' används textnormalisering alltid, medan den hoppas över med 'off'.
  - Allowed values: `auto`, `on`, `off`
- `apply_language_text_normalization` (boolean, optional, default: false) — Den här parametern styr språklig textnormalisering. Den hjälper till med korrekt uttal av text på vissa språk som stöds. VARNING: Den här parametern kan öka fördröjningen för begäran avsevärt. Stöds för närvarande endast för japanska.

## Response

### 200

Lyckat svar

- `audio_base64` (string, required) — Base64-kodade ljuddata
- `alignment` (CharacterAlignmentResponseModel, optional, nullable) — Tidsstämpelinformation för varje tecken i originaltexten
- `normalized_alignment` (CharacterAlignmentResponseModel, optional, nullable) — Tidsstämpelinformation för varje tecken i den normaliserade texten

## Errors

### 422 Unprocessable Entity Error

Valideringsfel

- `detail` (list of ValidationError, optional)

## Types

### VoiceSettingsResponseModel

- `stability` (double, optional, nullable, default: 0.5) — Avgör hur stabil rösten är och slumpmässigheten mellan varje generering. Lägre värden ger rösten ett bredare känslomässigt register. Högre värden kan ge en monoton röst med begränsade känslouttryck.
- `use_speaker_boost` (boolean, optional, nullable, default: true) — Den här inställningen ökar likheten med den ursprungliga talaren. Inställningen kräver något högre beräkningskapacitet, vilket i sin tur ökar fördröjningen.
- `similarity_boost` (double, optional, nullable, default: 0.75) — Avgör hur nära AI:n ska följa originalrösten när den försöker återskapa den.
- `style` (double, optional, nullable, default: 0) — Avgör hur mycket röstens stil ska överdrivas. Den här inställningen försöker förstärka originaltalarens stil. Den använder ytterligare beräkningsresurser och kan öka latensen om den sätts till något annat än 0.
- `speed` (double, optional, nullable, default: 1) — Justerar röstens hastighet. Värdet 1.0 är standardhastigheten. Värden under 1.0 gör talet långsammare och värden över 1.0 gör det snabbare.

### PronunciationDictionaryVersionLocatorRequestModel

- `pronunciation_dictionary_id` (string, required) — ID:t för uttalsordlistan.
- `version_id` (string, optional, nullable) — ID:t för versionen av uttalsordlistan. Om det inte anges används den senaste versionen.

### CharacterAlignmentResponseModel

- `characters` (list of string, required)
- `character_start_times_seconds` (list of double, required)
- `character_end_times_seconds` (list of double, required)

### ValidationError

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

### ValidationErrorLocItems

## Examples

**Request**

```json
{
  "text": "This is a test for the API of ElevenLabs."
}
```

**Response**

```json
{
  "audio_base64": "base64_encoded_audio_string",
  "alignment": {
    "characters": [
      "H",
      "e",
      "l",
      "l",
      "o"
    ],
    "character_start_times_seconds": [
      0,
      0.1,
      0.2,
      0.3,
      0.4
    ],
    "character_end_times_seconds": [
      0.1,
      0.2,
      0.3,
      0.4,
      0.5
    ]
  },
  "normalized_alignment": {
    "characters": [
      "H",
      "e",
      "l",
      "l",
      "o"
    ],
    "character_start_times_seconds": [
      0,
      0.1,
      0.2,
      0.3,
      0.4
    ],
    "character_end_times_seconds": [
      0.1,
      0.2,
      0.3,
      0.4,
      0.5
    ]
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.elevenlabs.io/v1/text-to-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps"

payload = { "text": "This is a test for the API of ElevenLabs." }
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-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"text":"This is a test for the API of ElevenLabs."}'
};

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-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps"

	payload := strings.NewReader("{\n  \"text\": \"This is a test for the API of ElevenLabs.\"\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-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps")

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  \"text\": \"This is a test for the API of ElevenLabs.\"\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-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps")
  .header("Content-Type", "application/json")
  .body("{\n  \"text\": \"This is a test for the API of ElevenLabs.\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.elevenlabs.io/v1/text-to-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps', [
  'body' => '{
  "text": "This is a test for the API of ElevenLabs."
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.elevenlabs.io/v1/text-to-speech/21m00Tcm4TlvDq8ikWAM/with-timestamps");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"text\": \"This is a test for the API of ElevenLabs.\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["text": "This is a test for the API of ElevenLabs."] as [String : Any]

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

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