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

# टेक्स्ट टू स्पीच स्ट्रीमिंग

इस गाइड में तीन तरीके बताए गए हैं: स्पीच को फ़ाइल के रूप में जनरेट करना, ऑडियो रिस्पॉन्स को सीधे स्ट्रीम करना, और वैकल्पिक रूप से जनरेट किए गए ऑडियो को साइन किए गए URL के ज़रिए शेयर करने के लिए AWS S3 बकेट में अपलोड करना।

> **Note**
>
> इस गाइड में माना गया है कि आपने [अपनी API कुंजी और SDK सेट अप कर लिए हैं](/docs/hi/eleven-api/quickstart)। अगर आपने अभी तक ऐसा नहीं किया है, तो पहले
> क्विकस्टार्ट पूरा करें। वैकल्पिक S3 अपलोड सेक्शन के लिए S3 एक्सेस वाले AWS अकाउंट की भी ज़रूरत होती है।

> **Tip**
>
> जानना चाहते हैं कि स्ट्रीमिंग इस तरह कैसे काम करती है? [ऑडियो स्ट्रीमिंग को समझें](/docs/hi/eleven-api/concepts/audio-streaming) में प्रोटोकॉल, बफ़रिंग और
> लेटेंसी के बीच के संतुलन को विस्तार से समझाया गया है।

## टेक्स्ट को स्पीच में बदलें (फ़ाइल)

टेक्स्ट को स्पीच में बदलकर फ़ाइल के रूप में सेव करने के लिए, हम ElevenLabs SDK का `convert` मेथड इस्तेमाल करेंगे और फिर इसे लोकल रूप से `.mp3` फ़ाइल में सेव करेंगे।

**`Python`**

```python Python

import os
import uuid
from dotenv import load_dotenv
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs

load_dotenv()

ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
elevenlabs = ElevenLabs(
    api_key=ELEVENLABS_API_KEY,
)


def text_to_speech_file(text: str) -> str:
    # Calling the text_to_speech conversion API with detailed parameters
    response = elevenlabs.text_to_speech.convert(
        voice_id="pNInz6obpgDQGcFmaJgB", # Adam pre-made voice
        output_format="mp3_22050_32",
        text=text,
        model_id="eleven_flash_v2_5", # use the flash model for low latency
        # Optional voice settings that allow you to customize the output
        voice_settings=VoiceSettings(
            stability=0.0,
            similarity_boost=1.0,
            style=0.0,
            use_speaker_boost=True,
            speed=1.0,
        ),
    )

    # uncomment the line below to play the audio back
    # play(response)

    # Generating a unique file name for the output MP3 file
    save_file_path = f"{uuid.uuid4()}.mp3"

    # Writing the audio to a file
    with open(save_file_path, "wb") as f:
        for chunk in response:
            if chunk:
                f.write(chunk)

    print(f"{save_file_path}: A new audio file was saved successfully!")

    # Return the path of the saved audio file
    return save_file_path

```

**`TypeScript`**

```typescript TypeScript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import * as dotenv from "dotenv";
import { createWriteStream } from "fs";
import { v4 as uuid } from "uuid";

dotenv.config();

const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;

const elevenlabs = new ElevenLabsClient({
  apiKey: ELEVENLABS_API_KEY,
});

export const createAudioFileFromText = async (text: string): Promise<string> => {
  return new Promise<string>(async (resolve, reject) => {
    try {
      const audio = await elevenlabs.textToSpeech.convert("JBFqnCBsd6RMkjVDRZzb", {
        modelId: "eleven_v4",
        text,
        outputFormat: "mp3_44100_128",
        // Optional voice settings that allow you to customize the output
        voiceSettings: {
          stability: 0,
          similarityBoost: 0,
          useSpeakerBoost: true,
          speed: 1.0,
        },
      });

      const fileName = `${uuid()}.mp3`;
      const fileStream = createWriteStream(fileName);

      audio.pipe(fileStream);
      fileStream.on("finish", () => resolve(fileName)); // Resolve with the fileName
      fileStream.on("error", reject);
    } catch (error) {
      reject(error);
    }
  });
};
```

फिर आप इस फ़ंक्शन को ऐसे चला सकते हैं:

**`Python`**

```python Python
text_to_speech_file("Hello World")
```

**`TypeScript`**

```typescript TypeScript
await createAudioFileFromText("Hello World");
```

## टेक्स्ट को स्पीच में बदलें (स्ट्रीमिंग)

अगर आप ऑडियो को फ़ाइल में सेव किए बिना सीधे स्ट्रीम करना चाहते हैं, तो हमारी स्ट्रीमिंग सुविधा इस्तेमाल कर सकते हैं।

**`Python`**

```python Python

import os
from typing import IO
from io import BytesIO
from dotenv import load_dotenv
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs

load_dotenv()

ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
elevenlabs = ElevenLabs(
    api_key=ELEVENLABS_API_KEY,
)


def text_to_speech_stream(text: str) -> IO[bytes]:
    # Perform the text-to-speech conversion
    response = elevenlabs.text_to_speech.stream(
        voice_id="pNInz6obpgDQGcFmaJgB", # Adam pre-made voice
        output_format="mp3_22050_32",
        text=text,
        model_id="eleven_multilingual_v2",
        # Optional voice settings that allow you to customize the output
        voice_settings=VoiceSettings(
            stability=0.0,
            similarity_boost=1.0,
            style=0.0,
            use_speaker_boost=True,
            speed=1.0,
        ),
    )

    # Create a BytesIO object to hold the audio data in memory
    audio_stream = BytesIO()

    # Write each chunk of audio data to the stream
    for chunk in response:
        if chunk:
            audio_stream.write(chunk)

    # Reset stream position to the beginning
    audio_stream.seek(0)

    # Return the stream for further use
    return audio_stream

```

**`TypeScript`**

```typescript TypeScript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import * as dotenv from "dotenv";

dotenv.config();

const ELEVENLABS_API_KEY = process.env.ELEVENLABS_API_KEY;

if (!ELEVENLABS_API_KEY) {
  throw new Error("Missing ELEVENLABS_API_KEY in environment variables");
}

const elevenlabs = new ElevenLabsClient({
  apiKey: ELEVENLABS_API_KEY,
});

export const createAudioStreamFromText = async (text: string): Promise<Buffer> => {
  const audioStream = await elevenlabs.textToSpeech.stream("JBFqnCBsd6RMkjVDRZzb", {
    modelId: "eleven_v4",
    text,
    outputFormat: "mp3_44100_128",
    // Optional voice settings that allow you to customize the output
    voiceSettings: {
      stability: 0,
      similarityBoost: 1.0,
      useSpeakerBoost: true,
      speed: 1.0,
    },
  });

  const chunks: Buffer[] = [];
  for await (const chunk of audioStream) {
    chunks.push(chunk);
  }

  const content = Buffer.concat(chunks);
  return content;
};
```

फिर आप इस फ़ंक्शन को ऐसे चला सकते हैं:

**`Python`**

```python Python
text_to_speech_stream("This is James")
```

**`TypeScript`**

```typescript TypeScript
await createAudioStreamFromText("This is James");
```

## बोनस - AWS S3 पर अपलोड करना और सुरक्षित शेयरिंग लिंक पाना

जब आपका ऑडियो डेटा फ़ाइल या स्ट्रीम के रूप में बन जाए, तो आप इसे अपने यूज़र्स के साथ शेयर करना चाह सकते हैं। ऐसा करने का एक तरीका इसे AWS S3 बकेट में अपलोड करके एक सुरक्षित शेयरिंग लिंक जनरेट करना है।

#### अपने AWS क्रेडेंशियल्स बनाना

डेटा को S3 पर अपलोड करने के लिए, आपको अपनी AWS access key ID, secret access key और AWS region name को अपनी `.env` फ़ाइल में जोड़ना होगा। क्रेडेंशियल्स पाने के लिए ये चरण अपनाएं:

1. अपने AWS Management Console में लॉग इन करें: AWS होम पेज पर जाएं और अपने अकाउंट से साइन इन करें।

![](/docs/_fern-img/e9f1f1b1950962c3d67ea25a0593ca989d33c9f49b641e22eb3f861fc72735e3.webp)

2. IAM (Identity and Access Management) डैशबोर्ड खोलें: सर्विसेज़ मेनू में आपको IAM, "Security, Identity, & Compliance" के अंतर्गत मिलेगा। IAM डैशबोर्ड आपके AWS सर्विसेज़ के एक्सेस को सुरक्षित रूप से मैनेज करता है।

![](/docs/_fern-img/d6fa7e75879e7537693c4edde16d0ac5face78d72b00de50743a754c0681a5e3.webp)

3. नया यूज़र बनाएं (ज़रूरत होने पर): IAM डैशबोर्ड पर "Users" और फिर "Add user" चुनें। यूज़र का नाम दर्ज करें।

![](/docs/_fern-img/47b05ffda6925e4e14147aadc296d7c86cbd3340aaa1025083f1e1464b230f51.webp)

4. परमिशन सेट करें: जिस स्तर का एक्सेस देना चाहते हैं, उसके अनुसार सीधे यूज़र से पॉलिसीज़ अटैच करें। S3 अपलोड के लिए आप AmazonS3FullAccess पॉलिसी इस्तेमाल कर सकते हैं। हालांकि, न्यूनतम विशेषाधिकार देना सबसे अच्छा तरीका है, यानी किसी काम के लिए केवल ज़रूरी परमिशन ही दें। आप एक कस्टम पॉलिसी बना सकते हैं, जो आपके S3 बकेट पर सिर्फ़ ज़रूरी कार्रवाइयों की अनुमति दे।

![](/docs/_fern-img/4b88bba4f5bb1509aa087a1ab5cc8068a274b17d8887c563f050b77e8438bb94.webp)

5. यूज़र की समीक्षा करें और बनाएं: अपनी सेटिंग्स की समीक्षा करें और यूज़र बनाएं। बनने के बाद आपको access key ID और secret access key दिखेगी। इन क्रेडेंशियल्स को डाउनलोड करके सुरक्षित रूप से सेव करना न भूलें; इस चरण के बाद secret access key फिर से नहीं पाई जा सकती।

![](/docs/_fern-img/27dcdff3681522cf936ff6bfb81cf216ada1fe401c7c1dbd10e58cead8a48abc.webp)

6. AWS region name पाएं: उदाहरण: us-east-1

![](/docs/_fern-img/016bc11c2f040942b215366c5fc9ac8e01f6261f5ebd44a3456d4b7ba97e9ae8.webp)

अगर आपके पास AWS S3 बकेट नहीं है, तो आपको इन चरणों का पालन करके नया बकेट बनाना होगा:

1. S3 डैशबोर्ड खोलें: सर्विसेज़ मेनू में आपको S3, "Storage" के अंतर्गत मिलेगा।

![](/docs/_fern-img/d2455fa92ce6dfa705c3b91144fe22539fae1611848cb8e3cc2dac20e57db4e7.webp)

2. नया बकेट बनाएं: S3 डैशबोर्ड पर "Create bucket" बटन पर क्लिक करें।

![](/docs/_fern-img/3b7d5bdb6559e8511445b41b1bbdeed3f6674791cf23021a30ccb5aa8143be28.webp)

3. बकेट का नाम दर्ज करें और "Create bucket" बटन पर क्लिक करें। आप बकेट के अन्य विकल्पों को डिफ़ॉल्ट पर ही छोड़ सकते हैं। नया जोड़ा गया बकेट सूची में दिखाई देगा।

![](/docs/_fern-img/68d23f21bec1e3aa70b18f09c40c9bdace5ff0dd63edc17c6807e7ddac75758d.webp)![](/docs/_fern-img/63f7af93d4a73fab3011853c8393c954400d9f344a5811ec90b86d6c69b2ec16.webp)

#### AWS SDK इंस्टॉल करना और क्रेडेंशियल्स जोड़ना

`pip` और `npm` का इस्तेमाल करके AWS सर्विसेज़ के साथ इंटरैक्ट करने के लिए `boto3` इंस्टॉल करें।

**`Python`**

```bash Python
pip install boto3
```

**`TypeScript`**

```bash TypeScript
npm install @aws-sdk/client-s3
npm install @aws-sdk/s3-request-presigner
```

फिर एनवायरनमेंट वेरिएबल्स को `.env` फ़ाइल में इस तरह जोड़ें:

```
AWS_ACCESS_KEY_ID=your_aws_access_key_id_here
AWS_SECRET_ACCESS_KEY=your_aws_secret_access_key_here
AWS_REGION_NAME=your_aws_region_name_here
AWS_S3_BUCKET_NAME=your_s3_bucket_name_here
```

#### AWS S3 पर अपलोड करना और साइन किया गया URL जनरेट करना

ऑडियो स्ट्रीम को S3 पर अपलोड करने और साइन किया गया URL जनरेट करने के लिए ये फ़ंक्शन जोड़ें।

**`s3_uploader.py (Python)`**

```python s3_uploader.py (Python)

import os
import boto3
import uuid

AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
AWS_REGION_NAME = os.getenv("AWS_REGION_NAME")
AWS_S3_BUCKET_NAME = os.getenv("AWS_S3_BUCKET_NAME")

session = boto3.Session(
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
    region_name=AWS_REGION_NAME,
)
s3 = session.client("s3")


def generate_presigned_url(s3_file_name: str) -> str:
    signed_url = s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": AWS_S3_BUCKET_NAME, "Key": s3_file_name},
        ExpiresIn=3600,
    )  # URL expires in 1 hour
    return signed_url


def upload_audiostream_to_s3(audio_stream) -> str:
    s3_file_name = f"{uuid.uuid4()}.mp3"  # Generates a unique file name using UUID
    s3.upload_fileobj(audio_stream, AWS_S3_BUCKET_NAME, s3_file_name)

    return s3_file_name

```

**`s3_uploader.ts (TypeScript)`**

```typescript s3_uploader.ts (TypeScript)
import { S3Client, PutObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
import * as dotenv from "dotenv";
import { v4 as uuid } from "uuid";

dotenv.config();

const { AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION_NAME, AWS_S3_BUCKET_NAME } =
  process.env;

if (!AWS_ACCESS_KEY_ID || !AWS_SECRET_ACCESS_KEY || !AWS_REGION_NAME || !AWS_S3_BUCKET_NAME) {
  throw new Error("One or more environment variables are not set. Please check your .env file.");
}

const s3 = new S3Client({
  credentials: {
    accessKeyId: AWS_ACCESS_KEY_ID,
    secretAccessKey: AWS_SECRET_ACCESS_KEY,
  },
  region: AWS_REGION_NAME,
});

export const generatePresignedUrl = async (objectKey: string) => {
  const getObjectParams = {
    Bucket: AWS_S3_BUCKET_NAME,
    Key: objectKey,
    Expires: 3600,
  };
  const command = new GetObjectCommand(getObjectParams);
  const url = await getSignedUrl(s3, command, { expiresIn: 3600 });
  return url;
};

export const uploadAudioStreamToS3 = async (audioStream: Buffer) => {
  const remotePath = `${uuid()}.mp3`;
  await s3.send(
    new PutObjectCommand({
      Bucket: AWS_S3_BUCKET_NAME,
      Key: remotePath,
      Body: audioStream,
      ContentType: "audio/mpeg",
    })
  );
  return remotePath;
};
```

अब आप टेक्स्ट से मिली ऑडियो स्ट्रीम के साथ अपलोडिंग फ़ंक्शन को कॉल कर सकते हैं।

**`Python`**

```python Python
s3_file_name = upload_audiostream_to_s3(audio_stream)
```

**`TypeScript`**

```typescript TypeScript
const s3path = await uploadAudioStreamToS3(stream);
```

ऑडियो फ़ाइल को S3 पर अपलोड करने के बाद, फ़ाइल का एक्सेस शेयर करने के लिए एक साइन किया गया URL जनरेट करें। यह URL सीमित समय के लिए मान्य होगा, यानी एक तय अवधि बाद समाप्त हो जाएगा, इसलिए अस्थायी शेयरिंग के लिए सुरक्षित है।

अब आप फ़ाइल से URL ऐसे जनरेट कर सकते हैं:

**`Python`**

```python Python
signed_url = generate_presigned_url(s3_file_name)
print(f"Signed URL to access the file: {signed_url}")
```

**`TypeScript`**

```typescript TypeScript
const presignedUrl = await generatePresignedUrl(s3path);
console.log("Presigned URL:", presignedUrl);
```

अगर आप फ़ाइल को कई बार इस्तेमाल करना चाहते हैं, तो साइन किया हुआ URL सीधे सेव करने के बजाय अपने डेटाबेस में S3 फ़ाइल पाथ सेव करें और ज़रूरत पड़ने पर हर बार साइन किया हुआ URL फिर से जनरेट करें, क्योंकि वह समाप्त हो जाएगा।

#### सब कुछ एक साथ जोड़ना

सब कुछ एक साथ जोड़ने के लिए, आप नीचे दिया गया स्क्रिप्ट इस्तेमाल कर सकते हैं:

**`main.py (Python)`**

```python main.py (Python)

import os

from dotenv import load_dotenv

load_dotenv()

from text_to_speech_stream import text_to_speech_stream
from s3_uploader import upload_audiostream_to_s3, generate_presigned_url


def main():
    text = "This is James"

    audio_stream = text_to_speech_stream(text)
    s3_file_name = upload_audiostream_to_s3(audio_stream)
    signed_url = generate_presigned_url(s3_file_name)

    print(f"Signed URL to access the file: {signed_url}")


if __name__ == "__main__":
    main()

```

**`index.ts (Typescript)`**

```typescript index.ts (Typescript)
import "dotenv/config";

import { generatePresignedUrl, uploadAudioStreamToS3 } from "./s3_uploader";
import { createAudioFileFromText } from "./text_to_speech_file";
import { createAudioStreamFromText } from "./text_to_speech_stream";

(async () => {
  // save the audio file to disk
  const fileName = await createAudioFileFromText(
    "Today, the sky is exceptionally clear, and the sun shines brightly."
  );

  console.log("File name:", fileName);

  // OR stream the audio, upload to S3, and get a presigned URL
  const stream = await createAudioStreamFromText(
    "Today, the sky is exceptionally clear, and the sun shines brightly."
  );

  const s3path = await uploadAudioStreamToS3(stream);

  const presignedUrl = await generatePresignedUrl(s3path);

  console.log("Presigned URL:", presignedUrl);
})();
```

## निष्कर्ष

अब आप जानते हैं कि टेक्स्ट को स्पीच में कैसे बदलें और ऑडियो फ़ाइल शेयर करने के लिए साइन किया गया URL कैसे जनरेट करें। यह सुविधा आपको डायनामिक रूप से कंटेंट बनाने और शेयर करने के कई अवसर देती है।

इससे आप ये चीज़ें बना सकते हैं:

1. **शैक्षिक पॉडकास्ट**: ऐसा व्यक्तिगत शैक्षिक कंटेंट बनाएं जिसे छात्र ज़रूरत पड़ने पर एक्सेस कर सकें। शिक्षक अपने पाठों को ऑडियो फ़ॉर्मैट में बदल सकते हैं, उन्हें S3 पर अपलोड कर सकते हैं और पारंपरिक कक्षा के बाहर अधिक आकर्षक सीखने के अनुभव के लिए छात्रों के साथ लिंक शेयर कर सकते हैं।

2. **वेबसाइटों के लिए एक्सेसिबिलिटी सुविधाएं**: टेक्स्ट कंटेंट को ऑडियो फ़ॉर्मैट में उपलब्ध कराकर वेबसाइट की एक्सेसिबिलिटी बढ़ाएं। इससे वेबसाइट की जानकारी दृष्टिबाधित लोगों या सुनकर सीखना पसंद करने वालों के लिए अधिक सुलभ हो सकती है।

3. **ऑटोमेटेड कस्टमर सपोर्ट मैसेज**: कस्टमर सपोर्ट के लिए ऑटोमेटेड और व्यक्तिगत ऑडियो मैसेज बनाएं, जैसे FAQs या ऑर्डर अपडेट। यह पारंपरिक टेक्स्ट ईमेल की तुलना में अधिक आकर्षक ग्राहक अनुभव दे सकता है।

4. **ऑडियोबुक और नैरेशन**: पूरी किताबों या छोटी कहानियों को ऑडियो फ़ॉर्मैट में बदलें, जिससे श्रोता साहित्य का आनंद नए तरीके से ले सकें। लेखक और प्रकाशक अपने कंटेंट ऑफ़रिंग में विविधता ला सकते हैं और पढ़ने के बजाय सुनना पसंद करने वाले लोगों तक पहुंच सकते हैं।

5. **भाषा सीखने के टूल**: ऐसे भाषा-शिक्षण सहायक बनाएं जो सीखने वालों को ऑडियो लेसन और अभ्यास दें। इससे उच्चारण और सुनने के कौशल का केंद्रित तरीके से अभ्यास करना संभव होता है।

## अगले चरण

#### [WebSocket स्ट्रीमिंग](/docs/hi/eleven-api/guides/how-to/websockets/realtime-tts)

LLM द्वारा जनरेट होते समय टेक्स्ट को रीयल टाइम में स्पीच में स्ट्रीम करने के लिए WebSockets का इस्तेमाल करें।

#### [लेटेंसी को समझें](/docs/hi/eleven-api/concepts/latency)

जानें कि लेटेंसी किन कारणों से होती है और पहले ऑडियो तक पहुंचने का समय कैसे कम करें।