> 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-voice
Content-Type: application/json

पहले जनरेट किए गए वॉइस प्रीव्यू से वॉइस बनाएं। POST /v1/text-to-voice/design या POST /v1/text-to-voice/:voice_id/remix का इस्तेमाल करके generated_voice_id फ़ेच करने के बाद इस एंडपॉइंट को कॉल करें।

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

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

### Body (application/json)

This endpoint expects a Body_Create_a_new_voice_from_voice_preview_v1_text_to_voice_post.

- `voice_name` (string, required) — बनाई गई वॉइस के लिए इस्तेमाल किया जाने वाला नाम।
- `voice_description` (string, required) — बनाई गई वॉइस के लिए इस्तेमाल किया जाने वाला विवरण।
- `generated_voice_id` (string, required) — बनाने के लिए generated_voice_id; इसे POST /v1/text-to-voice/design, POST /v1/text-to-voice/:voice_id/remix या प्रीव्यू जनरेट करते समय रिस्पॉन्स हेडर से प्राप्त करें।
- `labels` (map from string to string, optional, nullable) — बनाई गई वॉइस में जोड़ने के लिए वैकल्पिक metadata। डिफ़ॉल्ट रूप से None।
- `played_not_selected_voice_ids` (list of string, optional, nullable) — उन वॉइस ID की सूची जिन्हें यूज़र ने चलाया, लेकिन चुना नहीं। RLHF के लिए इस्तेमाल होती है।

## Response

### 200

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

- `voice_id` (string, required) — वॉइस का ID।
- `name` (string, optional) — वॉइस का नाम।
- `samples` (list of SampleResponseModel, optional, nullable) — वॉइस से जुड़े सैंपल की सूची।
- `category` (enum, optional) — वॉइस की कैटेगरी।
  - Allowed values: `generated`, `cloned`, `premade`, `professional`, `famous`, `high_quality`
- `fine_tuning` (FineTuningResponseModel, optional, nullable) — वॉइस के लिए फ़ाइन-ट्यूनिंग जानकारी।
- `labels` (map from string to string, optional) — वॉइस से जुड़े लेबल।
- `description` (string, optional, nullable) — वॉइस का विवरण।
- `preview_url` (string, optional, nullable) — वॉइस का प्रीव्यू URL।
- `available_for_tiers` (list of string, optional) — वे टियर जिनके लिए वॉइस उपलब्ध है।
- `settings` (VoiceSettingsResponseModel, optional, nullable) — वॉइस की सेटिंग्स।
- `sharing` (VoiceSharingResponseModel, optional, nullable) — वॉइस की शेयरिंग जानकारी।
- `high_quality_base_model_ids` (list of string, optional) — उच्च-गुणवत्ता वाली वॉइसेज़ के बेस मॉडल IDs।
- `verified_languages` (list of VerifiedVoiceLanguageResponseModel, optional, nullable) — वॉइस की सत्यापित भाषाएं।
- `collection_ids` (list of string, optional, nullable) — वे कलेक्शन ID जिनसे यह वॉइस जुड़ी है।
- `safety_control` (enum, optional, nullable) — वॉइस के सुरक्षा नियंत्रण।
  - Allowed values: `NONE`, `BAN`, `CAPTCHA`, `ENTERPRISE_BAN`, `ENTERPRISE_CAPTCHA`
- `voice_verification` (VoiceVerificationResponseModel, optional, nullable) — वॉइस का वॉइस वेरिफ़िकेशन।
- `permission_on_resource` (string, optional, nullable) — वॉइस के रिसोर्स पर अनुमति।
- `is_owner` (boolean, optional, nullable) — क्या वॉइस यूज़र की है।
- `is_legacy` (boolean, optional, default: false) — क्या वॉइस लेगसी है।
- `is_mixed` (boolean, optional, default: false) — क्या वॉइस मिक्स की गई है।
- `favorited_at_unix` (integer, optional, nullable) — वॉइस को पसंदीदा के रूप में चिह्नित करने का Unix टाइमस्टैम्प।
- `created_at_unix` (integer, optional, nullable) — Unix समय में वॉइस बनाने का समय।
- `is_bookmarked` (boolean, optional, nullable) — क्या मौजूदा यूज़र ने वॉइस को बुकमार्क किया है। यह केवल कम्युनिटी (लाइब्रेरी से कॉपी की गई) वॉइस के लिए लागू है।
- `recording_quality` (enum, optional, nullable) — रिव्यू पाइपलाइन द्वारा निर्धारित वॉइस की रिकॉर्डिंग क्वालिटी।
  - Allowed values: `studio`, `good`, `ok`, `poor`, `bad`
- `labelling_status` (enum, optional, nullable) — वॉइस का रिव्यू पाइपलाइन स्टेटस।
  - Allowed values: `in_review`, `review_complete`
- `recording_quality_reason` (string, optional, nullable) — रिव्यू पाइपलाइन द्वारा निर्धारित रिकॉर्डिंग क्वालिटी आकलन का कारण।

## Errors

### 409 Conflict Error

इस प्रीव्यू के लिए जनरेशन पहले से जारी है। अनुरोध को फिर से आज़माएं।

- `any`

### 422 Unprocessable Entity Error

वैलिडेशन एरर

- `detail` (list of ValidationError, optional)

## Types

### SampleResponseModel

- `sample_id` (string, optional) — सैंपल की ID।
- `file_name` (string, optional) — सैंपल फ़ाइल का नाम।
- `mime_type` (string, optional) — सैंपल फ़ाइल का MIME प्रकार।
- `size_bytes` (integer, optional) — सैंपल फ़ाइल का आकार बाइट्स में।
- `hash` (string, optional) — सैंपल फ़ाइल का हैश।
- `duration_secs` (double, optional, nullable)
- `remove_background_noise` (boolean, optional, nullable)
- `has_isolated_audio` (boolean, optional, nullable)
- `has_isolated_audio_preview` (boolean, optional, nullable)
- `speaker_separation` (SpeakerSeparationResponseModel, optional, nullable)
- `trim_start` (integer, optional, nullable)
- `trim_end` (integer, optional, nullable)

### FineTuningResponseModel

- `is_allowed_to_fine_tune` (boolean, optional) — क्या यूज़र को वॉइस फाइन-ट्यून करने की अनुमति है।
- `state` (map from string to enum, optional) — हर मॉडल के Finetune प्रोसेस की स्थिति।
  - Allowed values: `not_started`, `queued`, `fine_tuning`, `fine_tuned`, `failed`, `delayed`
- `verification_failures` (list of string, optional) — फाइन-ट्यूनिंग प्रक्रिया में सत्यापन विफलताओं की सूची।
- `verification_attempts_count` (integer, optional) — Finetune प्रक्रिया में सत्यापन प्रयासों की संख्या।
- `manual_verification_requested` (boolean, optional) — क्या fine-tuning प्रक्रिया के लिए मैन्युअल सत्यापन का अनुरोध किया गया था।
- `language` (string, optional, nullable) — फाइन-ट्यूनिंग प्रक्रिया की भाषा।
- `progress` (map from string to double, optional, nullable) — Finetune प्रक्रिया की प्रगति।
- `message` (map from string to string, optional, nullable) — फाइन-ट्यूनिंग प्रक्रिया का संदेश।
- `dataset_duration_seconds` (double, optional, nullable) — डेटासेट की अवधि सेकंड में।
- `verification_attempts` (list of VerificationAttemptResponseModel, optional, nullable) — सत्यापन प्रयासों की संख्या।
- `slice_ids` (list of string, optional, nullable) — स्लाइस ID की सूची।
- `manual_verification` (ManualVerificationResponseModel, optional, nullable) — फाइन-ट्यूनिंग प्रक्रिया का मैन्युअल वेरिफ़िकेशन।
- `max_verification_attempts` (integer, optional, nullable) — वेरिफ़िकेशन प्रयासों की अधिकतम संख्या।
- `next_max_verification_attempts_reset_unix_ms` (integer, optional, nullable) — अधिकतम सत्यापन प्रयासों के अगले रीसेट का समय, Unix मिलीसेकंड में।
- `finetuning_state` (any, optional)

### 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 से अधिक मान उसे तेज़ करते हैं।

### VoiceSharingResponseModel

- `status` (enum, optional) — वॉइस शेयरिंग का स्टेटस।
  - Allowed values: `enabled`, `disabled`, `copied`, `copied_disabled`
- `history_item_sample_id` (string, optional, nullable) — हिस्ट्री आइटम की सैंपल ID।
- `date_unix` (integer, optional) — Unix समय में वॉइस शेयर किए जाने की तारीख।
- `whitelisted_emails` (list of string, optional) — अनुमति प्राप्त ईमेल की सूची।
- `public_owner_id` (string, optional) — पब्लिक ओनर की ID।
- `original_voice_id` (string, optional) — मूल वॉइस की ID।
- `financial_rewards_enabled` (boolean, optional) — क्या वित्तीय पुरस्कार सक्षम हैं।
- `free_users_allowed` (boolean, optional) — क्या मुफ़्त यूज़र को अनुमति है।
- `live_moderation_enabled` (boolean, optional) — क्या live moderation सक्षम है।
- `rate` (double, optional, nullable) — वॉइस शेयरिंग की दर।
- `fiat_rate` (double, optional, nullable) — प्रति 1000 क्रेडिट्स वॉइस शेयरिंग की USD में दर।
- `notice_period` (integer, optional) — वॉइस शेयरिंग की नोटिस अवधि।
- `disable_at_unix` (integer, optional, nullable) — Unix समय में वॉइस शेयर किए जाने की तारीख।
- `voice_mixing_allowed` (boolean, optional) — वॉइस मिक्सिंग की अनुमति है या नहीं।
- `featured` (boolean, optional) — क्या वॉइस फ़ीचर्ड है।
- `category` (enum, optional) — वॉइस की कैटेगरी।
  - Allowed values: `generated`, `cloned`, `premade`, `professional`, `famous`, `high_quality`
- `reader_app_enabled` (boolean, optional, nullable) — क्या रीडर ऐप सक्षम है।
- `image_url` (string, optional, nullable) — वॉइस का इमेज URL।
- `ban_reason` (string, optional, nullable) — वॉइस पर प्रतिबंध लगाने का कारण।
- `liked_by_count` (integer, optional) — वॉइस पर लाइक्स की संख्या।
- `cloned_by_count` (integer, optional) — वॉइस के क्लोन्स की संख्या।
- `name` (string, optional) — वॉइस का नाम।
- `description` (string, optional, nullable) — वॉइस का विवरण।
- `labels` (map from string to string, optional) — वॉइस के लेबल।
- `review_status` (enum, optional) — वॉइस का रिव्यू स्टेटस।
  - Allowed values: `not_requested`, `pending`, `declined`, `allowed`, `allowed_with_changes`
- `review_message` (string, optional, nullable) — वॉइस का रिव्यू मैसेज।
- `enabled_in_library` (boolean, optional) — क्या वॉइस लाइब्रेरी में सक्षम है।
- `instagram_username` (string, optional, nullable) — वॉइस का Instagram यूज़रनेम।
- `twitter_username` (string, optional, nullable) — वॉइस का Twitter/X यूज़रनेम।
- `youtube_username` (string, optional, nullable) — वॉइस का YouTube यूज़रनेम।
- `tiktok_username` (string, optional, nullable) — वॉइस का TikTok यूज़रनेम।
- `moderation_check` (VoiceSharingModerationCheckResponseModel, optional, nullable) — वॉइस की मॉडरेशन जांच।
- `reader_restricted_on` (list of ReaderResourceResponseModel, optional, nullable) — वॉइस पर रीडर प्रतिबंध चालू है।

### VerifiedVoiceLanguageResponseModel

- `language` (string, required) — वॉइस की भाषा।
- `model_id` (string, required) — वॉइस की मॉडल ID।
- `accent` (string, optional, nullable) — वॉइस का एक्सेंट, अगर लागू हो।
- `locale` (string, optional, nullable) — वॉइस का लोकेल, अगर लागू हो।
- `preview_url` (string, optional, nullable) — वॉइस का प्रीव्यू URL, अगर लागू हो।

### VoiceVerificationResponseModel

- `requires_verification` (boolean, required) — क्या वॉइस को वेरिफ़िकेशन की ज़रूरत है।
- `is_verified` (boolean, required) — क्या वॉइस सत्यापित हो चुकी है।
- `verification_failures` (list of string, required) — सत्यापन विफलताओं की सूची।
- `verification_attempts_count` (integer, required) — सत्यापन प्रयासों की संख्या।
- `language` (string, optional, nullable) — वॉइस की भाषा।
- `verification_attempts` (list of VerificationAttemptResponseModel, optional, nullable) — verification के प्रयासों की संख्या।

### ValidationError

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

### SpeakerSeparationResponseModel

- `voice_id` (string, required) — वॉइस का ID।
- `sample_id` (string, required) — सैंपल की ID।
- `status` (enum, required) — स्पीकर सेपरेशन का स्टेटस।
  - Allowed values: `not_started`, `pending`, `completed`, `failed`
- `speakers` (map from string to SpeakerResponseModel, optional, nullable) — सैंपल के स्पीकर।
- `selected_speaker_ids` (list of string, optional, nullable) — चुने गए स्पीकर के ID।

### VerificationAttemptResponseModel

- `text` (string, required) — वेरिफ़िकेशन प्रयास का टेक्स्ट।
- `date_unix` (integer, required) — Unix समय में वेरिफ़िकेशन प्रयास की तारीख।
- `accepted` (boolean, required) — क्या वेरिफ़िकेशन प्रयास स्वीकार किया गया था।
- `similarity` (double, required) — सत्यापन प्रयास की समानता।
- `levenshtein_distance` (double, required) — वेरिफ़िकेशन प्रयास की Levenshtein दूरी।
- `recording` (RecordingResponseModel, optional, nullable) — सत्यापन प्रयास की रिकॉर्डिंग।

### ManualVerificationResponseModel

- `extra_text` (string, required) — मैन्युअल वेरिफ़िकेशन का अतिरिक्त टेक्स्ट।
- `request_time_unix` (integer, required) — Unix समय में मैन्युअल वेरिफ़िकेशन की तारीख।
- `files` (list of ManualVerificationFileResponseModel, required) — मैन्युअल वेरिफ़िकेशन की फ़ाइलें।

### VoiceSharingModerationCheckResponseModel

- `date_checked_unix` (integer, optional, nullable) — Unix समय में मॉडरेशन जांच किए जाने की तारीख।
- `name_value` (string, optional, nullable) — वॉइस की नाम वैल्यू।
- `name_check` (boolean, optional, nullable) — क्या name check सफल रहा।
- `description_value` (string, optional, nullable) — वॉइस का विवरण मान।
- `description_check` (boolean, optional, nullable) — क्या description check सफल रहा।
- `sample_ids` (list of string, optional, nullable) — सैंपल IDs की सूची।
- `sample_checks` (list of double, optional, nullable) — सैंपल जाँचों की सूची।
- `captcha_ids` (list of string, optional, nullable) — captcha IDs की सूची।
- `captcha_checks` (list of double, optional, nullable) — CAPTCHA जाँच मानों की सूची।

### ReaderResourceResponseModel

- `resource_type` (enum, required) — रिसोर्स का टाइप।
  - Allowed values: `read`, `collection`
- `resource_id` (string, required) — रिसोर्स की ID।

### ValidationErrorLocItems

### SpeakerResponseModel

- `speaker_id` (string, required) — स्पीकर की ID।
- `duration_secs` (double, required) — स्पीकर सेगमेंट की अवधि सेकंड में।
- `utterances` (list of UtteranceResponseModel, optional, nullable) — स्पीकर के कथन।

### RecordingResponseModel

- `recording_id` (string, required) — रिकॉर्डिंग की ID।
- `mime_type` (string, required) — रिकॉर्डिंग का MIME प्रकार।
- `size_bytes` (integer, required) — रिकॉर्डिंग का आकार बाइट्स में।
- `upload_date_unix` (integer, required) — Unix समय में रिकॉर्डिंग की तारीख।
- `transcription` (string, required) — रिकॉर्डिंग का ट्रांसक्रिप्शन।

### ManualVerificationFileResponseModel

- `file_id` (string, required) — फ़ाइल की ID।
- `file_name` (string, required) — फ़ाइल का नाम।
- `mime_type` (string, required) — फ़ाइल का MIME प्रकार।
- `size_bytes` (integer, required) — फ़ाइल का आकार बाइट्स में।
- `upload_date_unix` (integer, required) — Unix समय में फ़ाइल की तारीख।

### UtteranceResponseModel

- `start` (double, required) — उच्चारण का शुरुआती समय, सेकंड में।
- `end` (double, required) — उच्चारण का समाप्ति समय सेकंड में।

## Examples

**Request**

```json
{
  "voice_name": "Sassy squeaky mouse",
  "voice_description": "A sassy squeaky mouse",
  "generated_voice_id": "37HceQefKmEi3bGovXjL"
}
```

**Response**

```json
{
  "voice_id": "21m00Tcm4TlvDq8ikWAM",
  "name": "Rachel",
  "category": "professional",
  "fine_tuning": {
    "is_allowed_to_fine_tune": true,
    "state": {
      "eleven_multilingual_v2": "fine_tuned"
    },
    "verification_failures": [],
    "verification_attempts_count": 2,
    "manual_verification_requested": false
  },
  "labels": {
    "accent": "American",
    "age": "middle-aged",
    "description": "expressive",
    "gender": "female",
    "use_case": "social media"
  },
  "description": "A warm, expressive voice with a touch of humor.",
  "preview_url": "https://storage.googleapis.com/eleven-public-prod/premade/voices/9BWtsMINqrJLrRacOk9x/405766b8-1f4e-4d3c-aba1-6f25333823ec.mp3",
  "available_for_tiers": [
    "creator",
    "enterprise"
  ],
  "settings": {
    "stability": 1,
    "use_speaker_boost": true,
    "similarity_boost": 1,
    "style": 0,
    "speed": 1
  },
  "sharing": {
    "status": "enabled",
    "history_item_sample_id": "DCwhRBWXzGAHq8TQ4Fs18",
    "date_unix": 1714204800,
    "whitelisted_emails": [
      "example@example.com"
    ],
    "public_owner_id": "DCwhRBWXzGAHq8TQ4Fs18",
    "original_voice_id": "DCwhRBWXzGAHq8TQ4Fs18",
    "financial_rewards_enabled": true,
    "free_users_allowed": true,
    "live_moderation_enabled": true,
    "rate": 0.05,
    "notice_period": 30,
    "disable_at_unix": 1714204800,
    "voice_mixing_allowed": false,
    "featured": true,
    "category": "professional",
    "reader_app_enabled": true,
    "liked_by_count": 100,
    "cloned_by_count": 50,
    "name": "Rachel",
    "description": "A female voice with a soft and friendly tone.",
    "labels": {
      "accent": "American",
      "gender": "female"
    },
    "review_status": "allowed",
    "enabled_in_library": true,
    "moderation_check": {
      "date_checked_unix": 1714204800,
      "name_value": "Rachel",
      "name_check": true,
      "description_value": "A female voice with a soft and friendly tone.",
      "description_check": true,
      "sample_ids": [
        "sample1",
        "sample2"
      ],
      "sample_checks": [
        0.95,
        0.98
      ],
      "captcha_ids": [
        "captcha1",
        "captcha2"
      ],
      "captcha_checks": [
        0.95,
        0.98
      ]
    },
    "reader_restricted_on": [
      {
        "resource_type": "read",
        "resource_id": "FCwhRBWXzGAHq8TQ4Fs18"
      }
    ]
  },
  "high_quality_base_model_ids": [
    "eleven_v2_flash",
    "eleven_flash_v2",
    "eleven_turbo_v2_5",
    "eleven_multilingual_v2",
    "eleven_v2_5_flash",
    "eleven_flash_v2_5",
    "eleven_turbo_v2"
  ],
  "verified_languages": [
    {
      "language": "en",
      "model_id": "eleven_multilingual_v2",
      "accent": "american",
      "locale": "en-US",
      "preview_url": "https://storage.googleapis.com/eleven-public-prod/premade/voices/9BWtsMINqrJLrRacOk9x/405766b8-1f4e-4d3c-aba1-6f25333823ec.mp3"
    }
  ],
  "voice_verification": {
    "requires_verification": false,
    "is_verified": true,
    "verification_failures": [],
    "verification_attempts_count": 0,
    "language": "en",
    "verification_attempts": [
      {
        "text": "Hello, how are you?",
        "date_unix": 1714204800,
        "accepted": true,
        "similarity": 0.95,
        "levenshtein_distance": 2,
        "recording": {
          "recording_id": "CwhRBWXzGAHq8TQ4Fs17",
          "mime_type": "audio/mpeg",
          "size_bytes": 1000000,
          "upload_date_unix": 1714204800,
          "transcription": "Hello, how are you?"
        }
      }
    ]
  },
  "is_owner": false,
  "is_legacy": false,
  "is_mixed": false
}
```

**SDK Code**

```python
import requests

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

payload = {
    "voice_name": "Sassy squeaky mouse",
    "voice_description": "A sassy squeaky mouse",
    "generated_voice_id": "37HceQefKmEi3bGovXjL"
}
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';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"voice_name":"Sassy squeaky mouse","voice_description":"A sassy squeaky mouse","generated_voice_id":"37HceQefKmEi3bGovXjL"}'
};

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"

	payload := strings.NewReader("{\n  \"voice_name\": \"Sassy squeaky mouse\",\n  \"voice_description\": \"A sassy squeaky mouse\",\n  \"generated_voice_id\": \"37HceQefKmEi3bGovXjL\"\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")

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_name\": \"Sassy squeaky mouse\",\n  \"voice_description\": \"A sassy squeaky mouse\",\n  \"generated_voice_id\": \"37HceQefKmEi3bGovXjL\"\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")
  .header("Content-Type", "application/json")
  .body("{\n  \"voice_name\": \"Sassy squeaky mouse\",\n  \"voice_description\": \"A sassy squeaky mouse\",\n  \"generated_voice_id\": \"37HceQefKmEi3bGovXjL\"\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', [
  'body' => '{
  "voice_name": "Sassy squeaky mouse",
  "voice_description": "A sassy squeaky mouse",
  "generated_voice_id": "37HceQefKmEi3bGovXjL"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

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

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "voice_name": "Sassy squeaky mouse",
  "voice_description": "A sassy squeaky mouse",
  "generated_voice_id": "37HceQefKmEi3bGovXjL"
] as [String : Any]

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

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