
Deploy Parakeet | (Just Updated) Speech-to-Text API, OpenAI-Compatible Transcription, API Key Pre-Set
NVIDIA Parakeet speech-to-text API, OpenAI-compatible transcription, CPU
parakeet
Just deployed
Deploy and Host Parakeet Speech-to-Text on Railway
NVIDIA Parakeet-TDT-0.6B-v3 is an open speech recognition model that transcribes 25 European languages, with punctuation and capitalization, from one 600-million-parameter network. This template serves it as an OpenAI-compatible transcription API: send an audio or video file to /v1/audio/transcriptions and get back text, segments, word timestamps, SRT or WebVTT. The int8 weights are already inside the image, a bearer key is generated for you at deploy, and everything runs on CPU.
About Hosting Parakeet
This template runs the int8 ONNX export of NVIDIA Parakeet-TDT-0.6B-v3 through onnx-asr 0.12.0 behind a small FastAPI server. POST /v1/audio/transcriptions takes a multipart file (mp3, m4a, wav, ogg, flac, webm, mp4 or anything else ffmpeg reads) and the same form fields the OpenAI SDK sends, so an OpenAI client pointed at your Railway URL works with only the base URL and key changed. response_format can be json, text, verbose_json (segments plus word timestamps), srt or vtt. The model detects the language itself, so language is accepted and ignored. Audio longer than 24 seconds is cut at silences with Silero VAD, so a long recording is transcribed in one call.
The weights are baked into the image, so the first request is answered from disk and no model download hides inside a request that Railway's edge would abandon after five minutes. The service sizes its ONNX Runtime thread pool from the container's own CPU quota instead of the host's core count, and handles one request at a time so memory stays bounded.
Measured on Railway, 8 vCPU: a 5.9 second clip took 0.29 s, 71.5 seconds of audio took 2.0 s, and a 29.8 minute recording (1786.6 s of audio, 57 MB upload, VAD cut and word timestamps on) took 49.9 s to process, 51.5 s end to end. That is about 36 seconds of audio per second of CPU time, so a request stays far inside the five minute edge limit; MAX_AUDIO_SECONDS defaults to 1800 and the upload cap to 100 MB. Container memory read 2.33 GB at peak after the 29.8 minute request (Railway MEMORY_USAGE_GB metric). The model loads and warms in about 1.3 s after the container starts.
Agent contract
- Public URL:
https://RAILWAY_PUBLIC_DOMAIN(the generated domain of theparakeetservice) - Private URL:
http://parakeet.railway.internal:8080 - Credentials: the
API_KEYvariable of theparakeetservice - Auth: send
Authorization: Bearer $API_KEYon every route exceptGET /health; a call without the key or with a wrong one answers401 - Health:
GET /healthreturns 200 once the model is loaded (503 while it loads)
# needs: RAILWAY_PUBLIC_DOMAIN, API_KEY (a variable of the parakeet service); also curl, mktemp.
R="https://$RAILWAY_PUBLIC_DOMAIN"
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/health")" = 200 ]; do n=$((n+1)); [ "$n" -le 60 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/health"
# a 5.9 s LibriSpeech clip (CC BY 4.0) that says "mister Quilter is the apostle of the middle classes"
F=$(mktemp --suffix=.wav); curl -sL -o "$F" https://raw.githubusercontent.com/bon5co/parakeet-railway/main/sample.wav
curl -s -o /dev/null -w "write without key: %{http_code}\n" -X POST "$R/v1/audio/transcriptions" -F file=@"$F"
curl -s -o /dev/null -w "write wrong key: %{http_code}\n" -X POST "$R/v1/audio/transcriptions" -H "Authorization: Bearer not-the-key" -F file=@"$F"
curl -s -X POST "$R/v1/audio/transcriptions" -H "Authorization: Bearer $API_KEY" -F file=@"$F" -F model=parakeet-tdt-0.6b-v3 | grep -o '"text":"[^"]*"' | sed 's/"//g; s/:/: /'
rm -f "$F"
A fresh deploy prints health: 200, write without key: 401, write wrong key: 401 and text: mister Quilter is the apostle of the middle classes, and we are glad to welcome his gospel. The snippet downloads its own sample clip, so it needs no file of yours. To transcribe your own recording with word timestamps, or with the OpenAI Python SDK:
curl -X POST "https://$RAILWAY_PUBLIC_DOMAIN/v1/audio/transcriptions" \
-H "Authorization: Bearer $API_KEY" -F file=@meeting.mp3 \
-F response_format=verbose_json -F "timestamp_granularities[]=word"
from openai import OpenAI
client = OpenAI(base_url="https://RAILWAY_PUBLIC_DOMAIN/v1", api_key="API_KEY value")
print(client.audio.transcriptions.create(model="parakeet-tdt-0.6b-v3", file=open("meeting.mp3", "rb")).text)
GET /v1/models lists the model. A file ffmpeg cannot read answers 422, a recording longer than MAX_AUDIO_SECONDS answers 413.
Why Deploy Parakeet Speech-to-Text on Railway?
Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.
By deploying Parakeet on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.
- Audio stays on your infrastructure — calls, meetings and interviews are transcribed by your own container, not sent to a third-party speech API.
- Drop-in for the OpenAI SDK — change the base URL and key and existing transcription code keeps working.
- Fast on plain CPU — about 36 seconds of audio per second on 8 vCPU, measured, with no GPU bill and no per-minute fee.
- Private by default — a generated bearer key guards every route but the health check, and the container refuses to start without one.
Common Use Cases
- Meeting and call transcripts — send a recording, get back text with segment and word timestamps for search and summaries.
- Subtitles — request
srtorvttfor a video file and attach the result to the video. - AI agent tool — give an LLM agent a speech-to-text endpoint it can call with one authenticated request, for voice notes and voicemail.
Dependencies for Parakeet Hosting
- A service with 4 GB of RAM (measured 2.33 GB after a 29.8 minute request). Free and Trial plans cannot run it.
- No volume: the service keeps no state and the model is in the image.
Deployment Dependencies
- nvidia/parakeet-tdt-0.6b-v3 — the model, licensed CC-BY-4.0
- istupakov/onnx-asr — the ONNX runtime wrapper, MIT, version 0.12.0
- bon5co/parakeet-railway — the Railway wrapper image this template deploys, Apache-2.0
- Weights licence: the Hugging Face model card of
nvidia/parakeet-tdt-0.6b-v3reads "GOVERNING TERMS: Use of this model is governed by the CC-BY-4.0 license" and "Released under a permissive CC BY 4.0 license", and the ONNX exportistupakov/parakeet-tdt-0.6b-v3-onnxcarrieslicense:cc-by-4.0. CC BY 4.0 allows commercial use and requires attribution. Attribution: NVIDIA Parakeet-TDT-0.6B-v3, copyright NVIDIA, licensed CC BY 4.0, ONNX conversion by istupakov.
Template Content

