Why Does My Instagram Transcript Generator Give Me Different Text Each Time?
Because “the transcript” is not one object. One recording can leave the pipeline as several different texts — the raw recognition text (the words the model heard), the normalized text (spoken forms rewritten into written display form: numbers, times, punctuation, capitals), and the content-filtered text (masked words) — and on top of those layers, decoding can drift between runs. None of those outputs is the audio; each is a different decision applied to it. This page separates the three output texts, reports what this site’s own repeated runs returned, and gives a rule for which text to trust.
Main guide: Instagram transcript — paste a link, get the full text. The page you are reading covers one specific case in depth.
Short answer: the same audio returns different text because the pipeline produces more than one output and the decoder is not perfectly deterministic. A Microsoft Azure speech writeup on display text format describes at least four separate display layers stacked after recognition — inverse text normalization (spoken “two thirty” written as “2:30”), capitalization, disfluency removal, punctuation, and content filtering — each rewriting the previous text, and notes the inverse-text-normalization layer in particular is not user-configurable. So one recording can legitimately appear as a word string, a written-form string, and a masked string. Beyond the layers, this site’s own repeated runs show raw drift: across twenty-four recognizer calls on a 182.961406-second synthetic narration, whole-file and split inputs returned different text — It's became Its, 94 became 1994, handwritten became “hundred and”, Nobody became “Everybody”, play became place — and a whole-file run overshot its own length, 435 words against a 183.0-second endpoint. The fix is to decide which text you actually want before trusting any of them: the raw word string for fidelity, the normalized string for readability, the filtered string only if a word was genuinely masked, and a re-run or a replay whenever the two outputs disagree.
Three texts come out of one recording
A recording is a wave. The text you see is one or more decisions made about that wave after the acoustic model has done its first pass. The most useful way to stop being surprised by “different text” is to name the three texts and treat them as different artifacts rather than as one correct answer that changed.
| Output text | What it is | Example from one audio |
|---|---|---|
| Recognition text | The words the acoustic and language models settled on, with no display rewriting yet | two thirty |
| Normalized text | Spoken forms rewritten into written display form (ITN): numbers, times, dates, currency, addresses, email, phone | 2:30 |
| Filtered text | Result text with masked words replaced by asterisks or blanks | **** where a flagged word was |
The recognition text and the normalized text are both valid readings of the same audio; they answer different questions. The filtered text is not a correction of an error, it is a policy applied to the result.
The recognition text: what the model heard
This is the layer closest to the audio. It is a sequence of words the model judged most likely given the sound, before anything rewrites it into a more readable shape. It can still be wrong — a sound can resolve to the wrong word — but at this stage nothing has been silently reformatted. When you want to know what was actually said, this is the string to hold onto, because every layer after it edits it.
For the word-selection errors that live in this layer (a word swapped for a different legal word), see the page on why a transcript picks the wrong homophone and the 23-Reel count on why a transcript writes it's and never its. Both are mistakes the model made deciding which word, not formatting applied afterward.
The normalized text: spoken rewritten as written
A Chinese technical writeup on recognition error sources and a Microsoft Azure speech writeup on display text format both describe a step called inverse text normalization, where spoken forms are converted into written display forms. The Azure writeup lists what the layer handles: dates, times, decimals, currency, addresses, email, and phone numbers, and it states that this conversion is applied and is not configurable by the user. That is why “two thirty” can come back as “2:30” and a spelled-out number can come back as digits. It is a writing decision, not a claim about what was clearer in the audio.
This is the same family of layer that also adds punctuation and capitalization you never said. The page on why a transcript adds punctuation you never said covers the punctuation and number side of it, and why capitals come back wrong covers the casing side. Read together, they show normalization is several independent layers, not one switch.
The dangerous part is that normalization looks like an improvement. “2:30” is tidier than “two thirty”, so a reader assumes the tool “fixed” the audio. It did not — it applied a rule that happens to produce written-looking text, and the rule can be wrong about which number or time was spoken.
The filtered text: masking, not accuracy
The same Azure display-text writeup lists content filtering as another display layer, acting on the result text rather than on the recognition. A flagged word is replaced with asterisks or a blank. This is a moderation policy applied after the fact, and it has nothing to do with whether the word was recognized correctly. If the original word matters — a name, a quote, a lyric — the filtered text is the wrong artifact to keep, even though it is the one some interfaces show by default.
The point for this page is narrow: a filter turning word into **** is a third “text” from the same audio, and it is easy to mistake for the model having “gotten it wrong” when nothing about recognition changed.
What you are actually holding after a mask is a result text that still lines up with the recording word for word except at one slot. The content filtering display layer replaces the flagged word in place: an asterisk run or a blank keeps the position, keeps the word count and keeps the sentence readable, but that slot no longer carries a sound you could pronounce. That is the reason the words stop matching the audio without anything having been misheard — the word was recognized and written, then overwritten by policy, so replaying that second still gives you the whole word while the text gives you a placeholder you cannot read aloud. A substitution error is the mirror image: it hands you a legal word that reads like the original and can pass unnoticed, whereas a mask is an obvious gap that the text itself cannot fill. Count each mask as a slot where speech was confirmed and then discarded, not as a hole to guess back into; the filtered string is a writing decision applied to the result, not a copy of what was said.
On top of the layers: a re-run can drift
The three texts above are different by design. There is a second, separate reason for different text: the recognition layer itself is not perfectly reproducible. A Chinese writeup on multi-accent data alignment and acoustic versus language-model error sources describes the acoustic and language models disagreeing more often under accented, fast, or mixed-language audio — the normal condition for a short Reel — which widens the space where a second pass can land somewhere else.
This site’s own repeated runs show that space opening up. Across twenty-four recognizer calls on a single 182.961406-second synthetic English narration (cached faster-whisper tiny, CPU int8, one thread, one worker, beam size one, English selected, VAD disabled), whole-file and split inputs returned different text from each other: It's came back as Its, 94 as 1994, handwritten as “hundred and”, Nobody as “Everybody”, and play as place. A whole-file run also overshot its own length, returning 435 words against a 183.0-second endpoint. None of those are display-layer rewrites; they are the recognition layer returning a different word sequence on a different call.
| Measurement | What came back | What it shows |
|---|---|---|
| 24 recognizer calls, one 182.961406 s file | Whole-file and split inputs differ | A re-run is not guaranteed identical |
| Same runs, word-level | It's → Its, 94 → 1994 |
Apostrophe direction and digit count move |
| Same runs, phrase-level | handwritten → “hundred and”, Nobody → “Everybody”, play → place |
Whole words swap between calls |
| Same runs, whole-file length | 435 words, endpoint 183.0 s vs 182.961 s input | The output overruns its own duration |
Source: this site’s eight audio cuts comparison (cached faster-whisper tiny, CPU int8, one thread, one worker, beam size one, English selected, VAD disabled, 24 calls across eight whole-file runs and sixteen halves). The differences are recorded as differences; no run used an independently listened reference transcript, so they establish that the output moves between calls, not that any specific form was “correct.”
Which text should you keep?
You do not need to disable the layers — most of them you cannot. You need to pick the artifact that matches the job before you quote anything.
- Want fidelity? Keep the raw recognition text. It is the closest string to the audio before any rewriting, and it is the one to replay against.
- Want readability? Use the normalized text — but treat every number, time, and capitalized name as a guess the layer made, and check the ones that matter.
- See blanks or asterisks? That is the filtered text. If the word is a name or a quote you need, go back to the recognition or normalized text; the mask is policy, not accuracy.
- Two runs disagree? Re-run once more and replay the few seconds around the difference. The recognition layer is allowed to move; the audio is the tiebreaker, not the later text.
- Record the chosen form. Write which text you kept and why, so a later reader knows the decision was made on purpose, not by accident of which layer showed up.
Scope and limits
The layer model here comes from two sources: a Microsoft Azure speech writeup on display text format, which lists inverse text normalization, capitalization, disfluency removal, punctuation and content filtering as separate display layers and states the ITN layer is not user-configurable; and a Chinese technical writeup on multi-accent data alignment and acoustic versus language-model error sources, which describes the acoustic and language models disagreeing more under accented or mixed-language audio. The measured drift comes only from one local experiment published on this site, described above with its parameters. Nothing here measures Instagram’s own captions, tests a hosted speech service end to end, compares commercial products, or reports an accuracy rate. No traffic, indexing or ranking figures appear on this page, because none were available to read.
FAQ
- Why does the same audio give me different text each time?
- Two reasons. One, the pipeline produces more than one output — a recognition text, a normalized written-form text, and a content-filtered text — each a different decision about the same audio. Two, the recognition layer itself can drift between runs, because decoding is not perfectly deterministic, especially on fast or accented audio.
- Is one of the texts the “correct” one?
- No single text is the audio. The recognition text is closest to what was said; the normalized text is more readable but rewrites numbers and times; the filtered text applies a moderation policy. Pick the one that matches what you need, and check the parts that matter against the audio.
- Why does “two thirty” come back as “2:30”?
- That is inverse text normalization, a display layer that rewrites spoken forms into written ones. A Microsoft Azure writeup lists dates, times, decimals, currency, addresses, email and phone among what it handles, and states the layer is not user-configurable. It is a writing rule, not a correction of an error.
- Why are some words replaced with asterisks or blanks?
- That is the content-filtering display layer acting on the result text. It is a moderation policy applied after recognition and has nothing to do with whether the word was recognized correctly. If you need the original word, use the recognition or normalized text instead.
- Does a re-run give the same transcript?
- Not guaranteed. This site’s twenty-four-call run on one 182.961406-second narration returned different text between whole-file and split inputs — It's became Its, 94 became 1994, handwritten became “hundred and” — and a whole-file run returned 435 words against a 183.0-second endpoint. When two runs disagree, replay the audio around the difference.
- Can I turn these layers off?
- Mostly no. The display layers are part of how the text is formed, and writeups describe the normalization layer specifically as not user-configurable. Modes may change how a layer behaves, but you generally cannot request the raw acoustic candidates instead of a written string.
- After a word is masked, why does the transcript no longer line up with what I hear?
- Because the mask sits in the position of a word that was recognized and then overwritten, not in the position of a word that was missed. The audio still contains the whole word at that second; the filtered text holds an asterisk or a blank that you cannot read aloud. The sentence stays readable and the word count stays the same, which is exactly why the mismatch is easy to overlook. Treat the mask as a confirmed spoken slot the content filtering display layer discarded, and replay the audio rather than trying to reconstruct the word from the text.
How this connects to the rest of the site
Layered output is the frame; the neighbouring pages carry the specific measurements. These three pages are the ones this page draws on most directly.
- For the punctuation and number side of the normalization layer, see why a transcript adds punctuation you never said.
- For a word-selection error that lives in the recognition layer, see why a transcript picks the wrong homophone.
- For the casing side of the display layers, see why capitals come back wrong.
- For why the same normalization layer applies different writing rules per language, see why a transcript uses different writing rules for each language.
Affiliate link: Notta is a separate service that transcribes audio and video files you upload. This site earns a commission if you subscribe through that link, at no extra cost to you.
For the display layer that deletes fillers, stutters and false starts, see why a transcript drops filler words.