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

# टाइमिंग के साथ स्पीच बनाएं

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

ऑडियो-टेक्स्ट सिंक्रोनाइज़ेशन के लिए सटीक कैरेक्टर-स्तर टाइमिंग जानकारी के साथ टेक्स्ट से स्पीच जनरेट करें।

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) — इस्तेमाल की जाने वाली वॉइस ID। सभी उपलब्ध वॉइसेज़ की सूची के लिए आप https://api.elevenlabs.io/v1/voices इस्तेमाल कर सकते हैं।

### Query parameters

- `enable_logging` (boolean, optional, default: true) — जब enable_logging को false सेट किया जाता है, तो अनुरोध के लिए zero retention mode इस्तेमाल होगा। इसका मतलब है कि इस अनुरोध के लिए history सुविधाएं, जिनमें request stitching भी शामिल है, उपलब्ध नहीं होंगी। zero retention mode केवल enterprise ग्राहक इस्तेमाल कर सकते हैं।
- `optimize_streaming_latency` (integer, optional, nullable, deprecated) — आप क्वालिटी में कुछ कमी के बदले लेटेंसी ऑप्टिमाइज़ेशन चालू कर सकते हैं। सबसे कम संभव अंतिम लेटेंसी मॉडल के अनुसार अलग-अलग होती है। संभावित मान: 0 - डिफ़ॉल्ट मोड (कोई लेटेंसी ऑप्टिमाइज़ेशन नहीं) 1 - सामान्य लेटेंसी ऑप्टिमाइज़ेशन (विकल्प 3 से संभव लेटेंसी सुधार का लगभग 50%) 2 - मज़बूत लेटेंसी ऑप्टिमाइज़ेशन (विकल्प 3 से संभव लेटेंसी सुधार का लगभग 75%) 3 - अधिकतम लेटेंसी ऑप्टिमाइज़ेशन 4 - अधिकतम लेटेंसी ऑप्टिमाइज़ेशन, साथ ही और अधिक लेटेंसी बचाने के लिए टेक्स्ट नॉर्मलाइज़र बंद रहता है (सबसे अच्छी लेटेंसी, लेकिन जैसे नंबर और तारीखों का गलत उच्चारण हो सकता है)। डिफ़ॉल्ट रूप से None।
- `output_format` (enum, optional, default: mp3_44100_128) — जनरेट किए गए ऑडियो का output format। codec_sample_rate_bitrate के रूप में फ़ॉर्मैट किया जाता है। इसलिए, 32kbs पर 22.05kHz sample rate वाले mp3 को mp3_22050_32 के रूप में दर्शाया जाता है। 192kbps bitrate वाले MP3 के लिए Creator tier या उससे ऊपर का subscription चाहिए। 44.1kHz sample rate वाले PCM और WAV formats के लिए Pro tier या उससे ऊपर का subscription चाहिए। ध्यान दें कि μ-law format (कभी-कभी mu-law लिखा जाता है, और अक्सर u-law के रूप में अनुमानित) का उपयोग आमतौर पर 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) — वह टेक्स्ट जिसे स्पीच में बदला जाएगा।
- `model_id` (string, optional, default: eleven_multilingual_v2) — इस्तेमाल किए जाने वाले मॉडल का पहचानकर्ता। आप GET /v1/models से इनके बारे में क्वेरी कर सकते हैं। मॉडल में टेक्स्ट टू स्पीच का समर्थन होना चाहिए, जिसे आप can_do_text_to_speech प्रॉपर्टी से जांच सकते हैं।
- `language_code` (string, optional, nullable) — मॉडल और टेक्स्ट नॉर्मलाइज़ेशन के लिए भाषा लागू करने में इस्तेमाल होने वाला भाषा कोड (ISO 639-1)। अगर मॉडल दिए गए भाषा कोड को सपोर्ट नहीं करता, तो उसे अनदेखा कर दिया जाएगा। यह पैरामीटर multilingual_v2 मॉडल के लिए समर्थित नहीं है।
- `voice_settings` (VoiceSettingsResponseModel, optional, nullable) — दी गई वॉइस की सेव की गई सेटिंग्स को ओवरराइड करने वाली वॉइस सेटिंग्स। ये सिर्फ़ दिए गए अनुरोध पर लागू होती हैं।
- `pronunciation_dictionary_locators` (list of PronunciationDictionaryVersionLocatorRequestModel, optional) — टेक्स्ट पर लागू किए जाने वाले उच्चारण शब्दकोश लोकेटर्स (id, version_id) की सूची। इन्हें क्रम से लागू किया जाएगा। हर अनुरोध में अधिकतम 3 लोकेटर्स हो सकते हैं।
- `seed` (integer, optional, nullable) — निर्दिष्ट होने पर, हमारा सिस्टम नियतात्मक रूप से सैंपल करने का सर्वोत्तम प्रयास करेगा, ताकि एक ही seed और पैरामीटर्स वाली बार-बार की गई रिक्वेस्ट से एक ही परिणाम मिले। नियतात्मकता की गारंटी नहीं है। यह 0 से 4294967295 के बीच एक पूर्णांक होना चाहिए।
- `previous_text` (string, optional, nullable) — वह टेक्स्ट जो मौजूदा अनुरोध के टेक्स्ट से पहले आया था। कई जनरेशन को जोड़ते समय स्पीच की निरंतरता बेहतर करने या मौजूदा जनरेशन में स्पीच की निरंतरता को प्रभावित करने के लिए इस्तेमाल किया जा सकता है।
- `next_text` (string, optional, nullable) — वह टेक्स्ट जो मौजूदा अनुरोध के टेक्स्ट के बाद आता है। कई जनरेशन को जोड़ते समय स्पीच की निरंतरता बेहतर करने या मौजूदा जनरेशन में स्पीच की निरंतरता को प्रभावित करने के लिए इस्तेमाल किया जा सकता है।
- `previous_request_ids` (list of string, optional) — इस जनरेशन से पहले जनरेट किए गए सैंपल के request_id की सूची। किसी बड़े कार्य को कई अनुरोधों में बाँटते समय स्पीच की निरंतरता बेहतर करने के लिए इसका उपयोग किया जा सकता है। सभी जनरेशन्स में एक ही मॉडल इस्तेमाल करने पर परिणाम सबसे अच्छे होंगे। previous_text और previous_request_ids दोनों भेजने पर previous_text को अनदेखा किया जाएगा। अधिकतम 3 request_ids भेजे जा सकते हैं।
- `next_request_ids` (list of string, optional) — इस जनरेशन के बाद आने वाले सैंपल के request_id की सूची। ऑडियो क्वालिटी संबंधी समस्या वाले सैंपल को फिर से जनरेट करते समय स्पीच की निरंतरता बनाए रखने के लिए next_request_ids खास तौर पर उपयोगी हैं। उदाहरण के लिए, अगर आपने 3 स्पीच क्लिप जनरेट किए हैं और क्लिप 2 को बेहतर बनाना चाहते हैं, तो क्लिप 3 का request id next_request_id के रूप में (और क्लिप 1 का previous_request_id के रूप में) देने से संयुक्त स्पीच में प्राकृतिक प्रवाह बनाए रखने में मदद मिलेगी। सभी जनरेशन्स में एक ही मॉडल इस्तेमाल करने पर परिणाम सबसे अच्छे होंगे। next_text और next_request_ids दोनों भेजने पर next_text को अनदेखा किया जाएगा। अधिकतम 3 request_ids भेजे जा सकते हैं।
- `use_pvc_as_ivc` (boolean, optional, default: false) — प्रोफेशनल वॉइस का IVC वर्शन इस्तेमाल करना है या नहीं। इससे अभिव्यक्तिशीलता बेहतर हो सकती है और लेटेंसी कम हो सकती है।
- `apply_text_normalization` (enum, optional, default: auto) — यह पैरामीटर तीन मोड के साथ टेक्स्ट नॉर्मलाइज़ेशन नियंत्रित करता है: 'auto', 'on' और 'off'। 'auto' पर सेट होने पर, सिस्टम अपने-आप तय करेगा कि टेक्स्ट नॉर्मलाइज़ेशन लागू करना है या नहीं, जैसे संख्याओं को शब्दों में लिखना। 'on' के साथ टेक्स्ट नॉर्मलाइज़ेशन हमेशा लागू होगा, जबकि 'off' के साथ इसे छोड़ दिया जाएगा।
  - Allowed values: `auto`, `on`, `off`
- `apply_language_text_normalization` (boolean, optional, default: false) — यह पैरामीटर भाषा टेक्स्ट नॉर्मलाइज़ेशन नियंत्रित करता है। इससे कुछ समर्थित भाषाओं में टेक्स्ट के सही उच्चारण में मदद मिलती है। चेतावनी: यह पैरामीटर अनुरोध की लेटेंसी को काफी बढ़ा सकता है। फ़िलहाल यह केवल जापानी के लिए समर्थित है।
- `audio_effects` (EffectsSpec-Input, optional, nullable) — जनरेट किए गए ऑडियो पर लागू किए गए ऑडियो इफेक्ट्स। अज्ञात ID पर 404 मिलता है, जिसमें `param` फ़ील्ड का नाम बताता है। रीवर्ब (`environment_id`, जिसमें `send_level` 0 से अधिक हो) और गैर-शून्य `pan` स्टीरियो ऑडियो बनाते हैं और `ulaw_*`, `alaw_*` और `pcm_*` आउटपुट फ़ॉर्मैट के लिए 400 के साथ अस्वीकार कर दिए जाते हैं। इफेक्ट्स से अनुरोध की लागत नहीं बदलती।

## Response

### 200

सफल रिस्पॉन्स

- `audio_base64` (string, required) — Base64-एन्कोड किया गया ऑडियो डेटा
- `alignment` (CharacterAlignmentResponseModel, optional, nullable) — मूल टेक्स्ट के हर वर्ण की टाइमस्टैम्प जानकारी
- `normalized_alignment` (CharacterAlignmentResponseModel, optional, nullable) — सामान्यीकृत टेक्स्ट के हर वर्ण की टाइमस्टैम्प जानकारी

## Errors

### 422 Unprocessable Entity Error

वैलिडेशन एरर

- `detail` (list of ValidationError, optional)

## Types

### VoiceSettingsResponseModel

- `stability` (double, optional, nullable, default: 0.5) — यह वॉइस की स्थिरता और हर जनरेशन के बीच रैंडमनेस तय करता है। कम मान वॉइस में भावनाओं की व्यापक रेंज लाते हैं। ज़्यादा मान से सीमित भावनाओं वाली एकरस वॉइस बन सकती है।
- `use_speaker_boost` (boolean, optional, nullable, default: true) — यह सेटिंग मूल स्पीकर से समानता बढ़ाती है। इस सेटिंग के लिए थोड़ा ज़्यादा कंप्यूटेशनल लोड चाहिए, जिससे लेटेंसी बढ़ती है।
- `similarity_boost` (double, optional, nullable, default: 0.75) — यह तय करता है कि मूल वॉइस को दोहराने की कोशिश करते समय AI को उसका कितना करीब से पालन करना चाहिए।
- `style` (double, optional, nullable, default: 0) — यह वॉइस के स्टाइल एक्सैजेरेशन को तय करता है। यह सेटिंग मूल स्पीकर के स्टाइल को बढ़ाने की कोशिश करती है। इसमें अतिरिक्त कंप्यूटेशनल संसाधन लगते हैं और 0 के अलावा कोई मान सेट करने पर लेटेंसी बढ़ सकती है।
- `speed` (double, optional, nullable, default: 1) — वॉइस की गति समायोजित करता है। 1.0 डिफ़ॉल्ट गति है, 1.0 से कम मान स्पीच को धीमा करते हैं और 1.0 से अधिक मान उसे तेज़ करते हैं।

### PronunciationDictionaryVersionLocatorRequestModel

- `pronunciation_dictionary_id` (string, required) — उच्चारण डिक्शनरी की ID।
- `version_id` (string, optional, nullable) — उच्चारण डिक्शनरी के वर्ज़न की ID। न देने पर नवीनतम वर्ज़न का उपयोग किया जाएगा।

### EffectsSpec-Input

जनरेट की गई स्पीच पर लागू ऑडियो इफेक्ट्स: फ़िल्टर प्रीसेट, महसूस होने वाली दूरी, रीवर्ब environment, बैकग्राउंड नॉइज़ बेड और स्टीरियो पैनिंग। बिना प्रोसेस किया हुआ ऑडियो पाने के लिए हर फ़ील्ड को उसके डिफ़ॉल्ट मान पर छोड़ दें।

- `filter_preset_id` (string, optional, nullable) — वॉइस का टोन बदलने वाले फ़िल्टर प्रीसेट की ID, जैसे `phone` या `old_radio`। मान्य IDs की सूची `GET /v1/audio-effects/catalog` से प्राप्त करें।
- `distance` (double, optional, default: 0) — स्पीकर माइक्रोफ़ोन से कितना दूर सुनाई देता है: 0 (पास, अपरिवर्तित) से 1 (दूर) तक। ज़्यादा मान कम और ज़्यादा फ़्रीक्वेंसी को घटाते हैं और environment सेट होने पर संतुलन को ड्राई वॉइस से रीवर्ब की ओर ले जाते हैं।
- `environment_id` (string, optional, nullable) — वॉइस को किसी स्थान में रखने वाले रीवर्ब environment की ID, जैसे `small_room` या `hall`। मान्य IDs की सूची `GET /v1/audio-effects/catalog` से प्राप्त करें। रीवर्ब स्टीरियो में रेंडर होता है और स्पीच खत्म होने के बाद कई सेकंड तक टेल जोड़ता है।
- `background_noise_id` (string, optional, nullable) — वॉइस के नीचे लूप होने वाले बैकग्राउंड नॉइज़ बेड की ID, जैसे `cafe` या `keyboard`। मान्य IDs की सूची `GET /v1/audio-effects/catalog` से प्राप्त करें।
- `send_level` (double, optional, default: 1) — वॉइस का कितना हिस्सा रीवर्ब में भेजा जाए: 0 (कोई नहीं) से 1 (पूरा) तक। यह केवल `environment_id` सेट होने पर लागू होता है; 0 रीवर्ब बंद कर देता है।
- `pan` (double, optional, default: 0) — वॉइस की स्टीरियो स्थिति, -1 (पूरी तरह बाएं) से 0 (केंद्र) होते हुए 1 (पूरी तरह दाएं) तक। केवल वॉइस को पैन किया जाता है; रीवर्ब और बैकग्राउंड नॉइज़ केंद्र में रहते हैं।

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