# Nemotron 3.5 ASR Streaming 0.6B

A streaming speech recognition model. Stream audio in and receive punctuated text while the speaker is still talking, in 32 languages or with automatic language detection. In public beta.

Model ID `nemotron-asr-streaming`

[Open in Playground](https://api.dotwave.ai/dashboard?model=nemotron-asr-streaming) · [Model source](https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b)

- **Price**: $0.00045 / minute (Billed from the first audio until the session closes)
- **Modality**: Speech to text (Streaming)
- **Languages**: 32 (Or automatic detection)
- **Status**: Public beta (May change before general availability)

## Use this model

Set `DOTWAVE_API_KEY` on your server. Point the OpenAI SDK at `https://api.dotwave.ai/v1` and open a transcription session, or point the Deepgram plugin of LiveKit Agents or Pipecat at .wave. For a browser, create a short-lived client secret on your server, as in the curl example.

```python
import asyncio, os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key=os.environ["DOTWAVE_API_KEY"],
    base_url="https://api.dotwave.ai/v1",
)

async def main():
    async with client.realtime.connect(model="nemotron-asr-streaming") as conn:
        await conn.session.update(session={
            "type": "transcription",
            "audio": {"input": {
                "format": {"type": "audio/pcm", "rate": 24000},
                "transcription": {
                    "model": "nemotron-asr-streaming",
                    "language": "pt-BR",  # leave it out to detect the language
                },
            }},
        })
        # Stream 24 kHz mono PCM16 as it is captured, with
        # conn.input_audio_buffer.append(audio=base64_chunk).
        async for event in conn:
            if event.type == "conversation.item.input_audio_transcription.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "conversation.item.input_audio_transcription.completed":
                print()

asyncio.run(main())
```

```typescript
import OpenAI from 'openai';
import { OpenAIRealtimeWS } from 'openai/realtime/ws';

const client = new OpenAI({
  apiKey: process.env.DOTWAVE_API_KEY,
  baseURL: 'https://api.dotwave.ai/v1',
});
const rt = new OpenAIRealtimeWS({ model: 'nemotron-asr-streaming' }, client);

rt.socket.on('open', () => {
  rt.send({
    type: 'session.update',
    session: {
      type: 'transcription',
      audio: {
        input: {
          format: { type: 'audio/pcm', rate: 24000 },
          transcription: {
            model: 'nemotron-asr-streaming',
            language: 'pt-BR', // leave it out to detect the language
          },
        },
      },
    },
  });
  // Stream 24 kHz mono PCM16 as it is captured, with
  // rt.send({ type: 'input_audio_buffer.append', audio: base64Chunk }).
});

rt.on('conversation.item.input_audio_transcription.delta', event => {
  process.stdout.write(event.delta);
});
rt.on('conversation.item.input_audio_transcription.completed', () => {
  process.stdout.write('\n');
});
rt.on('error', error => console.error(error.message));
```

```python
import os

# LiveKit Agents
from livekit.plugins import deepgram

stt = deepgram.STT(
    api_key=os.environ["DOTWAVE_API_KEY"],
    base_url="https://api.dotwave.ai/v1/listen",
    model="nemotron-asr-streaming",
    language="pt-BR",
)

# Pipecat
from pipecat.services.deepgram.stt import DeepgramSTTService
from pipecat.transcriptions.language import Language

stt = DeepgramSTTService(
    api_key=os.environ["DOTWAVE_API_KEY"],
    base_url="api.dotwave.ai",
    settings=DeepgramSTTService.Settings(
        model="nemotron-asr-streaming",
        language=Language.PT_BR,
    ),
)
```

```bash
curl https://api.dotwave.ai/v1/realtime/client_secrets \
  -H "Authorization: Bearer $DOTWAVE_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "expires_after": {
      "anchor": "created_at",
      "seconds": 60
    },
    "session": {
      "type": "transcription",
      "audio": {
        "input": {
          "format": {"type": "audio/pcm", "rate": 24000},
          "transcription": {
            "model": "nemotron-asr-streaming",
            "language": "pt-BR"
          }
        }
      }
    }
  }'
```

[Realtime API](https://dotwave.ai/docs/realtime/) · [Deepgram-compatible API](https://dotwave.ai/docs/deepgram/) · [OpenAI SDK guide](https://dotwave.ai/docs/guides/openai-sdk/)

## Languages

Set `audio.input.transcription.language`, or `language` on the Deepgram route, to one of these tags. Leave it out and the model detects the language automatically; when you know the language, naming it is more accurate. We publish no accuracy figures per language yet, so test with audio like yours before you rely on it.

- Arabic `ar-AR`
- Bulgarian `bg-BG`
- Chinese, Mandarin Simplified `zh-CN`
- Croatian `hr-HR`
- Czech `cs-CZ`
- Danish `da-DK`
- Dutch `nl-NL`
- English, United Kingdom `en-GB`
- English, United States `en-US`
- Estonian `et-EE`
- Finnish `fi-FI`
- French, Canada `fr-CA`
- French, France `fr-FR`
- German `de-DE`
- Hindi `hi-IN`
- Hungarian `hu-HU`
- Italian `it-IT`
- Japanese `ja-JP`
- Korean `ko-KR`
- Norwegian Bokmål `nb-NO`
- Polish `pl-PL`
- Portuguese, Brazil `pt-BR`
- Portuguese, Portugal `pt-PT`
- Romanian `ro-RO`
- Russian `ru-RU`
- Slovak `sk-SK`
- Spanish, Spain `es-ES`
- Spanish, United States `es-US`
- Swedish `sv-SE`
- Turkish `tr-TR`
- Ukrainian `uk-UA`
- Vietnamese `vi-VN`

## Specifications

- **Author**: NVIDIA
- **Parameters**: 0.6B
- **Input**: Mono audio: PCM16 at 24 or 16 kHz, or G.711
- **Output**: Punctuated, capitalized text
- **Interaction**: Streaming
- **Access**: [Realtime API](https://dotwave.ai/docs/realtime/) or [Deepgram-compatible API](https://dotwave.ai/docs/deepgram/)

## Limits

Stream audio at the speed of speech: the server accepts up to 640 ms of audio ahead of real time, and a client that sends faster is disconnected. A session closes after 30 seconds without audio and runs for up to 24 hours. Transcription prompts, noise reduction, speaker diarization, multichannel audio and keyword boosting are not supported.

[Errors and close codes](https://dotwave.ai/docs/errors/)