The standard interface for ASR inference

Standard ASR defines a vendor-neutral protocol between applications and speech-recognition engines. Applications integrate speech-to-text once and gain every compliant engine; engines implement it once and reach every application. Think USB-C for ASR.

Get started Read the specificationpip install "standard-asr[audio]"

Pre-releaseBreaking changes may occur before v1.0.0. Try it out and tell us what you think.

Implement once. Interoperate with everything.

Like the OpenAI Chat Completion API did for LLMs: once a protocol is the common language, both sides of it stop writing adapters.

the application side

from standard_asr import discover_models

registry = discover_models()
engine = registry.create("faster-whisper/large-v3")

result = engine.transcribe("meeting.wav")
print(result.text)

# Switching engines is a one-line change:
engine = registry.create("std-openai/gpt-4o-transcribe")

the engine side

from standard_asr.engine import EngineBase, PreparedAudio

class MyEngine(EngineBase):
    # Declare properties, capabilities, and a typed config...

    def _transcribe(self, prepared: PreparedAudio, params):
        audio = prepared.array  # 16 kHz float32 mono, per your Properties
        return my_model_infer(audio)

# One interface -> CLI, HTTP/WebSocket server, and a
# compliance test suite, for free.

One event protocol for every streaming engine

Real-time ASR is the most fragmented part of the ecosystem: some engines rewrite interim results, some never revise a token, some merge segments after a second pass. Standard ASR unifies all of it under six event types with explicit stability guarantees — designed against a survey of 30+ real engine APIs.

Interim text may change with every event until the segment goes final.

Session events

Press play to start the session.

Your application's view

Events on the left; the reduced transcript state on the right.

The right panel runs the documented core reduce — the same logic as reduce_event in the streaming guide.

The plumbing, standardized

Audio negotiation

Hand over a path, bytes, an array, or a URL. The standard layer negotiates the form your engine accepts, deterministically.

Capability discovery

engine.supports("batch.word_timestamps") answers before you call. Fail-closed: an absent declaration means unsupported.

Structured diagnostics

Lossy conversions and degraded paths surface as structured diagnostics. Silent wrong results are the cardinal sin.

Compliance suite

standard-asr compliance run verifies an implementation against the specification, one command.

Reference server

Expose any compliant engine over HTTP and WebSocket, so non-Python applications get the same capabilities.

Plugin discovery

Entry-point based: install a plugin and it appears in discover_models(). Zero application-side configuration.