You’ve probably used Gemini to analyze hours of video, summarize podcasts, or answer questions from recorded meetings (if you didn't you should, it's extremely useful!). But when all you need is a clean, hyper-accurate, and structured transcript from audio, spinning up a huge reasoning model with complicated prompts often feels like using a sledgehammer to crack a nut.
Enter Gemini 3.5 Transcribe ( gemini-3.5-transcribe ).
It's Google's dedicated speech-to-text model built on Gemini's audio understanding core, optimized specifically for fast, accurate, and cost-effective transcription. Whether you want an exact court-reporter transcript with millisecond timestamps, or a reading-optimized summary that removes all your awkward "ums" and "uhs" , this model handles it natively with zero prompt gymnastics.
🚀 Hands-on first: If you want to jump straight into running the code yourself, open the interactive Gemini Transcribe Colab notebook ：https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_transcribe.ipynb! It's ready to run so you can dirrectly experience how the model work. Prefer a visual UI with zero coding? You can also test speech recognition directly in Google AI Studio ：https://aistudio.google.com/prompts/new_chat?model=gemini-3.5-transcribe.
Here's what you'll find in this guide:
Before looking at the code, let's get the mental model straight. You might wonder: "Can't I just upload an MP3 to Gemini 3.7 and say 'Transcribe this'?"
You can, but here is why gemini-3.5-transcribe is different:
Pro tip: If you need to ask questions about what happened in an audio file ("What was the action item for Alice?"), use a multimodal model like Gemini 3.7. If you need the transcript itself , subtitles, or cleaned dictation notes, use Gemini Transcribe!
The Gemini 3.5 Transcribe model runs on the modern Google GenAI SDK ( google-genai v2.0+) using the Interactions API：https://ai.google.dev/gemini-api/docs/interactions-overview.
Make sure you have an API key from Google AI Studio：https://aistudio.google.com/app/apikey, set it as GEMINI_API_KEY , and let's look at how audio gets passed to the model:
Watch the demo video below to see the baseline transcription in action—handling natural speech and bilingual code-switching with ease:
When dealing with audio and video, you never want to inline raw audio bytes as base64 in your API requests—it blows up the payload size by 33%, easily hits network timeouts, and requires re-uploading the same bytes if you want to rerun a query.
The Files API：https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/File_API.ipynb solves this cleanly:
As you saw in the video above, Gemini Transcribe automatically identifies spoken languages out of the box and seamlessly handles code-switching (when someone mixes multiple languages in the same sentence—like switching between French and English mid-sentence, which happens to me all the time!).
However, if you know your audio is exclusively in a specific language or regional dialect, you can pass explicit BCP-47 language codes in transcription_config to bias recognition:
Note: Leaving language_codes=[] (or omitting it) enables full automatic detection across 85+ supported languages and locales：https://ai.google.dev/gemini-api/docs/transcribe#supported-languages. Check out the Audio Transcription Documentation：https://ai.google.dev/gemini-api/docs/transcribe for the complete list of language codes.
Every developer has suffered from an ASR model mangling proper names, confusing specialized libraries with everyday dictionary words (turning "ScaNN" into "scan" , or "Qdrant" into "quadrant" ), or inventing phonetically similar terms ( "Sitsi" instead of "CitC" , "Thiago" instead of "Tiago" ).
With custom_vocabulary , you can pass a list of up to 1,000 domain-specific terms that the model will bias towards:
Watch the side-by-side comparison video below to see how the model behaves with and without custom vocabulary biasing:
Notice how default speech recognition falls back to phonetic dictionary guesses ( Vernat , Scan , Quadrant , Syllium , Thiago , Sitsi , Spacey ). By contrast, supplying custom_vocabulary guarantees that names of team members, niche tools, internal infrastructure, and open-source libraries are transcribed with 100% precision.
Pro tip: Don't just put acronyms in your custom vocabulary. Add proper names of team members, internal service codenames, GitHub repo handles, product brand names, and niche industry terminology.
This is hands down my favorite capability of Gemini 3.5 Transcribe.
By default, speech-to-text models operate in verbatim mode: they write down everything , including every nervous stutter, throat clear, false start, and verbal tick.
When you're transcribing a speech rehearsal, interview, or voice memo, reading raw verbatim text is painful:
If you switch mode={"type": "smart"} , the model performs intelligent reading optimization:
Look at the cleaned result on that exact same rehearsal audio:
Watch the side-by-side comparison video below to see how the raw disfluencies are stripped while listening:
(If the video doesn't load, you can listen to rehearsing.wav directly：https://storage.googleapis.com/generativeai-downloads/audio/rehearsing.wav.)
Important caveat: Because Smart transcription uses language modeling to clean up disfluencies and structure the output, it might slightly rewrite, omit, or rephrase parts of what was said to make it sound natural and concise. If you are doing verbatim court reporting, medical transcription, or subtitle syncing where every exact syllable matters, stick with verbatim mode!
Also note that Smart mode is incompatible with word-level timestamps and speaker diarization (which require {"type": "verbatim"} ).
Need to know who spoke during a multi-person meeting or podcast? Enable diarization with diarization_mode="speaker" :
To extract each speaker turn cleanly, iterate through the step annotations:
Watch the demo video below where two colleagues debate pain au chocolat vs. chocolatine . Notice how the waveform line dynamically changes color (Cyan for Tiago, Orange for his colleague) as each speaker takes turns:
(Direct audio link: listen to pain_au_chocolat.wav：https://storage.googleapis.com/generativeai-downloads/audio/pain_au_chocolat.wav)
When you need exact synchronization—for example, to jump to specific points in a video, build interactive transcripts, or align text with waveforms—you can request word-level millisecond start and end offsets.
Configure timestamp_granularities=["word"] (and optionally combine it with diarization_mode="speaker" ):
Each recognized word comes back with its exact time offsets (and speaker turn) attached in the content annotations:
Having millisecond-level offsets for every individual word unlocks huge capabilities:
💡 Behind the scenes: That's actually what I did to make the demo videos above! The word timestamps provided the exact millisecond timing to align the subtitle cards, highlight the custom terms ( "oatmilk" ), and trigger the color switch of the waveform line from Cyan to Orange when the speaker changed.
If you want the complete Python function to convert these word annotations into standard .srt subtitle files, you can find it directly in the interactive Cookbook Colab notebook：https://colab.research.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_transcribe.ipynb.
Here is a quick cheat sheet to pick the right settings for your use case:
Everything we covered above is for pre-recorded audio files (unary mode via the Files API).
Gemini also supports real-time live streaming transcription over WebSockets using gemini-3.5-transcribe-live and the Live API. It lets you stream raw 16-bit PCM chunks (100ms each) directly from a microphone and receive instantaneous interim partial hypotheses ( interim_input_transcription ) and finalized text as speech occurs.
However, streaming real-time WebSockets with asynchronous Python workers ( asyncio ), handling audio chunking, and managing ephemeral valet tokens for secure client apps is quite a bit more complex and deserves its own dedicated tutorial.
If you want to dive straight into live streaming code right now:
Gemini 3.5 Transcribe gives you the best of both worlds: strict, millisecond-accurate verbatim data when you need timestamps and diarization, and an intelligent, disfluency-stripping smart mode when you want clean text for human eyes.
Have you tried using smart mode on your own voice recordings or meetings? Drop your thoughts and edge cases in the comments below! 🚀🚀🚀
Templates let you quickly answer FAQs or store snippets for re-use.
Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink：#.
For further actions, you may consider blocking this person and/or reporting abuse：/report-abuse
Google AI Studio is the fastest way to start building with Gemini. Ready to build?
DEV Community：/ — A space to discuss and keep up software development and manage your software career
Built on Forem：https://www.forem.com — the open source：https://dev.to/t/opensource software that powers DEV：https://dev.to and other inclusive communities.
Made with love and Ruby on Rails：https://dev.to/t/rails. DEV Community © 2016 - 2026.
We're a place where coders share, stay up-to-date and grow their careers.
Scan to open this article