Settings

Settings is where you connect the services Whispr runs on and prove they actually work. Everything runs on your own accounts: keys are stored in your credential store — the macOS Keychain, or Windows Credential Manager — and only ever used from this machine to call the services you connected.

Changes to transcription and engines apply to the next session, not the one already running.

How this screen is laid out

Four groups in the sidebar, ordered by when you need them rather than by what they configure:

Readiness and headroom sit above the groups rather than inside one, because they are about all of it: what has been proven, and how much is left on each account.

If you only ever touch one group, touch Essentials. If it is green there and in the chip, a meeting will work.

Which permissions each key actually needs

The single most common way to end up with a key that half-works is to give it too few permissions and get no error until the moment it matters. Every credential row in Credentials opens to show its own numbered steps; these are the two where the scope is genuinely not obvious.

Cloudflare (Workers AI)

Two permissions, and they buy different things:

The prefilled token from the Workers AI panel carries the first but not the second, which is why a token that answers perfectly can still report no headroom. The Neuron figure lives in an undocumented analytics dataset, so the Workers AI permission alone returns 403 there.

You also need the account ID, shown in the same panel. It is an identifier rather than a secret, but it travels with the token.

Deepgram

Member is the right choice unless you specifically want the balance reading. Confirmed against a real Member key: listing projects returned 200 and reading balances returned 403.

The others

Gemini, Anthropic and OpenAI-compatible keys have no scopes to choose — one key, full access to the API. Google, OpenAI and Anthropic publish nothing an inference key can read about remaining quota, so headroom says so rather than guessing.

Your own voice Worker needs no permission at all: the token is one you invent and set on your own deployment with wrangler secret put VOICE_TOKEN.

Ready for a call?

The block at the top is the honest summary. It reports what has been proven — a key that is saved but has never answered a request is not a working engine, and this is the screen where that difference shows before a call rather than during one.

It lists transcription, each engine, and the prep material this kind of meeting wants. Test everything re-runs the lot. Re-run setup reopens the guided walkthrough.

The chip in the title bar says the same thing in one word, and clicking it comes back here:

Once you have been through setup, a chip that is not green puts a banner under the title bar saying the same thing at greater length, in the same tone, with the button for that case — Test them when everything is saved and merely unproven, Open Settings when something is missing. It never appears during a call: there is nothing to fix mid-call and a takeover warning then is noise, so the chip is the whole of the report while a session runs.

You

Your name, which is the name answers are written in. It is committed when you click away from the field, not on every keystroke.

Your credentials

One row per key, grouped into speech, answers, and infrastructure. Each row shows a dot when something is stored, a box to paste a new value, and Clear to remove it.

Open a row and it tells you what that key switches on, what happens if you skip it, numbered steps to get it, and what it costs. That text is the detailed guidance; Credentials and costs is the shape of the whole arrangement.

The value is write-only. The app can ask whether a key is stored; it can never read one back, which is also why a saved key shows as dots rather than as characters you can check.

Below them is No key required — providers that need no stored credential, and one that is not built yet. They are listed rather than omitted, because silence reads as "unsupported".

Where the other side comes from

Under Your microphone, below the input picker. The default — this computer's own audio — is what every install does and what almost everyone should keep: Whispr hears the other person from whatever this machine plays.

Change it only when the call happens somewhere else and reaches this machine through an audio input: a phone wired in through a USB audio interface, a mixer, a conference phone with a line out. Your microphone stays you, so both sides are still told apart by which wire carried them — nothing is guessed from the sound.

Four things worth knowing before you use it:

• Screen Recording is not used at all on that setting. Nothing about the display is captured, and whispr doctor stops asking for the permission.
• Echo cancellation is switched off on both inputs while it is in use. That is measured rather than cautious: turning it on for one input reconfigures the other and drops it about 40 dB, which is worse than having none. Wear headphones.
• It never falls back. If the device is unplugged, that channel is dead and Whispr says so — because the fallback would be this computer's own audio, which is the wrong source and would look perfectly healthy.
• One device cannot carry both sides. Whispr refuses: both channels would hear the same audio and each side would be recorded as the other.

It takes effect at the next meeting, not immediately — switching it mid-call would restart the channel carrying the other person and drop whatever they are saying. From a terminal: whispr audio-devices --set-system <id>, and whispr audio-devices shows which is in use.

Hearing the call

Four transcribers, and each difference is a real trade rather than a preference.

• Deepgram — the fastest, and usually the largest running cost in a normal setup. It bills two streams, because your side and their side are transcribed separately.
• Workers AI — the same Deepgram model (@cf/deepgram/nova-3), hosted by Cloudflare and billed on the CF_ACCOUNT_ID/CF_API_TOKEN pair the default answer engine already uses. The transcript is the same; the price per minute is slightly higher than a direct Deepgram key ($0.0092 against $0.0048–$0.0078, about $0.83 for a 45-minute call across both streams). What it buys is one signup instead of two — and on the free plan it comes out of the same daily allowance the answers do.
• Local whisper — free, and no audio leaves this machine, at the cost of noticeably later answers.
• Gemini live — Google's gemini-3.5-transcribe-live, on the same GEMINI_API_KEY an answer engine may already use. Two things it does that the others do not: it detects the language automatically across 85+ languages including someone switching mid-sentence, and it can be biased towards the names in your own prep — Whispr passes up to a hundred proper nouns from your CV and the advert, which is exactly the vocabulary transcribers get wrong. It bills two streams like the others.

Two things worth knowing about Gemini live specifically. Its sessions are capped at ten minutes by Google, so Whispr replaces the connection roughly every nine — you will not notice, but it is why this transcriber reconnects during a long call when the others do not. And it is asked for verbatim text, never Google's "smart" tidied mode: that mode removes filler words, and practice measures your filler density, so a tidied transcript would report every answer as clean and the one number telling you how you actually sound would always be zero.

Headless, this is whispr transcriber — with no argument it prints the current one and the choices; with one it switches and names the credential that choice needs. There had been no way to change this outside this screen, which is a gap on a product whose first invariant is that every feature works without the app.

Languages spoken

Under the transcriber is a list of the languages actually spoken in your meetings. Leaving it empty means detect, which is how every install starts and is the right answer for a genuinely multilingual room. The reason to fill it in is the opposite case: in a quiet moment, a transcriber left to detect will invent words in a language nobody present speaks, and those words reach the question detector and the answer engines as though somebody had said them.

Each transcriber takes this differently, and Whispr does the translation:

• Deepgram and Workers AI — one named language is sent as itself. Two or more become Deepgram's multilingual mode, which is the honest reading of a list, since there is no way to say "these three and not the rest". That mode is a nova-3 feature; on an older model Whispr sends the first language rather than a parameter the socket would reject, because a rejected parameter is a call with no transcript at all.
• Local whisper — takes one code and has no multilingual mode, so it gets the first and detection stays on for the rest.
• Gemini live — takes the whole list, which is what it is best at.

The same panel is on the Live view under ⚙ Quick settings, because this is one of the few settings worth changing with a meeting already running.

Headless: whispr transcriber --languages en-GB,lv-LV, and whispr transcriber --languages detect to clear it.

Choosing Workers AI adds a Model field, because the model is configuration: @cf/deepgram/nova-3 is the default, and whatever speech model Cloudflare hosts next goes in the same box. Run the readiness test before a call — it opens the same authenticated socket an interview opens and requires an answer, which is what catches a token created without the Workers AI permission or a mistyped account id.

The voice Worker, and letting Whispr deploy it

The spoken practice interviewer can run on your own Cloudflare account instead of Deepgram's. That needs a small program — a "Worker" — on your account, and Whispr can put it there for you.

Choose Set it up for me, give it two things, and press Deploy:

• Account ID — in Cloudflare, open Workers & Pages; it is in the right-hand sidebar.
• An API token that can deploy. This is not the Workers AI token you may already have: that one runs models and cannot create Workers. Make a second one at My Profile → API Tokens → Create Token → Create Custom Token with one permission, Account · Workers Scripts · Edit, scoped to your account.

Five steps then tick past: checking the token, uploading, giving it an address, setting the shared password, and checking it answers. If one fails, that row goes red and says what to do — a token without the deploy permission is by far the most common, and it says so by name rather than reporting "authentication error".

The token is used and forgotten unless you tick keep it for updates. Nothing else on your Cloudflare account is touched, and the Worker runs on your free allowance, not ours.

Deploy it with one click is the default, and it is the one to give a client: it opens Cloudflare's own deploy page, which copies the Worker into their account and sets it up. Nothing is needed but a browser and a Cloudflare account. It then asks them to copy the address back and set a shared password themselves — four short steps the token path removes, which is the whole difference between the two.

I already have one is the technical path, and it is the one to use if you deployed the Worker yourself — with wrangler, from the dashboard, or on an earlier install. It asks for the two things that link it:

• The address, e.g. https://whispr-voice.<subdomain>.workers.dev.
• The shared password, which is the same string as the VOICE_TOKEN secret on the Worker. Cloudflare calls it VOICE_TOKEN; Whispr stores it as WHISPR_VOICE_TOKEN. One invented string under two names is where almost everybody gets stuck — if they differ, every request is refused and Whispr reports the credential as rejected.

Check the link then proves it: it opens a real socket to the Worker and closes it again, which tests the address and the password together and starts no call, so it costs nothing. Until something has answered, "linked" is an assumption.

Under What the Worker itself needs the panel lists the one secret and the three variables, with their working defaults — so if you deployed by hand you can see at a glance that only VOICE_TOKEN is actually missing. It also names the two bindings the Worker needs (Workers AI and a Durable Object, both free) and the trap worth knowing: pointing MODEL at a paid-plan or reasoning model returns a successful response containing no text, so the interviewer just says nothing.

Headless, the same two settings are whispr voice-worker <url> and whispr config set-secret WHISPR_VOICE_TOKEN.

Re-deploying later updates the Worker in place and never changes the shared password.

Reading answers into your headphones

Off by default, and it is the one setting with a way to embarrass you, so it is worth reading before switching on.

During a live call the fastest answer can be read aloud into your ear. The others stay on screen, which is what the screen is for. It starts speaking as the audio is generated, so the voice begins in well under a second rather than after the whole clip has been made — the wait is what made this unusable before.

You must choose an output device, and there is deliberately no "system default" option. This is the whole safety design, not an oversight. On a laptop the default output is the built-in speakers; anything played there is heard by your own microphone and transmitted to the meeting — which means the interviewer hears the answer being read to you. So:

• nothing is ever spoken until you pick a device;
• if the chosen device cannot be used, playback stops rather than falling back to the speakers, and says so;
• if that device is unplugged, nothing is spoken until it is back, and your choice is kept.

Choose the headphones you are actually wearing. The switch stays disabled until you have.

What to read offers two things. The answer is capped (about half a minute of listening, during which you are not talking). Just the cue is the head and three beats the overlay shows — about two seconds, and sized for exactly the gap between the interviewer finishing and you being expected to speak. If half a minute of listening turns out to be the problem, the cue is the answer to it.

It uses your Deepgram key — the same one that transcribes the call, no second credential.

Local whisper

Whispr does not start the whisper server. You start it, and leave it running:

whisper-server -m /path/to/ggml-base.en.bin --port 8080

Then put that server's address in the Server field — http://127.0.0.1:8080 if you followed the line above — and test it before a call. By far the likeliest failure is a server nobody started, and the readiness test catches that by posting real audio at it.

Whisper transcribes a block of speech once the speaker pauses, rather than word by word as they talk. That is why answers start a second or two later than with Deepgram.

The Model field is recorded, not sent — your server already has the weights loaded. It is here because changing the model means the last successful test no longer proves anything. A bigger model is more accurate and slower, and slower is felt directly as a later answer.

Answer engines

One card per engine: whether it is on, the name you gave it, the provider it speaks to, its role, the model, and how much of your prep it may carry. Add an engine adds another; Remove takes one away, after telling you what stops working if it was the last of its kind.

Several answer engines can run at once. They answer the same question in parallel and you pick between them, which is also why one slow or broken engine never leaves you with nothing — and it is the reason to add a second.

Four roles, and they are not interchangeable:

The arrangement you start with, and why

You do not have to set any of this up. A new install already holds every role, arranged so the expensive engines are spent only where they earn it:

Choosing a model, and what "the latest" means

Whispr does not ship a list of the newest models, because such a list is wrong the day after it is written — and wrong in a way that is hard to spot. A model id that Cloudflare will not run does not return an error: it returns a perfectly well-formed reply containing no text at all, which at run time looks exactly like a slow engine.

So ask your own account instead:

whispr models            # what this account is offered
whispr models --probe    # which of those actually answer

The probe sends one tiny completion to each and keeps only the ones that produce visible text. On a real free account, of thirty listed models: thirteen answered, nine returned nothing at all, one was behind a licence, and six were refused as paid-plan only.

Those six are the honest definition of a premium tier. Error 5035 means the model exists and your credential is fine — only the Workers plan is in the way. Upgrading (currently $5/month, with a far larger daily allowance) unlocks them. Re-run --probe afterwards: some of them will still turn out to return no text, and only the probe knows which.

Nothing about this changes your engines. Set a model in the engine editor above, or with whispr engines set <engine-id> --model <model-id>.

Which engine is actually earning its place

whispr engines stats

Per engine and per kind of question: how often you used its answer, its median latency, and how many times it failed. It is built from which answer you actually delivered, not from which arrived first — a race is won on speed, and fastest is not the same as best.

It refuses to name a winner until there is enough to name one (eight answers and a clear gap), so expect "not enough to call yet" for the first interview or two. That is the point: an engine named on four answers is a coin toss you would act on. When the engine you prefer is the slower one, it says so, so keeping it stays a decision rather than something you discover later from your latency.

How soon an answer starts

The engine cards carry a second figure: how long that engine takes to get its first word out, over its recent answers. It is a different question from the median above, and a more useful one.

The median latency is the whole answer, so an engine that thinks fast and writes a long, good reply looks slow on it. What decides whether an answer helps is the moment you can start reading — there are only about three seconds between the other person finishing and you being expected to speak. An engine whose first word lands after that produced something worth reading later, and nothing you could use in the moment.

So an engine that is regularly past three seconds says usually too late to help with the question asked, and one past ten seconds says something is wrong with this engine — that is not slowness, that is a stalled socket, a queue, or a cold local model. Individual answers say the same thing on the card, and only when there is something to say: a card with no note on it arrived in time.

Nothing is capped and nothing is cut off. A late answer is still a real option and still worth choosing — it just did not help with the question it was asked about. What to do with the figure is yours: a smaller or nearer model usually starts sooner. whispr engines stats and whispr preflight both print it.

Three things about that arrangement are worth knowing before you change it.

Two engines write the cue, and that is deliberate. Both anchor engines are asked, and whichever answers first with a usable cue is the one you see. The overlay is small and unforgiving — a head and three short beats, nothing longer — and a model that cannot hold that format produces nothing at all rather than a paragraph you have no time to read. Racing two is how Whispr finds out which one can, from your own interviews, instead of you having to guess. whispr doctor reports how often each was discarded and why, and there are two ways to vote for a cue: ⌘⇧L (Ctrl+Shift+L) while it is on the overlay, or the 👍 beside it in the main window. A race is won on speed, and fastest is not the same as best, so your vote is the only thing that can tell them apart.

The key matters more than it sounds. Before it existed the only vote was the button in the main window — the surface nobody looks at during a call — and on a real install not one cue in two hundred had ever been rated, which meant the recommendation below could never say anything but "not enough to go on". whispr cues prints the table, the verdict, and how many votes there have been.

Both are on your free Cloudflare allowance and a cue is a few dozen tokens, so the second one costs a rounding error against a single answer. If you would rather only one was asked, set anchorPick.preferred in config.json to that engine's id.

The fast lane is about fan-out, not quality. fast engines stand in for the answer engines on the cheap kinds — logistics and background. Which kinds those are is not a setting on this screen: it lives in config.json as fastLaneKinds, because changing it is rare and getting it wrong is expensive. On those kinds one competent free answer is enough; letting Claude and the 70B both race is paying twice for "the salary range is negotiable". If you remove the fast engine nothing breaks: those questions simply go back to every answer engine, which costs more and is slower.

Two roles fail silently if nothing holds them, so Whispr fills them in rather than letting you discover it mid-call. If your config has no classifier, question detection falls back to heuristics that cannot split one long turn into two questions; with no anchor, the overlay shows only cues drawn from your prep and nothing written for the actual question. On start-up, if either role is unheld, the app adds a small Workers AI engine for it and says so in its log. It will not re-enable an engine you switched off — if you turned the cue engine off deliberately, it stays off and a separate one is added — and it never touches a role you already have covered.

That fill exists because a default only ever applies to an install that has never run. Earlier versions shipped a cue engine in the defaults and nobody who already had a config ever received it: the overlay quietly wrote no cues, which looks exactly like a slow model.

Changing them

Everything above is a starting point, not a constraint. What each change costs:

whispr doctor reports which engine holds each role, so it is worth running after any change.

Give the anchor role to more than one engine and they race: every one is asked, and the first cue back is the one you see. Anchor cue lower down the page shows how that is going, per engine:

Beaten is the column that makes a slower-but-better engine visible. Without it only the fastest engine could ever collect votes, because nothing else left a trace — so the numbers would always agree with whichever engine was already winning. It also means the median is honest: measured over every valid cue an engine wrote, not only the races it happened to win.

Refused and Late are separate because they send you to different places. Refused is a model that cannot hold the format — try a different one. Late is a timeout or an error — check the credential and the network. One number for both sent people to rewrite a prompt that was never the problem.

Ordered by votes first and speed second.

Letting the votes decide

Under the table, once there is enough evidence, a line appears: "careful wrote 6 of the cues you voted good — 100% of the ones it got shown, against 20% for fast." One click applies it, and Not this one stops it being suggested again.

What applying it does is worth being precise about, because it is deliberately not what you might expect. It does not move the anchor role around. Your engines keep exactly the roles you gave them; the preference only decides which of the anchor-role engines is asked. The reason is that an engine holds one role, so promoting a winner would mean giving the old anchor some other job — and every version of that changes what your engines do or cost. Making it an answer engine bills on every question; disabling it stops whatever else it was for. Neither is a decision this should be making for you.

While a preference is set, the others are not asked at all — so they cost nothing and, equally, gather no new evidence. Let them all race again clears it, which is also how the comparison starts up again.

Nothing above 20 cues shown, 5 votes on the challenger, and a clear margin will be suggested at all. Below that the table just shows numbers, and the line says how far off it is.

Let the votes pick without asking me is off by default. With it on, the change happens between sessions and never during one — a cue engine swapped mid-interview is exactly the kind of surprise this should not be — and a notice says which engine, on what evidence, and how to undo it.

Some providers cannot take the last two roles: the Claude Code session, the MCP brain and the two voice agents all answer through one long-running conversation rather than a single completion, and a classifier or a cue engine needs the plain kind. The picker leaves those roles out rather than letting you choose one that would fail mid-call.

What each one costs, where you choose it

Every provider in the picker shows what it buys and what it costs the moment you select it — the unit it bills in, and what a 45-minute call actually consumes. The free allowance, the reference workload and anything unusual about the billing are folded underneath, and the date the figures were read is on the panel. The same numbers are in Your credentials and in whispr credentials; nothing on this screen keeps a price of its own, so a figure corrected once is corrected everywhere.

It is worth actually reading for the two voice-agent providers, whose bills are nothing like the token-priced engines. The Deepgram Voice Agent is billed by connection time — roughly $2.50 for a 45-minute call whether it answers once or twenty times, several times everything else put together. The Workers AI voice Worker is the opposite: on this surface no audio is billed in either direction, because the question goes in as text and speech is skipped, so a whole call is about 2,300 Neurons and fits inside Cloudflare's free day. The same Worker speaking in a practice run is about fourteen times as expensive per minute — see Practice.

Adding one

Pick the provider, give it a name, choose a role and name the model. If the provider needs a key you have not stored, the form says which one before you finish — and until it is stored that engine is skipped rather than failing the call. Anything OpenAI-compatible — a self-hosted proxy, Azure, Ollama — connects through the same OpenAI-compatible endpoint provider, so adding a provider is configuration rather than a new version of the app. A local endpoint such as Ollama needs no key at all.

Your own voice Worker

Choosing the Workers AI voice Worker provider adds one more field: the URL of the Worker you deployed to your own Cloudflare account. It is one field for one deployment — the same Worker serves this engine and the spoken practice interviewer — and the token you set on it goes under Your credentials as WHISPR_VOICE_TOKEN like any other secret. docs/voice-worker.md in the repository is the deployment procedure.

The Model field on that engine is a record rather than a control: which model answers is set on the Worker itself with wrangler, so what you type here is what names the answer column and the recorded test result. Keep it in step with the Worker; changing it here does not change the Worker.

The name cannot be changed

The name is the key everything else references: the test result recorded against it, whispr brain enable, the heading on each answer card. To rename an engine, add a new one and remove the old one — the editor offers no rename because a rename in place would quietly orphan all of that.

Models that return nothing

A few Cloudflare models return a perfectly successful response containing no text — the ones needing a paid plan, and reasoning models whose thinking never reaches the chat endpoint. Whispr substitutes a working model for those rather than leaving you with blank answers, and the editor says so at the moment you type one, with a button to make the substitution yourself.

Prep limit

How much of your prep material this one engine's prompt may carry, in characters. Leave it empty and it uses the provider's own default, which is conservative for the providers that could be anything from a 400k-token hosted model to an 8B running locally. Raise it if you know your model's context window is larger; an overflow is not a shorter answer, it is an error from that one engine mid-call.

Claude as the brain

If you already use Claude on this machine, it can be one of the answer engines: it answers with your own skills, files and tools behind it, alongside the provider engines rather than instead of them.

This section tells you whether a Claude session is actually attached and answering right now, which is the only thing that matters — it needs no credential, so "configured" is always true and would tell you nothing. Switch it on, and when nothing is attached it lists the three steps that connect one: two commands, and the sentence to say in a Claude session.

Your Whispr account

Sign in with your browser. If that hand-off does not work — a managed Mac, or another app holding the link — Paste a licence key signs you in exactly the same way.

This section says what your licence is, when it was last checked, and what to do if it has lapsed. If the app is locked, a new session cannot be started; a session already running is never interrupted, and everything you have recorded stays on this machine either way.

Bought Whispr on Gumroad? That is a different key from a different place, so it has its own button: Bought on Gumroad?, and you paste the licence key from your Gumroad receipt. It is checked with Gumroad and recorded on this machine, so it licenses Whispr whether or not you ever sign in — and signing in later cannot undo it.

This matters because the two are not interchangeable. Signing in creates a Whispr account, and an account that has only ever bought through Gumroad would otherwise look to us like an account that has bought nothing. Redeeming the key is what connects the two, so the app never tells somebody who has paid that they need to buy it.

Invites

When enough people you invited have subscribed, a credit comes off your next invoice. Once you are signed in, this section shows your invite link and the count so far — how many you invited, how many subscribed, how many more until the next credit.

Signed out there is no link, and that is not an oversight: only the account side knows who subscribed, so a code made up on this machine would look like a working invite link and credit nobody.

Add-ons

Under Account is Add-ons — extra methodologies, and they are free. They are switched on for everybody while we find out which ones people keep. There is nothing to buy and no key to paste.

The important thing to know about how they work: everything is already inside Whispr. A pack is not a download and not a plugin. The switch turns on content that shipped with the app, which is why it works offline, why there is nothing to install or keep updated, and why a pack cannot break when the app updates.

Nothing in the base app is behind one. Behavioural, technical, system-design and mixed interviews, and discovery, demo and pricing calls, are all included regardless. The packs are named methodologies for people who work that way:

Turning one off. Each has a switch. Off means its formats stop being offered when you choose the kind of round a meeting is; nothing is removed from your machine and turning it back on is instant.

It is worth switching off anything you will not use, and not only for a tidy list: if you are signed in to a Whispr account, which packs you have on is the one thing shared with us, and it is how we learn which of these are worth keeping. Your meetings, your prep and your answers never are — that is the promise on the first setup screen and it is unchanged.