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-api-key")
12
13
    # Connect and transcribe
14
    async with client.speech_to_text_streaming.connect(
15
        language_code="en-IN", high_vad_sensitivity=True
16
    ) as ws:
17
        # Send audio for transcription
18
        await ws.transcribe(audio=audio_data)
19
        
20
        # Get the result
21
        response = await ws.recv()
22
        print(f"Transcription: {response}")
23
24
# Run the transcription
25
asyncio.run(basic_transcription())

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 enhanced_transcription():
10
    client = AsyncSarvamAI(api_subscription_key="your-api-key")
11
12
    async with client.speech_to_text_streaming.connect(
13
        language_code="hi-IN",           # Hindi (India)
14
        model="saarika:v2.5",           # Latest model
15
        high_vad_sensitivity=True,       # Better voice detection
16
        vad_signals=True                # Get speech start/end signals
17
    ) as ws:
18
        # Send audio
19
        await ws.transcribe(
20
            audio=audio_data,
21
            encoding="audio/wav",
22
            sample_rate=16000
23
        )
24
        
25
        # Handle multiple response types
26
        async for message in ws:
27
            if message.get("type") == "speech_start":
28
                print("🎤 Speech detected")
29
            elif message.get("type") == "speech_end":
30
                print("🔇 Speech ended")
31
            elif message.get("type") == "transcript":
32
                print(f"📝 Result: {message.get('text')}")
33
                break  # Got our transcription
34
35
# Run the enhanced transcription
36
asyncio.run(enhanced_transcription())

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 instant_processing():
10
    client = AsyncSarvamAI(api_subscription_key="your-api-key")
11
12
    async with client.speech_to_text_streaming.connect(
13
        language_code="en-IN",
14
        model="saarika:v2.5",
15
        flush_signal=True  # Enable manual control
16
    ) as ws:
17
        # Send audio
18
        await ws.transcribe(
19
            audio=audio_data,
20
            encoding="audio/wav",
21
            sample_rate=16000
22
        )
23
        
24
        # Force immediate processing
25
        await ws.flush()
26
        print("⚡ Processing forced - getting immediate results")
27
28
        # Get results
29
        async for message in ws:
30
            print(f"Result: {message}")
31
            break
32
33
# Run instant processing
34
asyncio.run(instant_processing())

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 custom_audio_config():
10
    client = AsyncSarvamAI(api_subscription_key="your-api-key")
11
12
    async with client.speech_to_text_streaming.connect(
13
        language_code="kn-IN",
14
        model="saarika:v2.5",
15
        sample_rate=8000,               # Match your audio
16
        input_audio_codec="pcm_s16le",  # Specify codec (wav, pcm_s16le, pcm_l16, pcm_raw)
17
        high_vad_sensitivity=True       # For noisy environments
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"Optimized result: {response}")
27
28
# Run custom audio configuration
29
asyncio.run(custom_audio_config())