Google's Gemini 3.5 Live Translate Brings Real-Time Speech Translation to 70+ Languages

Real-time voice translation has been a demo-reel promise for years. You've seen the concept on stage, in sci-fi films, in product pitches. What's actually shipped has always lagged: clunky turn-based systems that wait for you to finish a sentence, then pause, then spit out robotic audio. Gemini 3.5 Live Translate is Google's attempt to close that gap for real, and it's available right now for developers to build on.

What actually changed

The Gemini Live API now supports low-latency, real-time speech-to-speech translation between 70+ languages using the gemini-3.5-live-translate-preview model. The key architectural shift is that the model handles real-time speech-to-speech translation as a continuous stream, not chunk-by-chunk. It stays just a few seconds behind the speaker throughout a session, rather than waiting for a full sentence to finish before translating.

The other big unlock is automatic language detection. It auto-detects language switches mid-sentence without any manual configuration. That matters a lot in practice: multilingual meetings, border crossings, customer support calls where the speaker might switch between languages mid-conversation no longer require you to pre-configure anything.

According to Google's model card, Gemini 3.5 Live Translate is based on Gemini 3 Pro, fine-tuned specifically for the translation pipeline. The model was evaluated across three dimensions: translation quality (using AutoMQM, an error-based metric that categorizes translation mistakes), latency, and speech naturalness.

The API surface is narrow by design

This is not a general-purpose multilingual assistant. The docs are explicit about it: text input is not supported in translation mode, and the model drops tool use and system instructions. For developers, the translation API call is a constrained surface -- you cannot send text, you cannot use the broader Gemini tool ecosystem, and you cannot inject system prompts.

The audio contract is equally specific. You send raw 16-bit PCM audio at 16kHz mono, in 100ms chunks. You get back 24kHz PCM audio. The config is minimal: set a target_language_code (BCP-47 format), and optionally toggle echo_target_language to control whether the model echoes back audio that's already in the target language. Here's the minimal Python setup:

from google import genai
from google.genai import types
client = genai.Client()
config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    input_audio_transcription=types.AudioTranscriptionConfig(),
    output_audio_transcription=types.AudioTranscriptionConfig(),
    translation_config=types.TranslationConfig(
        target_language_code="es",
        echo_target_language=True
    )
)
async with client.aio.live.connect(
    model="gemini-3.5-live-translate-preview",
    config=config
) as session:
    # stream 16kHz PCM audio in, receive 24kHz translated audio out
    ...

The API also supports optional transcripts for both input and output audio, which is useful for logging, accessibility, or displaying subtitles alongside the translated speech.

Where it works well, and where it doesn't

Gemini 3.5 Live Translate performs best with high-traffic languages: English, Spanish, Chinese, Japanese, Korean, and Vietnamese. Google has been transparent about the limitations in their official model card:

• Voices can be inconsistent, and voices may shift after long pauses, change gender, or get stuck on one voice during rapid multi-speaker sessions.
• Language detection can struggle with non-native accents, similar languages, or rapid language switches.
• The model is designed to filter out background noise, but not all background audio may be ignored.
• Google has not released benchmark scores, language-pair results, latency figures, or comparative performance data, limiting independent assessment of the model's performance.

The voice consistency issue is worth flagging for production use. In long sessions or rapid back-and-forth between multiple speakers, the synthesized voice can drift. This is a known limitation, not a bug, and it's something to design around rather than ignore.

Real-world use cases already in motion

The use cases this unlocks are genuinely new territory for API-level tooling:

• Live multilingual calls: one speaker, multiple listeners each hearing their own language simultaneously
• Real-time dubbing: stream a broadcast or lecture and output translated audio with preserved pacing and tone
• In-person translation: the Google Translate app's new listening mode lets you hold your phone to your ear like a call and hear translations directly through the earpiece
• Enterprise meetings: Google Meet is entering private preview for selected Google Workspace customers, expanding from the previous limit of just five languages to 70+, and enabling conversations across 2000+ language combinations in one meeting.

Google's partners at Grab are already testing the model to enable multilingual communication in near real-time between drivers and travelers at pickups. These users make over 10 million voice calls per month through Grab.

Developer platforms like Agora, Fishjam, LiveKit, Pipecat, and Vision Agents have integrated the Gemini Live API, handling the complex real-time media streaming infrastructure so developers can focus on the user experience.

How to get started

The model is available now in public preview via the Gemini Live API and Google AI Studio. The model ID is gemini-3.5-live-translate-preview. Billing is based on total input and output audio token consumption, calculated at a rate of 25 tokens per second of audio, equating to an effective price of approximately $0.0368 per minute.

For client-side apps where you don't want to expose your API key, the API supports ephemeral tokens via the v1alpha endpoint. You can lock the translationConfig server-side so clients can't tamper with the target language, or unlock it to let users pick their own. Google has also published example code and a LiveKit demo in the Gemini Cookbook.

One safety note: all audio generated by the model is watermarked with SynthID, Google's imperceptible audio watermark, so AI-generated translated speech remains detectable. That's a meaningful detail for anyone building broadcast or public-facing translation tools.

The field assumption that needs updating: real-time translation has historically been a specialized, expensive, infrastructure-heavy problem. It's now a three-line config object on top of an API you might already be using. The barrier to building a multilingual voice product just dropped significantly.