> ## Documentation Index
> Fetch the complete documentation index at: https://docs.zeroruntime.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Gladia

> Python API reference for the gladia speech-to-text plugin.

<Card title="Usage guide" icon="book" href="/plugins/stt/gladia" horizontal>
  Setup, environment variables, and Python/JavaScript/Go usage examples.
</Card>

## GladiaSTT

Gladia real-time speech-to-text via WebSocket streaming.

Wraps the Gladia Live Speech Recognition API (v2) using the `solaria-1`
model, which supports 90+ languages with optional per-utterance language
detection (code-switching).

### Constructor

```python theme={null}
GladiaSTT(*, api_key: 'str | None' = None, model: 'str' = 'solaria-1', languages: 'List[str] | None' = None, code_switching: 'bool' = True, input_sample_rate: 'int' = 48000, output_sample_rate: 'int' = 16000, encoding: 'str' = 'wav/pcm', bit_depth: 'int' = 16, channels: 'int' = 1, receive_partial_transcripts: 'bool' = False) -> 'None'
```

<ParamField path="api_key" type="str | None">
  Gladia API key. Falls back to the `GLADIA_API_KEY` environment variable when `None`.
</ParamField>

<ParamField path="model" type="str" default="solaria-1">
  Gladia recognition model. `"solaria-1"` is the only production model and the default.
</ParamField>

<ParamField path="languages" type="List[str] | None">
  ISO 639-1 language codes to hint at (e.g. `["en", "fr"]`). Only the first element is used. When `None` the default is `"english"`.
</ParamField>

<ParamField path="code_switching" type="bool" default="True">
  When `True`, language is re-detected on every utterance. When `False`, language is detected once on the first utterance and held for the session. Default: `True`.
</ParamField>

<ParamField path="input_sample_rate" type="int" default="48000">
  Sample rate (Hz) of the incoming audio before any resampling. Valid values: `8000`, `16000`, `32000`, `44100`, `48000`. Default: `48000`.
</ParamField>

<ParamField path="output_sample_rate" type="int" default="16000">
  Sample rate (Hz) forwarded to the Gladia WebSocket session. Default: `16000`.
</ParamField>

<ParamField path="encoding" type="str" default="wav/pcm">
  PCM encoding format sent over the WebSocket. Valid values: `"wav/pcm"` (default), `"wav/alaw"`, `"wav/ulaw"`.
</ParamField>

<ParamField path="bit_depth" type="int" default="16">
  Bit depth of the PCM samples. Valid values: `8`, `16` (default), `24`, `32`.
</ParamField>

<ParamField path="channels" type="int" default="1">
  Number of audio channels (1–8). Default: `1` (mono).
</ParamField>

<ParamField path="receive_partial_transcripts" type="bool" default="False">
  When `True`, partial (non-final) transcripts are emitted over the WebSocket before the utterance is complete. Default: `False`.
</ParamField>

### aclose

```python theme={null}
def aclose(self) -> 'None'
```

Release any resources held by the provider.

### emit

```python theme={null}
def emit(self, event: 'T', *args: 'Any') -> 'None'
```

Emit an event, invoking all registered handlers with the given arguments.

Handlers are called in registration order. Coroutine handlers are
scheduled on the running event loop. If the emitter is closed, the call
is a no-op.

<ParamField path="event" type="T" required>
  The event to emit.
</ParamField>

### off

```python theme={null}
def off(self, event: 'T', callback: 'Callable[..., Any]') -> 'None'
```

Remove a previously registered handler for an event.

If the handler is not registered for the event, the call is a no-op.

<ParamField path="event" type="T" required>
  The event the handler was registered for.
</ParamField>

<ParamField path="callback" type="Callable[..., Any]" required>
  The handler to remove.
</ParamField>

### on

```python theme={null}
def on(self, event: 'T', callback: 'Callable[..., Any] | None' = None) -> 'Callable[..., Any]'
```

Register a handler for an event.

Can be used directly by passing a callback, or as a decorator when
`callback` is omitted.

<ParamField path="event" type="T" required>
  The event to listen for.
</ParamField>

<ParamField path="callback" type="Callable[..., Any] | None">
  The handler to invoke when the event is emitted. If `None`, a decorator is returned that registers the decorated function.
</ParamField>

<ResponseField name="returns" type="Callable[..., Any]">
  The registered callback when `callback` is provided, otherwise a decorator that registers and returns the function it wraps.
</ResponseField>

### on\_stt\_transcript

```python theme={null}
def on_stt_transcript(self, callback: 'Callable[[STTResponse], Awaitable[None]]') -> 'None'
```

Register the coroutine invoked when a transcription event is produced.

<ParamField path="callback" type="Callable[[STTResponse], Awaitable[None]]" required>
  An async callable that receives each `STTResponse`.
</ParamField>

### process\_audio

```python theme={null}
def process_audio(self, audio_frames: 'bytes', language: 'Optional[str]' = None, **kwargs: 'Any') -> 'None'
```

Process a chunk of audio for transcription.

Implementations should consume the audio frames and emit transcription
results through the registered transcript callback.

<ParamField path="audio_frames" type="bytes" required>
  Raw audio bytes to transcribe.
</ParamField>

<ParamField path="language" type="Optional[str]">
  Optional language code to guide recognition.
</ParamField>

### stream\_transcribe

```python theme={null}
def stream_transcribe(self, audio_stream: 'AsyncIterator[bytes]', **kwargs: 'Any') -> 'AsyncIterator[STTResponse]'
```

Transcribe a continuous audio stream.

<ParamField path="audio_stream" type="AsyncIterator[bytes]" required>
  An async iterator yielding raw audio byte chunks.
</ParamField>

<ResponseField name="returns" type="AsyncIterator[STTResponse]">
  STTResponse: Transcription events produced as audio is consumed.
</ResponseField>