Skip to navigation

Dictate Best Practices

View as Markdown

The code uses the Sarvam Python and JavaScript SDKs (Python sarvamai 0.1.49 or later, JavaScript sarvamai 1.1.22 or later). Every field and limit is in the API reference.

Dictate turns speech into text that a person can send: a chat message, a to-do list, a CRM record, meeting minutes. Pick the recipe that matches what you are building. New to Dictate? Make your first call first.

Recipes at a glance

How Dictate works

You send audio and some settings. Each setting answers one question:

  • mode: where does the text go?
  • style.preset and style.rules: how tidy, and what form?
  • vocabulary and context.reference: which names must be right?
  • output_rules: what else do we need from the recording?

The Overview has the full table.

The one rule to remember: style.rules change the form of text. They never add or remove content. When you need something new (an email, a summary, JSON), use output_rules.

The recipes below use all three routes: a clip, a job for long files, and the live socket.

Set up the client

The recipes use one client and two small helpers. Paste this at the top of your script:

  • dictate() opens a clip and sends it.
  • fixes() prints the corrections of a response.

The SDK sends style, vocabulary and context for you: pass them as plain dicts and lists (Python) or objects (JavaScript). It also waits and retries after a 429 by itself. See Handle errors and retries.

The recipes use short clips named after what they contain (voice_note.mp3, support_note.wav, and so on). Use a clip of your own with the same kind of content.

import json, os
from sarvamai import SarvamAI
client = SarvamAI(api_subscription_key=os.environ["SARVAM_API_KEY"])
def dictate(clip, **fields):
"""Send one clip (30 s or less) and return the response."""
with open(clip, "rb") as f:
return client.dictate.transcribe(file=f, **fields)
def fixes(res):
"""Print the vocabulary and reference changes."""
for c in res.corrections:
print(f" {c.heard!r} -> {c.wrote!r} ({c.source})")
if not res.corrections:
print(" (no corrections)")

In JavaScript, call client.dictate.transcribe({ file: fs.createReadStream(clip), ...fields }) and pass the same objects. Fields keep the API names (language_code, output_rules, sounds_like).

Chat messages: choose the script

Use it when: the text goes to a chat, a document or a record, and the reader expects a certain script.

mode picks the script. Here is one Hindi clip in all four modes.

for mode in ["codemix", "transcribe", "translit", "verbatim"]:
res = dictate("voice_note.mp3", language_code="hi-IN",
mode=mode)
first_line = res.text.splitlines()[0][:100]
print(f"{mode:>10}: {first_line}")
Output
codemix: देखिए भाई साहब, accident में बच्चे का खून काफी बह गया है। आप तो जानती हैं कि AB negative खून बड़ा मु
transcribe: देखिए भाई साहब, एक्सीडेंट में बच्चे का खून काफी बह गया है। आप तो जानती हैं कि AB नेगेटिव खून बड़ा मु
translit: Dekhiye bhai sahab, accident mein bacche ka khoon kaafi beh gaya hai. Aap to jaanti hain ki AB negat
verbatim: देखिए भाई साहब, एक्सीडेंट में बच्चे का खून काफी बह गया है। आप तो जानती हैं कि ए बी नेगेटिव खून बड़ा
ModeWhat you getUse it for
codemixThe language in its own script, English words in Latin lettersChat and messages: WhatsApp, Slack, email
transcribe (default)One script for everythingA document in one script, search, text that is read aloud
translitLatin letters onlyPeople who type their language in Latin letters (Roman Hindi, Tanglish)
verbatimEvery word as spoken, numbers as words, no editsAn exact record: legal, medical, an ID read aloud

Send language_code when you know it. auto works, but a known language is more reliable.

Clean text: light or clean

Use it when: people say “um”, repeat words and correct themselves (“Tuesday, no sorry, Wednesday”), and you want to decide how much of that stays.

for clip in ["self_correction.wav", "filler.wav"]:
print(clip)
for preset in ["light", "clean"]:
res = dictate(clip, language_code="en-IN",
style={"preset": preset})
print(f" {preset:>5}: {res.text}")
Output
self_correction.wav
light: Let's meet on Tuesday. No, sorry, Wednesday at the main office.
clean: Let's meet on Wednesday at the main office.
filler.wav
light: Um, so I was, I was thinking that we could, you know, like maybe go there tomorrow and, and see the place.
clean: So I was thinking that we could maybe go there tomorrow and see the place.
PresetWhat it doesUse it for
clean (default)Removes fillers and repeated words. Keeps only the corrected version of a self-correctionText a person sends: a message, a note, an email body
lightKeeps every word. Adds punctuation, fixes namesA record where every word counts: a call log, captions
noneNo finishing step and no model callYou show the raw output, or finish the text in your own code

clean does not rewrite, and it cannot fix what speech recognition heard wrong.

Bullets, English, rupees and times

Use it when: you need a different layout, language or number format. A rule is a plain sentence in style.rules, and several rules can share one string, one sentence each.

Lists and translation

A Tamil to-do note, as bullets, as a checklist, and translated:

BULLETS = (
"Put each task on its own line, "
'as a bullet that starts with "- ".'
)
rules = {
"bullets": BULLETS,
"checkbox": (
"Write each task on its own line, "
'starting with "[ ] ".'
),
"in English": "Translate the text into English. " + BULLETS,
}
for name, rule in rules.items():
res = dictate("tasks_ta.wav", language_code="ta-IN",
mode="codemix", style={"rules": rule})
print(f"--- {name}\n{res.text}")
Output
--- bullets
- நான் வங்கிக்கு போகணும்
- அப்புறம் அம்மாவுக்கு phone பண்ணணும்
- அதுக்கப்புறம் வெள்ளிக்கிழமை rail ticket book பண்ணணும்.
--- checkbox
[ ] நான் வங்கிக்கு போகணும்
[ ] அப்புறம் அம்மாவுக்கு phone பண்ணணும்
[ ] அதுக்கப்புறம் வெள்ளிக்கிழமை rail ticket book பண்ணணும்.
--- in English
- I need to go to the bank.
- Then I need to phone my mother.
- After that, I need to book a rail ticket on Friday.

Money and times

English amounts already come in Indian digit grouping (1,25,000). A rule adds the sign and changes the clock:

RUPEE = (
"Write money amounts as the ₹ sign and digits with Indian "
"digit grouping, for example ₹1,25,000. Write no currency "
"word after the amount."
)
H24 = "Write times in 24-hour format, for example 15:30."
CASES = [("no rule", None), ("₹ + 24-hour", RUPEE + " " + H24)]
for name, rules in CASES:
style = {"rules": rules} if rules else {}
res = dictate("money.wav", language_code="en-IN", style=style)
print(f"{name:>12}: {res.text}")
Output
no rule: Please transfer 1,25,000 rupees to Ravi by the 5th of December. The call with the bank is at 3:30 in the afternoon and the second one is at 9:15 at night.
₹ + 24-hour: Please transfer ₹1,25,000 to Ravi by the 5th of December. The call with the bank is at 15:30 in the afternoon and the second one is at 21:15 at night.

Number words can stay as words in Telugu and Tamil. Add Write every number as digits. to get digits.

What a rule cannot do

A rule cannot add content: an email, a greeting, a summary or a shorter text. The words stay as the person said them, so an app can paste text as the user’s own words. Use output_rules for those.

rule = "Write it as an email, with a greeting and a sign-off."
res = dictate("invoice.wav", language_code="en-IN",
style={"rules": rule})
print(res.text)
Output
The invoice for October is ready and I will send it to you by Friday. Let me know if the amount looks wrong.
DoWhy
Name the change with a verb: “Translate the text into English.”A bare word such as “English.” is not a change
Say what the result looks like: Put each task on its own line, as a bullet that starts with "- ".Gives the exact marker your app needs
Choose the script with mode firstmode=translit gives Roman Hindi with no rule
Put new content in output_rulesstyle.rules cannot add it

Names your way: vocabulary

Use it when: product, customer or medicine names must come out with your spelling. Speech recognition cannot know that your company is “Velqora” and a customer spells her name “Vyshnavi”.

VOCAB = [
{"word": "Velqora"},
{"word": "Velqora Fiber"},
{"word": "Vyshnavi Raghunathan"},
]
res = dictate("support_note.wav", language_code="en-IN")
print("no list: ", res.text)
res = dictate("support_note.wav", language_code="en-IN",
vocabulary=VOCAB)
print("vocabulary:", res.text)
fixes(res)
Output
no list: Hi, this is Meera from Belkora Support. I spoke to Vaishnavi Raghunathan about her Belkora fiber connection. Her router has shown a red light since Tuesday, so I raised a ticket and asked the field team to visit tomorrow morning.
vocabulary: Hi, this is Mira from Velqora Support. I spoke to Vyshnavi Raghunathan about her Velqora Fiber connection. Her router has shown a red light since Tuesday, so I raised a ticket and asked the field team to visit tomorrow morning.
'Belkora' -> 'Velqora' (vocabulary)
'Vaishnavi Raghunathan' -> 'Vyshnavi Raghunathan' (vocabulary)
'Belkora fiber' -> 'Velqora Fiber' (vocabulary)

corrections lists each change, so your app can show the user what changed. If recognition keeps writing a name wrong in the same way, copy that spelling from transcript into sounds_like:

sounds_like
{"word": "Taxoryn", "sounds_like": ["Taxorin"]}

Trap 1: a look-alike that was not said. If the list has a spelling variant of a name that was said, Dictate uses the listed spelling, even when recognition had it right. Here the list has “Draxiva” and “Harprit”, but the speaker said “Draxivo” and “Harpreet”.

# Look-alike spellings of two names that were said correctly.
vocab = [
{"word": "Draxiva Logistics"},
{"word": "Harprit Sodhi"},
{"word": "Taxoryn"},
]
res = dictate("billing_hi.wav", language_code="hi-IN",
mode="codemix", vocabulary=vocab)
print(res.text)
fixes(res)
Output
Draxiva Logistics का इस महीने का Taxoryn invoice अभी तक नहीं गया है। Accounts में Harprit Sodhi से बात करो और कल तक भेज दो वरना late fee लगेगी।
'Draxivo Logistics' -> 'Draxiva Logistics' (vocabulary)
'taxorin' -> 'Taxoryn' (vocabulary)
'Harpreet Sodhi' -> 'Harprit Sodhi' (vocabulary)

Trap 2: the whole catalogue. A catalogue of 300 customer names in vocabulary fixed none of the three names in the support note (0 of 3 in each of 4 runs). The same three names alone fixed all of them (3 of 3 in each of 4 runs).

DoWhy
Send the names of this recording: this customer, this patient, this ticketA short list works much better than a large one
Write word exactly as it must appear in text, in the script of your modeEvery fix uses the listed spelling
List only the right spelling, not variantsA wrong variant can replace a right name
Read correctionsEvery change is listed, the wrong ones too

vocabulary corrects words that recognition wrote. It cannot bring back a word that recognition lost.

Names from a document: reference

Use it when: the names are already in a record you have (a meeting agenda, a CRM record, a prescription). Send it as it is, and Dictate takes the terms from it and uses them like a vocabulary. No list to build.

AGENDA = """Orvinta launch sync, Friday
Attendees: Tejaswini Kulkarni (design), Farhan Siddiqui (payments)
Agenda: 1. Onboarding screens
2. Plivora payment integration
3. Beta date
Products: Orvinta, Orvinta Lite, Orvinta Max
Payment partner: Plivora checkout"""
clip = "review_meeting.wav"
res = dictate(clip, language_code="hi-IN", mode="codemix")
print("no reference:", res.text)
res = dictate(clip, language_code="hi-IN", mode="codemix",
context={"reference": AGENDA})
print("reference: ", res.text)
fixes(res)
Output
no reference: आज के review में तीन चीजें हैं। पहले Aurvinta Lite का pricing, फिर Plivora checkout के bugs और आखिर में Farhan Siddiqui का demo। Tejaswini Kulkarni design की updates देंगी।
reference: आज के review में तीन चीजें हैं। पहले Orvinta Lite का pricing, फिर Plivora checkout के bugs और आखिर में Farhan Siddiqui का demo। Tejaswini Kulkarni design की updates देंगी।
'Aurvinta' -> 'Orvinta' (reference)
'Aurvinta Lite' -> 'Orvinta Lite' (reference)
vocabularycontext.reference
What you sendA list of namesAny document, up to 50,000 characters
Best forThe names that must be rightNames that are already in a document
sounds_likeYesNo

You can send both. When a term is in both, the vocabulary entry wins.

The situation: context.text

context.text tells the model what the recording is: “A support call about a broadband outage.” Use it to describe the situation in a sentence or two.

It can sometimes change how a name is spelled, but it is not reliable: the same text fixed a name in one run and not in the next, and the change is not listed in corrections. Put names that must be right in vocabulary or context.reference.

situation = (
"A support agent's note about a Velqora Fiber broadband "
"customer, Vyshnavi Raghunathan. The agent works for "
"Velqora support."
)
res = dictate("support_note.wav", language_code="en-IN",
context={"text": situation})
print(res.text)
fixes(res)
Output
Hi, this is Mira from Belkora Support. I spoke to Vaishnavi Raghunathan about her Belkora fiber connection. Her router has shown a red light since Tuesday, so I raised a ticket and asked the field team to visit tomorrow morning.
(no corrections)

JSON, summaries and answers: output rules

Use it when: you need something new from the whole recording: JSON for a form, a summary, answers, a reply draft. You get it in output.text, next to the normal text. The output can only use what was said.

A sales call into a CRM record

Describe every key: its type, what it holds, and what to write when it was not said.

CRM = """Return only one JSON object with exactly these keys, and
no other text. Use null for a value that was not said.
{
"buyer_name": string | null, // full name, in English letters
"buyer_city": string | null, // city, in English
"buyer_phone": string | null, // phone number, digits only
"buyer_email": string | null, // email address, as said
"product": string | null, // what the buyer wants, with size
"quantity": number | null, // how many units
"unit_price_inr": number | null // price of one unit, in rupees
}"""
res = dictate("sales_call.wav", language_code="hi-IN",
output_rules=CRM)
record = json.loads(res.output.text) # a string: parse it
print(json.dumps(record, indent=2, ensure_ascii=False))
total = record["quantity"] * record["unit_price_inr"]
print("order total (computed in code): ₹", total)
Output
{
"buyer_name": "Sunita Kulkarni",
"buyer_city": "Nashik",
"buyer_phone": "9822041735",
"buyer_email": null,
"product": "water tanks of 1000 liters",
"quantity": 40,
"unit_price_inr": 6800
}
order total (computed in code): ₹ 272000

Answers to set questions

Give a way out for questions the call does not answer:

QUESTIONS = """Answer each question on its own numbered line, in
English, in one short sentence. If the call does not answer a
question, write "Not mentioned".
1. Which city is the buyer from?
2. How many tanks does the buyer want?
3. Did the buyer ask for a discount?"""
res = dictate("sales_call.wav", language_code="hi-IN",
output_rules=QUESTIONS)
print(res.output.text)
Output
1. The buyer is from Nashik.
2. The buyer wants 40 tanks.
3. Not mentioned.
DoWhy
Describe every key: type (string | null, number | null), what it holdsA bare JSON shape gets keys wrong more often
Say what to write when a value was not said (null, “Not mentioned”)Otherwise the model may invent a value
For Indian-language audio, write “Write every value in English” at the top, or “in English” in each keyWith no language named, the values come back in the speaker’s script
Name the language of a summary: “in English”Otherwise it can follow the clip
Ask for one output per requestSeveral outputs in one request can mix up
Do sums in your own codeThe model’s sums are not reliable
Parse output.text yourselfIt is a string. In JavaScript, use JSON.parse(res.output.text)

The output can only be as right as the text. A name that vocabulary fixed in text has the same spelling in output.

Long recordings: jobs

Use it when: the recording is longer than 30 s, up to 1 hour. Upload it, poll every 5 s, read result.output.text, then delete the job.

  • Upload compressed audio (MP3, M4A, Opus). Files of about 100 MB or more are refused, so pass audio_url for a large file.
  • Set a generous timeout for the upload: SarvamAI(..., timeout=600) in Python, or timeoutInSeconds: 600 in JavaScript. For callbacks and audio_url, see Transcribe long recordings.
  • Each POST is a new, billed job. Do not send it again without a reason.
import time
def run_job(path, **fields):
"""Upload a job, wait for it, delete it, return the result."""
with open(path, "rb") as f:
created = client.dictate.jobs.create(file=f, **fields)
job_id = created.job_id
while True:
time.sleep(5) # poll every 5 s or more
job = client.dictate.jobs.get(job_id=job_id)
if job.job_state in ("Completed", "Failed"):
break
# Results are kept for 7 days. Delete the job when you are done.
client.dictate.jobs.delete(job_id=job_id)
if job.job_state == "Failed":
raise RuntimeError(f"{job.error.code}: {job.error.message}")
return job.result
MINUTES = """Return only one JSON object, and no other text:
{
"summary": string, // what was decided, in English
"decisions": [string], // each decision, one short sentence
"action_items": [
{
"owner": string | null, // who will do it, as named
"task": string, // what they will do
"due": string | null // when it is due, as said
}
]
}
Use only what was said. Use [] for a list with nothing in it."""
result = run_job("weekly_meeting.mp3", language_code="en-IN",
output_rules=MINUTES)
minutes = json.loads(result.output.text)
print("Summary:", minutes["summary"])
for a in minutes["action_items"]:
owner = a["owner"] or "(no owner)"
due = a["due"] or "not said"
print(f"Action: {owner}: {a['task']} (due: {due})")
Output
Summary: The team reviewed the Koramangala store launch, confirming the launch date, a backup stock plan, hiring needs, the event budget, and training plan deadlines.
Action: Rohan: tell the landlord in writing about the launch date (due: today)
Action: not mentioned: call the customs agent to find out what form they need and update the group (due: tomorrow morning)
Action: Amit: send 2 candidate profiles (due: Tuesday)
Action: not mentioned: send a breakdown if more than ₹75,000 is needed for the launch event (due: Friday)
Action: Aditya: share the training plan (due: next Monday)

For a callback instead of polling, pass callback={"url": ..., "auth_token": ...} to jobs.create. See Create Job.

The owner of a task is the weakest field in minutes. When two people speak in turn, the model can pick the wrong one, or write the text “not mentioned” instead of null. Check this field in your app.

Live dictation: the socket

Use it when: the app shows partial text while the user speaks, then one finished text after each pause.

1

Connect

Call client.dictate_streaming.connect(...). The first message is session.begin.

2

Configure (optional)

Call update_config with output_rules, if you need an output at the end.

3

Send audio

send_audio with base64 audio: 16 kHz, mono, 16-bit, at most 1 s per message (0.5 s with stream_type=fast), at about real-time speed.

4

Show the text

Show each transcript.partial as a live preview. Replace the turn with dictation.final after each pause.

5

End the session

Call end and read until session.end. output.final comes before it.

import asyncio, base64, os, wave
from sarvamai import AsyncSarvamAI
from sarvamai.types import DictateAudioInput, DictateConfigUpdate, DictateEnd
aclient = AsyncSarvamAI(api_subscription_key=os.environ["SARVAM_API_KEY"])
CHUNK = 3200 # 100 ms of 16 kHz, 16-bit mono audio
RULES = (
'List the action items from this note as bullets that '
'start with "- ". For each, write the owner, the task and '
'the due date, as said. Write "None" if there are none.'
)
async def live(path):
with wave.open(path) as w: # 16 kHz, mono, 16-bit WAV
pcm = w.readframes(w.getnframes())
async with aclient.dictate_streaming.connect(
language_code="en-IN", encoding="linear16", sample_rate="16000"
) as ws:
async def send_audio():
await ws.update_config(DictateConfigUpdate(output_rules=RULES))
for i in range(0, len(pcm), CHUNK):
chunk = base64.b64encode(pcm[i:i + CHUNK]).decode()
await ws.send_audio(DictateAudioInput(audio=chunk))
await asyncio.sleep(CHUNK / 32000) # real time
await ws.end(DictateEnd())
sender = asyncio.create_task(send_audio())
partials = 0
async for m in ws:
if m.event == "session.begin":
print("connected:", m.event)
elif m.event == "transcript.partial":
partials += 1 # show these as a live preview
elif m.event == "dictation.final":
print(f"turn {m.utterance_idx}: {m.text}")
elif m.event == "output.final":
print("output:\n" + (m.text or "(none)"))
elif m.event == "error":
print("error:", m.code, m.message)
elif m.event == "session.end":
print(f"{partials} partials, {m.total_utterances} turn(s), "
f"billed {m.usage.audio_duration_s} s")
break
await sender
asyncio.run(live("live_note.wav"))
Output
connected: session.begin
turn 0: Note for the team, our order from Nilga Exports is stuck at the Chennai port. Neha will call the customs agent tomorrow at 10. If Nilga Exports cannot send the form by Friday, we open the store with 200 units. Rohan, please send the updated budget to Kriya by Monday.
output:
- Neha, call the customs agent, tomorrow at 10
- Rohan, send the updated budget to Kriya, by Monday
130 partials, 1 turn(s), billed 14.362 s
  • To add a name in the middle of a session, call update_config with vocabulary. It applies from the next turn that ends, so it needs a pause between turns.
  • For push-to-talk, connect with endpointing=manual. Each press is one turn, and only the pressed audio is billed.
  • Always call end and read until session.end, or you lose the last turn and the output.
  • Open the socket from your server, not from a browser. The SDK sends your key as a header, which a browser socket cannot do.
  • JavaScript on Node.js 22 and later: run the script with node --no-experimental-websocket, or the socket is refused with 403 (the built-in WebSocket cannot send the key header). See Live dictation.

Cheat sheet

You wantSend
A chat message in Hinglish or Tanglishmode=codemix
One script, for a document or searchmode=transcribe (default)
Latin letters onlymode=translit
An exact record, numbers as wordsmode=verbatim
Every word kept, with punctuationstyle.preset=light
Bullets, a checklist, one sentence per linestyle.rules
The text in Englishstyle.rules: Translate the text into English.
Names rightvocabulary with the names of this recording
Names from a document you havecontext.reference
JSON, a summary, answers, a replyoutput_rules
A file longer than 30 sA job
Live words while the user speaksThe socket
Text that must not change without noticemodel=dictate-v1-2026-11-04 or model=dictate-v1-2026-11-05. The alias dictate-v1 moves to a newer snapshot after 30 days’ notice

Check in every response: degraded (null means the finishing step ran), corrections (what names changed), and output.degraded when you send output_rules.

When something looks wrong

Find the group that matches what you see, then the row.

Text and names

You seeCauseDo this
degraded is set and text equals transcriptThe finishing step failed or timed out. It is not billedSend it again if you need the finished text
A name is misspelledIt is not in vocabulary, or word is in another script than the modeAdd it in the script of the output. Add the wrong spelling from transcript as sounds_like
A different listed name was writtenA look-alike in your listRemove names that will not be said in this recording
No name is fixedThe list is too longSend only the names of this recording
400 with “is also listed for” in the messageTwo vocabulary entries list the same sounds_like. Letter case is ignoredList each misheard form under one word
A rule in style.rules did nothingIt asked for new content, or it was a bare wordMove new content to output_rules. Write the rule with a verb
English words come in Devanagari or Tamil scriptThe default mode is transcribeSend mode=codemix
JSON values come in an Indian scriptNo language namedWrite “Write every value in English” at the top

Language and audio

You seeCauseDo this
The whole text is in the wrong scriptlanguage_code does not match the audio (this is not an error), or you sent it in the query string, where it is ignoredSend the right code as a form field, or auto
A clip returns 200 with an empty textThe clip has no speech, only noise. This is not an errorSkip empty text

Requests and limits

You seeCauseDo this
A request gets 307 to an http:// addressA trailing slash in the path (/v2/dictate/)Use the path exactly as written, with no trailing slash
HTTP 429The key’s rate limit. Polls countThe SDK retries by itself. Poll every 5 s
HTTP 413The body is too large at the gatewayClip: up to 10,000,000 bytes. Job: use audio_url

Jobs

You seeCauseDo this
A job is Failed with invalid_audio_urlThe host name of audio_url points to a private address, or does not resolveUse a public https URL. localhost and private IP addresses are refused at create with 400
A job is Failed with invalid_audioThe file is not readable audio. A job finds this when it runs, not at createCheck the file. A clip returns 400 for the same file

Live socket

You seeCauseDo this
A socket gives wrong text, and the billed seconds are doubledsample_rate does not match the audioSet sample_rate to the real rate (16000 or 8000). Send raw samples
A socket closes with 1011 and keepalive ping timeoutYour client stopped reading, so it stopped answering the server’s pingsRead messages in their own task, and do not block it on slow work
A socket turn has empty text and degraded is nullA short noise opened a turnSkip empty turns
CERTIFICATE_VERIFY_FAILED on the socket on macOSThe Python build has no CA filepip install certifi, then set SSL_CERT_FILE=$(python -m certifi)

Limits to keep in mind

  • Speech recognition comes first. No rule or preset fixes a word it heard wrong, so use vocabulary for the words you know.
  • Do sums yourself. Do arithmetic in your own code, and check task owners in meeting minutes.
  • Results vary a little between runs. Check the text before you depend on it.

Limitations has the full list of what Dictate does not do, and its limits.

Next steps