Streaming Speech-to-Text API

1
import asyncio
2
import base64
3
from sarvamai import AsyncSarvamAI
4
5
# Load your audio file
6
with open("path/to/your/audio.wav", "rb") as f:
7
    audio_data = base64.b64encode(f.read()).decode("utf-8")
8
9
async def basic_transcription():
10
    # Initialize client with your API key
11
    client = AsyncSarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
12
13
    # Connect and transcribe — change mode as needed
14
    async with client.speech_to_text_streaming.connect(
15
        model="saaras:v3",
16
        mode="transcribe",
17
        language_code="en-IN",
18
        high_vad_sensitivity=True
19
    ) as ws:
20
        await ws.transcribe(audio=audio_data)
21
        response = await ws.recv()
22
        print(f"Result: {response}")
23
24
asyncio.run(basic_transcription())

1
import asyncio
2
import base64
3
from sarvamai import AsyncSarvamAI
4
5
with open("path/to/your/audio.wav", "rb") as f:
6
    audio_data = base64.b64encode(f.read()).decode("utf-8")
7
8
async def enhanced_transcription():
9
    client = AsyncSarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
10
11
    async with client.speech_to_text_streaming.connect(
12
        model="saaras:v3",
13
        mode="transcribe",              # Change mode as needed
14
        language_code="hi-IN",
15
        high_vad_sensitivity=True,       # Better voice detection
16
        vad_signals=True                # Get speech start/end signals
17
    ) as ws:
18
        await ws.transcribe(
19
            audio=audio_data,
20
            encoding="audio/wav",
21
            sample_rate=16000
22
        )
23
        
24
        async for message in ws:
25
            if message.type == "events":
26
                # VAD signals arrive as events (signal_type is START_SPEECH / END_SPEECH)
27
                print(f"Voice activity: {message.data.signal_type}")
28
            elif message.type == "data":
29
                print(f"Result: {message.data.transcript}")
30
                break
31
32
asyncio.run(enhanced_transcription())

1
import asyncio
2
import base64
3
from sarvamai import AsyncSarvamAI
4
5
with open("path/to/your/audio.wav", "rb") as f:
6
    audio_data = base64.b64encode(f.read()).decode("utf-8")
7
8
async def instant_processing():
9
    client = AsyncSarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
10
11
    async with client.speech_to_text_streaming.connect(
12
        model="saaras:v3",
13
        mode="transcribe",              # Change mode as needed
14
        language_code="en-IN",
15
        flush_signal=True               # Enable manual control
16
    ) as ws:
17
        await ws.transcribe(
18
            audio=audio_data,
19
            encoding="audio/wav",
20
            sample_rate=16000
21
        )
22
        
23
        # Force immediate processing
24
        await ws.flush()
25
26
        async for message in ws:
27
            print(f"Result: {message}")
28
            break
29
30
asyncio.run(instant_processing())

1
import asyncio
2
import base64
3
from sarvamai import AsyncSarvamAI
4
5
with open("path/to/your/audio.wav", "rb") as f:
6
    audio_data = base64.b64encode(f.read()).decode("utf-8")
7
8
async def custom_audio_config():
9
    client = AsyncSarvamAI(api_subscription_key="YOUR_SARVAM_API_KEY")
10
11
    async with client.speech_to_text_streaming.connect(
12
        model="saaras:v3",
13
        mode="transcribe",              # Change mode as needed
14
        language_code="kn-IN",
15
        sample_rate=8000,               # Match your audio
16
        input_audio_codec="pcm_s16le",  # Specify codec
17
        high_vad_sensitivity=True
18
    ) as ws:
19
        await ws.transcribe(
20
            audio=audio_data,
21
            encoding="audio/wav",
22
            sample_rate=8000             # Must match connection setting
23
        )
24
        
25
        response = await ws.recv()
26
        print(f"Result: {response}")
27
28
asyncio.run(custom_audio_config())