Best Speech-to-Text APIs in 2026

const { createClient } = require("@deepgram/sdk");
const deepgram = createClient(process.env.DEEPGRAM_API_KEY);

const { result } = await deepgram.listen.prerecorded.transcribeUrl(
  { url: "https://example.com/audio.mp3" },
  { model: "nova-3", smart_format: true, diarize: true }
);
console.log(result.results.channels[0].alternatives[0].transcript);

from elevenlabs.client import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")
with open("interview.mp3", "rb") as audio:
    result = client.speech_to_text.convert(
        model_id="scribe_v2",
        file=audio,
        diarize=True,
        timestamps_granularity="word",
    )
print(result.text)

import whisper

model = whisper.load_model("large-v3")
result = model.transcribe(
    "interview.mp3",
    language=None,          # auto-detect
    word_timestamps=True
)
for segment in result["segments"]:
    print(f"[{segment['start']:.1f}s] {segment['text']}")

import assemblyai as aai

aai.settings.api_key = "YOUR_API_KEY"
transcriber = aai.Transcriber()

config = aai.TranscriptionConfig(
    speaker_labels=True,
    auto_highlights=True,
    entity_detection=True,
    sentiment_analysis=True
)
transcript = transcriber.transcribe("meeting.mp3", config=config)
for utterance in transcript.utterances:
    print(f"Speaker {utterance.speaker}: {utterance.text}")

from google.cloud import speech_v2

client = speech_v2.SpeechClient()
config = speech_v2.RecognitionConfig(
    auto_decoding_config=speech_v2.AutoDetectDecodingConfig(),
    language_codes=["en-US"],
    model="chirp_2",
    features=speech_v2.RecognitionFeatures(
        enable_automatic_punctuation=True
    ),
)
with open("audio.wav", "rb") as f:
    response = client.recognize(
        config=config, content=f.read(),
        recognizer="projects/my-project/locations/global/recognizers/_"
    )
print(response.results[0].alternatives[0].transcript)

import boto3

transcribe = boto3.client("transcribe")
transcribe.start_transcription_job(
    TranscriptionJobName="my-job",
    Media={"MediaFileUri": "s3://my-bucket/audio.mp3"},
    MediaFormat="mp3",
    LanguageCode="en-US",
    Settings={
        "ShowSpeakerLabels": True,
        "MaxSpeakerLabels": 5,
        "ShowAlternatives": True,
        "MaxAlternatives": 3,
    },
    OutputBucketName="my-output-bucket",
)

from rev_ai import apiclient

client = apiclient.RevAiAPIClient("YOUR_ACCESS_TOKEN")
job = client.submit_job_url(
    media_url="https://example.com/interview.mp3",
    metadata="legal-deposition-2026",
    skip_diarization=False,
    custom_vocabularies=[{
        "phrases": ["habeas corpus", "amicus curiae"]
    }]
)
# Poll for completion
transcript = client.get_transcript_text(job.id)
print(transcript)

import speechmatics

sm_client = speechmatics.client.WebsocketClient(
    speechmatics.models.ConnectionSettings(
        url="wss://eu2.rt.speechmatics.com/v2",
        auth_token="YOUR_API_KEY",
    )
)
conf = speechmatics.models.TranscriptionConfig(
    language="en",
    enable_partials=True,
    operating_point="enhanced",
)
sm_client.add_event_handler(
    event_name=speechmatics.models.ServerMessageType.AddTranscript,
    event_handler=lambda msg: print(msg["metadata"]["transcript"]),
)
await sm_client.run(audio_stream, conf)

import azure.cognitiveservices.speech as speechsdk

speech_config = speechsdk.SpeechConfig(
    subscription="YOUR_KEY",
    region="eastus"
)
speech_config.speech_recognition_language = "en-US"

audio_config = speechsdk.audio.AudioConfig(filename="meeting.wav")
recognizer = speechsdk.SpeechRecognizer(
    speech_config=speech_config,
    audio_config=audio_config
)
result = recognizer.recognize_once()
print(result.text)

const response = await fetch("https://api.gladia.io/v2/transcription", {
  method: "POST",
  headers: {
    "x-gladia-key": process.env.GLADIA_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    audio_url: "https://example.com/audio.mp3",
    diarization: true,
    language_behaviour: "automatic multiple languages",
  }),
});
const { id } = await response.json();
// Poll for result at /v2/transcription/{id}

import pvleopard

leopard = pvleopard.create(
    access_key="YOUR_ACCESS_KEY",
    model_path="leopard_params.pv"
)
transcript, words = leopard.process_file("recording.wav")
print(transcript)
for word in words:
    print(f"{word.word} [{word.start_sec:.1f}s - {word.end_sec:.1f}s] "
          f"confidence: {word.confidence:.2f}")
leopard.delete()