What NVIDIA Parakeet 1.1B RNNT Multilingual is
NVIDIA Parakeet 1.1B RNNT Multilingual is an automatic speech recognition (ASR) model. ASR systems convert spoken audio into written text; they do not generate conversational answers, translate text, synthesize speech, or create images. This model is intended for transcription workloads where the audio itself is the input and the primary result is text.
The model contains approximately 1.1 billion parameters and belongs to NVIDIA's Parakeet-RNNT family. Its architecture is based on FastConformer and a recurrent neural network transducer (RNNT). In practical terms, this design is aimed at recognizing speech incrementally, which supports live or streaming transcription rather than requiring an entire recording to be uploaded before processing begins.
NVIDIA says the model was trained on more than 90,000 hours of speech. That is a provider claim about its training and should not be interpreted as a guarantee of accuracy for every accent, recording environment, speaker, or language.
Languages, language detection, and transcript output
The model supports 25 documented languages and locale variants. The listed coverage includes English, Spanish, German, French, Italian, Arabic, Japanese, Korean, Portuguese, Russian, Hindi, Hebrew, Dutch, Danish, Norwegian Bokmål, Norwegian Nynorsk, Czech, Polish, Swedish, Thai, and Turkish. Regional variants include codes such as en-US, en-GB, es-US, es-ES, fr-FR, fr-CA, pt-BR, and pt-PT.
Parakeet uses a universal tokenizer that combines language-specific tokenizers into a shared vocabulary. This allows one multilingual model to handle the supported language set instead of requiring a completely separate model for each language. The model's default NIM profile can automatically detect the spoken language. A prompt profile allows the client to supply a language code, which may improve recognition in supported situations but requires the application to know or choose the language in advance.
The documented transcript output is case-sensitive text. It can include punctuation, spaces, and apostrophes. NVIDIA's NIM implementation supports automatic punctuation and capitalization, although punctuation may need to be enabled explicitly in some deployment configurations. The model does not produce audio, video, images, embeddings, or general-purpose structured responses.
NVIDIA NIM and Riva deployment
Parakeet 1.1B RNNT Multilingual is available as a downloadable NVIDIA NIM and Riva speech model. NIM provides a containerized deployment path for supported NVIDIA GPUs, while Riva supplies speech AI services and interfaces used for recognition applications. The NIM deployment exposes speech recognition through Riva gRPC APIs.
This is an infrastructure-oriented model rather than a typical hosted text-generation endpoint. The supplied research does not verify a fixed per-minute, per-request, or subscription price for the model. NVIDIA describes it as downloadable through NIM, with access and service costs depending on the applicable NVIDIA terms, infrastructure, and usage arrangement. Organizations should therefore budget for compatible GPU capacity and deployment operations instead of assuming that the model has a simple public API price.
The documented NIM profiles include a default profile with automatic language detection, a prompt profile for client-specified language prompting, and an Indic profile optimized for Indic-language use. The Indic profile includes Bengali, Hindi, and Tamil support. The supplied documentation notes that NIM deployment may require approximately 50 GB of GPU memory for the documented profiles. Exact resource requirements can vary by release, profile, batching configuration, and deployment environment.
Streaming behavior and performance trade-offs
Streaming is one of the model's most important practical characteristics. A streaming ASR system can return partial or continuing transcription while a person is still speaking, which is useful for live captions, voice interfaces, call monitoring, and interactive applications. It is a different operating mode from processing a completed audio file after recording has ended.
The 1.1-billion-parameter size places Parakeet above very lightweight speech recognition choices in resource requirements. Its larger footprint may provide a useful quality trade-off for multilingual production workloads, but it also increases the hardware and operational cost compared with smaller models. The supplied research does not provide a universal latency or word-error-rate benchmark, so claims about accuracy or speed should be evaluated against the target languages, audio conditions, GPU, and deployment profile.
An editorial assessment rates the model's speed at 8 out of 10. This is an editorial score based on its streaming support and optimized NIM deployment, not an NVIDIA-published benchmark. It should not be read as a measured latency guarantee.
Main strengths
- Broad multilingual coverage: one model supports 25 documented languages and locale variants.
- Streaming transcription: suitable for applications that need results while audio is arriving.
- Automatic language detection: the default profile can identify the spoken language without requiring the client to provide a language code.
- Readable transcript formatting: output can include capitalization, punctuation, spaces, and apostrophes.
- Downloadable deployment: organizations can deploy through NVIDIA NIM and Riva on supported NVIDIA GPU infrastructure.
- Deployment profiles: default, prompt, and Indic configurations support different language-selection and optimization needs.
Limitations and unsupported capabilities
Parakeet is specialized for speech recognition. It is not a reasoning model, coding model, conversational language model, translator, text-to-speech system, or media-generation model. It accepts audio rather than ordinary text as its primary input and returns transcription text rather than spoken audio.
The supplied model information does not specify a context-window length or maximum output-token limit. Those fields are therefore not meaningful verified specifications for this model in the same way they are for a text-generation model. Transcript length will depend on the duration and handling of the supplied audio and the deployment configuration.
Riva 2.19 release documentation states that the multilingual RNNT model does not support word boosting or inverse text normalization (ITN). Word boosting is commonly used to give selected words or names extra recognition priority. ITN converts spoken forms into normalized written forms, such as formatting certain numbers or dates. Applications that require either feature may need additional post-processing or a different speech recognition option.
Deployment also has a substantial infrastructure requirement. A compatible NVIDIA GPU is required, and the documented NIM profiles may need approximately 50 GB of GPU memory. This can make the model unsuitable for small local systems, low-cost CPU-only deployments, or applications where minimizing infrastructure is more important than multilingual streaming quality.
Best-fit use cases
Parakeet 1.1B RNNT Multilingual is a strong candidate for multilingual speech-to-text services that need ongoing transcription and control over deployment. Appropriate examples include:
- live captions for meetings, events, and broadcasts;
- multilingual voice agents that need an audio-to-text front end;
- customer-support and contact-center transcription;
- meeting, interview, and media transcription;
- call analytics and searchable spoken-content archives;
- production applications that need language detection and streaming recognition on NVIDIA hardware.
For example, a support application could send incoming call audio to a streaming Riva interface, allow the default profile to identify the language, and display the resulting case-sensitive transcript to an agent. A controlled deployment serving a known language could instead use the prompt profile and provide the language code explicitly.
When to choose this model
Choose Parakeet 1.1B RNNT Multilingual when the main requirement is multilingual streaming transcription and the organization can operate compatible NVIDIA GPU infrastructure. It is particularly relevant when automatic language detection, downloadable deployment, and integration with NIM or Riva matter more than a minimal hardware footprint.
A smaller ASR model may be more appropriate when the application has strict latency, memory, or cost limits and only needs a narrower language set. A hosted speech API may be preferable when the team does not want to manage GPU containers, model serving, or capacity planning. A system with built-in word boosting or inverse text normalization may be a better fit for terminology-heavy call centers, names, numbers, and structured business records.
Parakeet should also not be selected simply because it is a 1.1-billion-parameter model. Parameter count alone does not establish transcription accuracy or total cost. Test representative recordings for every target language, microphone condition, accent, background-noise level, and speaking style before production deployment. The supplied research does not provide a fixed public price or a universal accuracy benchmark, so those evaluations must be performed in the intended environment.
Verified specifications at a glance
| Specification | Details |
|---|---|
| Provider | NVIDIA |
| Model family | Parakeet-RNNT |
| Model type | Automatic speech recognition |
| Parameters | Approximately 1.1 billion |
| Architecture | FastConformer-based RNNT |
| Audio input | Supported |
| Text output | Supported; case-sensitive transcription with punctuation support |
| Streaming | Supported |
| Languages | 25 documented languages and locale variants |
| Deployment | NVIDIA NIM and NVIDIA Riva |
| Public model price | No fixed price verified |
| Context and maximum output tokens | Not specified for this ASR model |
Overall, NVIDIA Parakeet 1.1B RNNT Multilingual is best understood as a deployable multilingual speech-recognition component. Its value comes from combining streaming recognition, broad documented language coverage, automatic language detection, and NVIDIA-managed deployment paths. Its main trade-offs are GPU requirements, the absence of documented public model pricing, and limitations such as no word boosting or inverse text normalization in the documented Riva implementation.

