Unified speech-to-text API: switch providers by changing one model ID

A unified speech-to-text API gives you one endpoint, one API key and one request shape for transcription models from several providers. With Speechall, you send audio to POST https://api.speechall.com/v1/transcribe and choose the provider and model with a single model value such as openai.whisper-1, deepgram.nova-3 or assemblyai.universal-3-5-pro.

This guide shows which providers are available, how switching works in code, and what does and does not stay the same when you change models.

Providers and model IDs

Every model has an ID in provider.model form. The provider prefix tells you which speech-to-text service runs the transcription. The table below lists the providers in the Speechall catalog in November 2026, with one or more example IDs each. Models are added and retired over time, so treat the model catalog or the models endpoint as the current list.

List the current models and their capabilities with your API key:

curl "https://api.speechall.com/v1/speech-to-text-models" 
  -H "Authorization: Bearer $SPEECHALL_API_KEY"

Use the returned id exactly. A provider’s own model name, such as whisper-1 or nova-3, is not a Speechall model ID until it has the provider prefix.

Switch providers with the same request

The direct upload endpoint takes raw audio bytes in the request body and the options as query parameters. To try a different provider, change the model value and send the same file again. See Getting Started for API keys and credits before running these.

# OpenAI Whisper
curl -X POST "https://api.speechall.com/v1/transcribe?model=openai.whisper-1&language=en&output_format=json" 
  -H "Authorization: Bearer $SPEECHALL_API_KEY" 
  -H "Content-Type: audio/wav" 
  --data-binary @meeting.wav

# Deepgram Nova-3: only the model value changes
curl -X POST "https://api.speechall.com/v1/transcribe?model=deepgram.nova-3&language=en&output_format=json" 
  -H "Authorization: Bearer $SPEECHALL_API_KEY" 
  -H "Content-Type: audio/wav" 
  --data-binary @meeting.wav

# AssemblyAI Universal-3.5 Pro
curl -X POST "https://api.speechall.com/v1/transcribe?model=assemblyai.universal-3-5-pro&language=en&output_format=json" 
  -H "Authorization: Bearer $SPEECHALL_API_KEY" 
  -H "Content-Type: audio/wav" 
  --data-binary @meeting.wav

Each request is billed separately against your prepaid credits at that model’s rate, so a three-model comparison costs three transcriptions. Per-model prices are on each model’s page in the catalog.

The same pattern with the official Python SDK (pip install speechall), transcribing one file with three models:

import os
from speechall import SpeechallApi

client = SpeechallApi(token=os.environ["SPEECHALL_API_KEY"])

with open("meeting.wav", "rb") as f:
    audio = f.read()

for model in ["openai.whisper-1", "deepgram.nova-3", "assemblyai.universal-3-5-pro"]:
    result = client.speech_to_text.transcribe(model=model, request=audio)
    print(model, result.text)

And with the TypeScript SDK (npm install @speechall/sdk) for audio at a URL Speechall’s servers can fetch:

import { SpeechallClient } from '@speechall/sdk';

const client = new SpeechallClient({ token: process.env.SPEECHALL_API_KEY! });

for (const model of ['openai.whisper-1', 'deepgram.nova-3', 'assemblyai.universal-3-5-pro']) {
    const result = await client.speechToText.transcribeRemote({
        model,
        file_url: 'https://example.com/meeting.mp3'
    });
    console.log(model, result.text);
}

You can also compare models on the same recording without writing code in the playground, or from a terminal with the Speechall CLI.

Already using OpenAI’s Whisper API

If your code calls OpenAI’s transcription endpoint through the OpenAI SDK, you can keep that code. Point the SDK’s base URL at Speechall’s OpenAI-compatible endpoint, use a Speechall API key, and use a Speechall model ID:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["SPEECHALL_API_KEY"],
    base_url="https://api.speechall.com/v1/openai-compatible",
)

with open("meeting.wav", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="openai.whisper-1",  # or "deepgram.nova-3", "elevenlabs.scribe-v1", ...
        file=audio,
        response_format="text",
    )

The compatible endpoint accepts the OpenAI audio fields (file, model, language, prompt, response_format, temperature, timestamp_granularities[]). Whether a given field has an effect depends on the model you pick. The speech-to-text guide covers the compatibility details, and Migrating the OpenAI transcription API to Speechall has a step-by-step checklist.

Structure your code to avoid lock-in

Switching is only cheap if the provider choice lives in one place. A few habits help:

• Keep the model ID in configuration, such as an environment variable, instead of hard-coding it at each call site. Changing providers then means changing one value.
• Wrap transcription in one function that takes audio and returns the fields your application uses (usually text, and segments or words if you need timing). The rest of your code depends on that function, not on a provider.
• Read only the documented response fields. If you start depending on provider-specific metadata, note it, because it may not exist for another model.
• Keep a short test set of your own recordings and re-run it when you consider a new model. Results depend on your audio, languages and vocabulary, so a model that suits one workload may not suit another.

What stays the same across providers

• Endpoints. POST /v1/transcribe for raw uploads, POST /v1/transcribe-remote for audio URLs, /v1/openai-compatible/audio/transcriptions for OpenAI SDK clients, and wss://api.speechall.com/v1/transcribe for streaming.
• Authentication. One Speechall API key in Authorization: Bearer ..., whichever provider runs the model. You do not need an account or key with each provider.
• Request shape. model, language and output_format, plus the shared optional parameters (diarization, speakers_expected, custom_vocabulary, initial_prompt, temperature, punctuation, ruleset_id).
• Response shape. output_format=text returns plain text, json_text returns { "id", "text" }, and json returns a detailed object with text, language and timed segments and words where the model provides them. See the TranscriptionDetailed schema in the API reference.
• Billing. Usage from every provider is deducted from one prepaid credit balance. Check fees and your balance in Billing.
• Text replacement rules. A ruleset created with /replacement-rulesets is applied to the final transcript text through ruleset_id, whichever model produced it.

What does not carry over

A shared request shape does not mean every model supports every option. Check these before you switch:

• Feature support differs per model. Diarization, word timestamps, language detection, custom vocabulary and prompts are supported by some models and not others. For example, the November 2026 catalog lists deepgram.nova-3 and assemblyai.universal-3-5-pro with diarization and openai.whisper-1 without it. Sending a parameter does not guarantee that the selected model uses it.
• Subtitle formats differ per model. In the same catalog, openai.whisper-1 lists both SRT and VTT, deepgram.nova-3 lists VTT only, and assemblyai.universal-3-5-pro lists neither. Check supports_srt and supports_vtt before requesting output_format=srt or vtt.
• Languages differ per model. Check each model’s supported_languages. The language parameter defaults to en, and auto works only on models that support language detection.
• Limits differ per model. File size and duration limits come from the model’s max_file_size_bytes and max_duration_seconds where the catalog lists them. A missing value does not mean there is no limit.
• Streaming is available on some models only. Only models with streamable: true accept live audio over WebSocket, and the message semantics are not identical across them. The published schema does not define a portable interim/final flag, so read the streaming guide before reusing streaming code with a new model.
• Output differs. Punctuation, casing, number formatting, segment boundaries and speaker labels vary between models, and so does the transcript itself. Code that parses transcript text may need adjusting.
• Provider-specific options outside the schema are not passed through. If you rely on a provider parameter that the API reference does not list, assume it is not available through Speechall.
• Prices differ per model. Each model has its own per-second rate, and streaming can have a separate rate. Compare them on the model pages.

The model catalog shows these capabilities for each model, and the /speech-to-text-models endpoint returns them as JSON so your code can check them at runtime.

When going direct to one provider is the better choice

A gateway is not the right fit for every project. Calling a provider’s own API directly is likely better when:

• You have negotiated pricing, volume commitments or data processing terms with one provider. Those agreements apply to your account with that provider, not to requests made through Speechall.
• You need a provider feature that Speechall does not expose, such as a parameter, endpoint, streaming event or model that is missing from the API reference and the catalog.
• You have already settled on one provider and do not expect to compare or switch. An extra layer adds a dependency without much benefit.
• You need that provider’s support, SLA or compliance commitments directly. Speechall’s documentation does not make those commitments on a provider’s behalf.

If you are still choosing, or want to keep the option to switch later, a unified API lets you test several models on your own audio first and move between them with a configuration change.

Next steps

• Getting Started: create an API key, add credits and make your first request.
• Speech-to-Text: upload methods, OpenAI compatibility, formats and limits.
• Speech-to-Text Streaming: live audio over WebSocket.
• Model catalog: current models, capabilities and prices.
• Speechall CLI: transcribe files from the terminal with any model.
• Billing: prepaid credits and the current purchase quote.