diff --git a/.claude/skills/verify/SKILL.md b/.claude/skills/verify/SKILL.md
index 89a83b1b..9bb5b621 100644
--- a/.claude/skills/verify/SKILL.md
+++ b/.claude/skills/verify/SKILL.md
@@ -225,8 +225,8 @@ its profile. It keeps the vault and `.obsidian-e2e-artifacts/`. Delete
 
 - `.claude/skills/verify/net.mjs` runs as `watch`, `log` or `unwatch`. It logs
   every `fetch` and `requestUrl` call PodNotes makes, without query strings,
-  and answers ElevenLabs, Deepgram and OpenAI with a fixture provider while it
-  watches.
+  and answers ElevenLabs, Deepgram, OpenRouter and OpenAI with a fixture
+  provider while it watches.
 
 - `.claude/skills/verify/ui.mjs` sends trusted input through
   `obsidian dev:cdp`. Its verbs are `click <css> [--text <s>] [--right]`,
diff --git a/.claude/skills/verify/features/transcripts.md b/.claude/skills/verify/features/transcripts.md
index 7914999a..3e772f95 100644
--- a/.claude/skills/verify/features/transcripts.md
+++ b/.claude/skills/verify/features/transcripts.md
@@ -18,6 +18,7 @@ from `Transcript template`, and opens.
 - `transcript-settings` shows `Transcription provider`, the chosen provider's API key row alone, `Model`, `Speaker labels` and, while those are on, `Speaker label format`. `Speaker labels` is disabled for a model without them.
 - `transcript-elevenlabs` writes timestamped paragraphs with numbered speakers from one `scribe_v3` request. ElevenLabs gets the address of an episode a saved public feed lists, and the audio itself for a private feed's episode, a local file, and an address that carries a credential or is not public.
 - `transcript-deepgram` does the same with `nova-3`.
+- `transcript-openrouter` offers `Grok STT 2.0` (recommended), `ElevenLabs Scribe v2` and `MAI-Transcribe 2`, filtered by OpenRouter's public model catalog. Grok gets uploads as base64 JSON routed to xAI, Scribe v2 the address of a public episode, and an upload goes in parts of at most 18 MB and 1,800 s.
 - `transcript-openai` sends OpenAI the audio as `gpt-transcribe` uploads of at most 24 MB and 2,070 s, one at a time, and writes paragraphs without timestamps or speaker labels.
 - `transcript-existing` refuses a second run while the note exists.
 
@@ -32,13 +33,13 @@ Preconditions:
 
 - `FEED=$(node .claude/skills/verify/fixtures.mjs transcripts)` prints `http://podnotes.test:<port>/transcripts.xml`. Add `PodNotes Transcripts` through Settings as [feeds.md](./feeds.md) describes. Its episodes are `VTT Episode` (an HTML link, then a relative VTT link), `SRT Episode`, `JSON Episode`, `Untranscribed Episode` and `Broken Transcript Episode` (its VTT returns 404).
 - No `transcripts/PodNotes Transcripts/` notes exist yet.
-- `NET=node .claude/skills/verify/net.mjs`. Run `$NET watch` before each command, and again after an `app:reload`, which drops it. While it watches, the fixture provider answers ElevenLabs, Deepgram and OpenAI, so nothing is charged even with a key set.
-- A fake key is a precondition, not a user path. For ElevenLabs: `CLI eval code='app.secretStorage.setSecret("podnotes-elevenlabs-api-key-424242", "sk-verify-fixture-not-real"), app.plugins.plugins.podnotes.settings.elevenLabsSecretId = "podnotes-elevenlabs-api-key-424242", app.plugins.plugins.podnotes.saveSettings(), "key set"'`. Deepgram and OpenAI take `podnotes-deepgram-api-key-424242` in `deepgramSecretId` and `podnotes-openai-api-key-424242` in `openAISecretId`.
+- `NET=node .claude/skills/verify/net.mjs`. Run `$NET watch` before each command, and again after an `app:reload`, which drops it. While it watches, the fixture provider answers ElevenLabs, Deepgram, OpenRouter (its model catalog too) and OpenAI, so nothing is charged even with a key set.
+- A fake key is a precondition, not a user path. For ElevenLabs: `CLI eval code='app.secretStorage.setSecret("podnotes-elevenlabs-api-key-424242", "sk-verify-fixture-not-real"), app.plugins.plugins.podnotes.settings.elevenLabsSecretId = "podnotes-elevenlabs-api-key-424242", app.plugins.plugins.podnotes.saveSettings(), "key set"'`. Deepgram, OpenRouter and OpenAI take `podnotes-deepgram-api-key-424242` in `deepgramSecretId`, `podnotes-openrouter-api-key-424242` in `openRouterSecretId` and `podnotes-openai-api-key-424242` in `openAISecretId`.
 - Choose a provider in Settings by focusing the `Transcription provider` dropdown with `UI click` and stepping with `UI key ArrowDown` or `UI key ArrowUp`, or as a precondition with `CLI eval code='app.plugins.plugins.podnotes.settings.transcript.provider = "openai", app.plugins.plugins.podnotes.settings.transcript.model = "", app.plugins.plugins.podnotes.saveSettings(), "chosen"'`.
 
 - **Published.** Play `VTT Episode` ([player.md](./player.md)), then run `UI key Ctrl+p`, `UI type .prompt-input 'Transcribe current episode'` and `UI key Enter`. The exact command is the first suggestion; `--text 'Transcribe current episode'` matches both transcribe commands. The notices read `Queued "VTT Episode" for transcription. It will start automatically.` and, in the progress notice headed `Transcription: VTT Episode (00:00:00):`, `Saved the transcript the feed publishes.` `transcripts/PodNotes Transcripts/VTT Episode.md` opens. Its body starts `[00:00:00](obsidian://podnotes?episodeName=VTT%20Episode&url=...&time=0.48) From Potsdam in Brandenburg, Germany,`. `$NET log` lists `GET .../t/podnews.vtt` and nothing at `api.elevenlabs.io`, `api.deepgram.com` or `api.openai.com`. `node .claude/skills/verify/fixtures.mjs requests` has `/t/podnews.vtt`, not `/t/buzzcast.html`. Repeat with `SRT Episode` and `JSON Episode`.
 - **Seek.** Switch to Reading view and click a timestamp. `api.currentTime` lands on its time.
-- **Settings.** Open Settings > PodNotes. Under `Transcripts` a new vault shows `Transcription provider` on `ElevenLabs`, `ElevenLabs API key`, `Model` on `Recommended (Scribe v3)`, `Speaker labels` on, `Speaker label format`, then the path and template. Choosing `Deepgram` or `OpenAI` swaps the key row for that provider's and the model list for its models. On `OpenAI` the `Speaker labels` row is disabled and reads `GPT Transcribe does not label speakers.`
+- **Settings.** Open Settings > PodNotes. Under `Transcripts` a new vault shows `Transcription provider` on `ElevenLabs`, `ElevenLabs API key`, `Model` on `Recommended (Scribe v3)`, `Speaker labels` on, `Speaker label format`, then the path and template. Choosing `Deepgram`, `OpenRouter` or `OpenAI` swaps the key row for that provider's and the model list for its models. On `OpenRouter` the `Model` row offers `Recommended (Grok STT 2.0)`, `Grok STT 2.0`, `ElevenLabs Scribe v2` and `MAI-Transcribe 2`, and `$NET log` shows one `GET https://openrouter.ai/api/v1/models` with no `Authorization`. A model the catalog dates reads `<label>, ends <date>`, and a chosen model it no longer lists reads `<label>, no longer offered`. On `OpenAI` the `Speaker labels` row is disabled and reads `GPT Transcribe does not label speakers.`
 - **No published transcript.** Play `Untranscribed Episode` and run the command with no key. The notice is `Select or create an ElevenLabs API key in the transcript settings on this device.` and no note appears.
 - **ElevenLabs.** With the fake ElevenLabs key, the fixture provider answers with two speakers, the second 12 s in, so the note reads `[00:00:00](...) **1:** This text came from the fixture provider.` and `[00:00:12](...) **2:** A second speaker answers.`
     - Public. Play `Fixture Episode 1` of `PodNotes Fixture` and run the audio command. `$NET log` shows one `POST https://api.elevenlabs.io/v1/speech-to-text` with a `multipart/form-data` `contentType`, under 1,000 `uploadBytes` and the episode's address as `sourceUrl`, and no request for `/episode-1.wav` after the command.
@@ -50,10 +51,14 @@ Preconditions:
 - **Deepgram.** Choose `Deepgram` with its fake key. The notes read as for ElevenLabs.
     - Public. `$NET log` shows one `POST https://api.deepgram.com/v1/listen` with `contentType` `application/json` and under 100 `uploadBytes`, and no request for `/episode-1.wav` after the command.
     - Private. `$NET log` shows a `GET` for `/p/episode-1.wav`, then one `POST https://api.deepgram.com/v1/listen` with `contentType` `audio/wav` and the WAV's 960,044 `uploadBytes`.
+- **OpenRouter.** Choose `OpenRouter` with its fake key. The notes read as for ElevenLabs.
+    - Scribe v2, public. Choose `ElevenLabs Scribe v2`, play `Fixture Episode 1` of `PodNotes Fixture` and run the audio command. `$NET log` shows the catalog `GET`, then one `POST https://openrouter.ai/api/v1/audio/transcriptions` with `contentType` `application/json`, under 1,000 `uploadBytes` and the episode's address as `sourceUrl`, and no request for `/episode-1.wav` after the command.
+    - Grok STT 2.0. On `Recommended (Grok STT 2.0)`, play `Fixtures/Local Fixture.wav` and run the audio command. The `POST` is `application/json` with about 4/3 of the file's bytes, its audio in base64, and no `sourceUrl`.
+    - In parts. Write the 70 min MP3 from the OpenAI steps below, play it and run the audio command on Grok. `$NET log` shows three `POST https://openrouter.ai/api/v1/audio/transcriptions` entries of about 1.9 MB each, one after the other. The fixture answers each with two speakers, so the note numbers six, and the progress notice ends with `OpenRouter transcribed this episode in 3 parts, and speaker labels restart in each, so one person can have several labels.`
 - **OpenAI.** Choose `OpenAI` with its fake key. `Untranscribed Episode` downloads its WAV and `$NET log` shows a `POST https://api.openai.com/v1/audio/transcriptions` answered by the fixture provider. The note holds the fixture text with no timestamps.
     - In parts. Write an MP3 longer than 2,070 s into the vault, for example 70 min in 4 MB: `ffmpeg -f lavfi -i sine=frequency=440:duration=4200 -ac 1 -ar 8000 -b:a 8k "$VAULT/Fixtures/Long Fixture.mp3"`. Play it ([local-files.md](./local-files.md)) and run the audio command. `$NET log` shows three `POST https://api.openai.com/v1/audio/transcriptions` entries of about 1.4 MB each, one after the other, and the note holds the fixture text three times with no timestamps.
-    - Speaker labels. With `Speaker labels` on, as in a library that labelled speakers with OpenAI on 2.24.0, the progress notice ends with `Saved without speaker labels, because OpenAI does not label speakers. These providers do: ElevenLabs, Deepgram.` and stays until clicked.
-- **A 2.24.0 library.** Write a 2.24.0 `data.json` state into the vault (`transcript.diarization` with `enabled` and `provider`, no `transcript.provider`), run `CLI --reload`, and read `app.plugins.plugins.podnotes.settings.transcript.provider`: `deepgram` for speaker labels with Deepgram, `openai` for speaker labels with OpenAI or a linked OpenAI key, `elevenlabs` otherwise. `data.json` is unchanged until the next save, which adds `transcript.provider`, `transcript.model` and `elevenLabsSecretId` and leaves `transcript.diarization.provider` as it was.
+    - Speaker labels. With `Speaker labels` on, as in a library that labelled speakers with OpenAI on 2.24.0, the progress notice ends with `Saved without speaker labels, because OpenAI does not label speakers. These providers do: ElevenLabs, Deepgram, OpenRouter.` and stays until clicked.
+- **A 2.24.0 library.** Write a 2.24.0 `data.json` state into the vault (`transcript.diarization` with `enabled` and `provider`, no `transcript.provider`), run `CLI --reload`, and read `app.plugins.plugins.podnotes.settings.transcript.provider`: `deepgram` for speaker labels with Deepgram, `openai` for speaker labels with OpenAI or a linked OpenAI key, `elevenlabs` otherwise. `data.json` is unchanged until the next save, which adds `transcript.provider`, `transcript.model`, `elevenLabsSecretId` and `openRouterSecretId` and leaves `transcript.diarization.provider` as it was.
 - **Proof.** Screenshot the opened note (`npm run capture:e2e-obsidian -- screenshot .obsidian-e2e-artifacts/transcripts/note.png`), keep the note text, `$NET log` and `fixtures.mjs requests` for every run, and read `data.json` to show no new field.
 
 ## Gotchas
@@ -62,7 +67,7 @@ Preconditions:
 - To test the feed cache across a restart, reload inside Obsidian (`CLI --reload`, or `app:reload`). `npm run stop:e2e-obsidian` deletes the profile, and the cache with it.
 
 - `net.mjs` sees `window.fetch` and `requestUrl`. The player streams audio through the media element, which only `fixtures.mjs requests` shows.
-- A secret id must be `podnotes-<provider>-api-key` or `podnotes-<provider>-api-key-<n>`, where the provider is `elevenlabs`, `deepgram` or `openai`. Any other id reads as missing on this device.
+- A secret id must be `podnotes-<provider>-api-key` or `podnotes-<provider>-api-key-<n>`, where the provider is `elevenlabs`, `deepgram`, `openrouter` or `openai`. Any other id reads as missing on this device.
 - The progress notice hides about 5 s after a transcript is saved. A failure, or a transcript saved with a warning, stays until clicked. Notices also cover the PodNotes view's head and the full player's collapse button, and `ui.mjs` refuses a covered click, so dismiss them first.
 - After editing `fixtures.mjs`, run `fixtures.mjs stop` before `fixtures.mjs transcripts`. A running server keeps serving the old routes.
 - Every fixture transcript cue falls inside the 60 s WAV, so its links seek within the audio.
diff --git a/.claude/skills/verify/net.mjs b/.claude/skills/verify/net.mjs
index 8f01cacc..37eab3ca 100644
--- a/.claude/skills/verify/net.mjs
+++ b/.claude/skills/verify/net.mjs
@@ -2,9 +2,10 @@
 // Network log for this worktree's Obsidian instance, with a fixture provider in
 // place of the paid transcription APIs.
 //
-//   node .claude/skills/verify/net.mjs watch     start a fresh log; answer ElevenLabs, Deepgram and OpenAI locally
+//   node .claude/skills/verify/net.mjs watch     start a fresh log; answer ElevenLabs, Deepgram, OpenRouter
+//                                                and OpenAI locally, OpenRouter's model catalog included
 //   node .claude/skills/verify/net.mjs log       print each request as JSON, oldest first; a path only
-//                                                for the fixture server and the three providers
+//                                                for the fixture server and the four providers
 //   node .claude/skills/verify/net.mjs unwatch   restore fetch and requestUrl
 //
 // PodNotes sends its requests (feeds, audio, transcripts, the providers)
@@ -33,7 +34,20 @@ const instance = resolveInstanceOptions(
 const CALL_TIMEOUT_MS = 15000;
 const FIXTURE_TRANSCRIPTION = "This text came from the fixture provider.";
 const FIXTURE_REPLY = "A second speaker answers.";
-const PATH_HOSTS = [FIXTURE_HOST, "api.elevenlabs.io", "api.deepgram.com", "api.openai.com"];
+const PATH_HOSTS = [
+	FIXTURE_HOST,
+	"api.elevenlabs.io",
+	"api.deepgram.com",
+	"openrouter.ai",
+	"api.openai.com",
+];
+const OPENROUTER_TRANSCRIPTIONS = "https://openrouter.ai/api/v1/audio/transcriptions";
+const OPENROUTER_CATALOG = "https://openrouter.ai/api/v1/models?";
+const OPENROUTER_MODELS = [
+	"x-ai/grok-stt-2.0",
+	"elevenlabs/scribe-v2",
+	"microsoft/mai-transcribe-2",
+];
 
 /** @param {string} code */
 async function evaluate(code) {
@@ -92,10 +106,16 @@ const WATCH = `(() => {
 		return index === 0 ? [word] : [{ text: " ", type: "spacing", start, end: start, speaker_id: word.speaker_id }, word];
 	});
 	const elevenlabs = { language_code: "eng", text: text + " " + reply, words: [...scribeWords(text, 0, 0), ...scribeWords(reply, 1, 12)] };
-	// A multipart request that names an address in place of a file is a few hundred bytes.
+	// OpenRouter's verbose_json words, at the same times, with numbered speakers.
+	const openRouterWords = (sentence, speaker, from) => words(sentence, speaker, from).map(({ punctuated_word, start, end }) => ({ word: punctuated_word, start, end, speaker, speaker_label: "speaker_" + speaker, confidence: 0.99 }));
+	const openrouter = { text: text + " " + reply, words: [...openRouterWords(text, 0, 0), ...openRouterWords(reply, 1, 12)] };
+	const openrouterCatalog = { data: ${jsLiteral(OPENROUTER_MODELS)}.map((id) => ({ id, expiration_date: null })) };
+	// A request that names an address in place of a file is a few hundred bytes: multipart
+	// with source_url for ElevenLabs, JSON with input_audio.url for OpenRouter.
 	const namedAddress = (request) => {
 		if (!(request.body?.byteLength < 4096)) return undefined;
-		const match = /name="source_url"\\r\\n\\r\\n([^\\r]+)/.exec(new TextDecoder().decode(request.body));
+		const body = new TextDecoder().decode(request.body);
+		const match = /name="source_url"\\r\\n\\r\\n([^\\r]+)/.exec(body) ?? /"input_audio":\\{"url":"([^"]+)"/.exec(body);
 		return match ? logged(match[1]) : undefined;
 	};
 	const originalFetch = window.fetch;
@@ -116,7 +136,11 @@ const WATCH = `(() => {
 					? deepgram
 					: request.url.startsWith("https://api.elevenlabs.io/")
 						? elevenlabs
-						: null;
+						: request.url === ${jsLiteral(OPENROUTER_TRANSCRIPTIONS)}
+							? openrouter
+							: request.url.startsWith(${jsLiteral(OPENROUTER_CATALOG)})
+								? openrouterCatalog
+								: null;
 			if (answer) {
 				entries.push({ via: "requestUrl", method, url: logged(request.url), answeredBy: "fixture provider", contentType: request.contentType, uploadBytes: request.body?.byteLength ?? 0, sourceUrl: namedAddress(request) });
 				const body = new TextEncoder().encode(JSON.stringify(answer)).buffer;
diff --git a/AGENTS.md b/AGENTS.md
index 5d55bc14..aa22c9d5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -62,7 +62,7 @@ svelte-check's native API path passes when a tsconfig matches no files, which
 `check:a11y` in temporary workspaces and requires it to fail on that case and
 when the native compiler cannot start.
 
-After `npm run build`, `npm run size` enforces 330,000 raw bytes and 104,866 gzip bytes at level 9 for root `main.js` in the Test workflow's Build and sizes worker. `npm run size:data` reports a synthetic v2 stress library with 50 feeds, 2,000 history entries, and 200 saved episodes from frozen NPR metadata, including duplicated snapshots. Its 1.5 MB document goal is advisory. Pass an additive candidate JSON path to report optional-field overhead without changing existing data. In the isolated Obsidian instance, `npm run count:writes -- start`, `report`, and `stop` record writes to PodNotes' exact `data.json` path. Stop the recorder before stopping the instance, because recorder commands start a stopped instance; plugin reloads invalidate its counts.
+After `npm run build`, `npm run size` enforces 330,000 raw bytes and 106,162 gzip bytes at level 9 for root `main.js` in the Test workflow's Build and sizes worker. `npm run size:data` reports a synthetic v2 stress library with 50 feeds, 2,000 history entries, and 200 saved episodes from frozen NPR metadata, including duplicated snapshots. Its 1.5 MB document goal is advisory. Pass an additive candidate JSON path to report optional-field overhead without changing existing data. In the isolated Obsidian instance, `npm run count:writes -- start`, `report`, and `stop` record writes to PodNotes' exact `data.json` path. Stop the recorder before stopping the instance, because recorder commands start a stopped instance; plugin reloads invalidate its counts.
 
 Before opening a PR or cutting a release, run the CI-equivalent checks locally:
 
diff --git a/obsidian-e2e.config.mjs b/obsidian-e2e.config.mjs
index c28d7008..6a4ad568 100644
--- a/obsidian-e2e.config.mjs
+++ b/obsidian-e2e.config.mjs
@@ -115,6 +115,7 @@ export default {
 		openAISecretId: "",
 		deepgramSecretId: "",
 		elevenLabsSecretId: "",
+		openRouterSecretId: "",
 		transcript: {
 			path: "transcripts/{{podcast}}/{{title}}.md",
 			template: "# {{title}}\n\nPodcast: {{podcast}}\nDate: {{date}}\n\n{{transcript}}",
diff --git a/scripts/size-baseline.md b/scripts/size-baseline.md
index 7feb5b56..1bb93801 100644
--- a/scripts/size-baseline.md
+++ b/scripts/size-baseline.md
@@ -12,7 +12,7 @@ main.js raw: 307131 bytes; budget 330000 bytes; 22869 bytes remaining
 main.js gzip (level 9): 97161 bytes; budget 100000 bytes; 2839 bytes remaining
 ```
 
-The gzip budget is now 104,866 bytes. On 2026-10-14 it rose from 100,000 for
+The gzip budget is now 106,162 bytes. On 2026-10-14 it rose from 100,000 for
 the full player's Transcript panel, which the owner approved at about 1.9 KB
 and which measured 2,576 bytes. The coordinator set 103,000 to keep the
 panel's Find and Follow chip and to leave room for fixes in flight. The
@@ -44,6 +44,16 @@ main.js raw: 320988 bytes; budget 330000 bytes; 9012 bytes remaining
 main.js gzip (level 9): 104661 bytes; budget 104866 bytes; 205 bytes remaining
 ```
 
+On 2026-11-14 it rose again, from 104,866, for OpenRouter. The branch it builds
+on measured 104,706 bytes. The OpenRouter provider, its model catalog filter
+and the speaker label warnings measured 1,296 more. The budget rose by those
+1,296 bytes. With them:
+
+```text
+main.js raw: 325002 bytes; budget 330000 bytes; 4998 bytes remaining
+main.js gzip (level 9): 106002 bytes; budget 106162 bytes; 160 bytes remaining
+```
+
 Gzip uses Node's `gzipSync` at level 9, without a filename or timestamp.
 Budgets use decimal bytes. The brief's 96,533-byte reference is unexplained.
 This report fixes the compressor instead of comparing compressed sizes across
diff --git a/scripts/size.mjs b/scripts/size.mjs
index e7461f2a..c7a49ba6 100644
--- a/scripts/size.mjs
+++ b/scripts/size.mjs
@@ -10,7 +10,7 @@ try {
 	if (!bundle.length) throw new Error(`${path} is empty. Run npm run build first.`);
 	const measurements = [
 		{ name: "raw", bytes: bundle.length, budget: 330_000 },
-		{ name: "gzip (level 9)", bytes: gzipSync(bundle, { level: 9 }).length, budget: 104_866 },
+		{ name: "gzip (level 9)", bytes: gzipSync(bundle, { level: 9 }).length, budget: 106_162 },
 	];
 	const rows = measurements.map(({ name, bytes, budget }) => {
 		const overage = Math.max(0, bytes - budget);
diff --git a/scripts/size.test.ts b/scripts/size.test.ts
index af720d65..32177dd8 100644
--- a/scripts/size.test.ts
+++ b/scripts/size.test.ts
@@ -30,7 +30,7 @@ describe("bundle budget CLI", () => {
 		const result = check("gzip.js", randomBytes(110_000));
 		expect(result.status).toBe(1);
 		expect(result.stdout).toMatch(
-			/gzip \(level 9\): \d+ bytes; budget 104866 bytes; OVER by \d+ bytes/,
+			/gzip \(level 9\): \d+ bytes; budget 106162 bytes; OVER by \d+ bytes/,
 		);
 		expect(result.stdout).toContain("budget 330000 bytes; 220000 bytes remaining");
 	});
diff --git a/src/constants.ts b/src/constants.ts
index 6f3ed6ed..ba5eeca4 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -159,6 +159,7 @@ export const DEFAULT_SETTINGS: IPodNotesSettings = {
 	openAISecretId: "",
 	deepgramSecretId: "",
 	elevenLabsSecretId: "",
+	openRouterSecretId: "",
 	transcript: {
 		path: "transcripts/{{podcast}}/{{title}}.md",
 		template: "# {{title}}\n\nPodcast: {{podcast}}\nDate: {{date}}\n\n{{transcript}}",
diff --git a/src/main.persistence.test.ts b/src/main.persistence.test.ts
index 1dfe647c..8764c4c8 100644
--- a/src/main.persistence.test.ts
+++ b/src/main.persistence.test.ts
@@ -410,6 +410,7 @@ function savedByThisVersion(released: Record<string, unknown>): Record<string, u
 		headsetPreviousTrack: "captureTimestamp",
 		headsetNextTrack: "skipForward",
 		elevenLabsSecretId: "",
+		openRouterSecretId: "",
 		transcript: { ...(released.transcript as object), provider: "elevenlabs", model: "" },
 	};
 	delete data.feedCache;
diff --git a/src/persistence/podNotesData.test.ts b/src/persistence/podNotesData.test.ts
index 28d1a296..e3137af8 100644
--- a/src/persistence/podNotesData.test.ts
+++ b/src/persistence/podNotesData.test.ts
@@ -622,6 +622,7 @@ describe("PodNotes data schema", () => {
 			headsetNextTrack: "skipForward",
 			libraryId: "",
 			elevenLabsSecretId: "",
+			openRouterSecretId: "",
 			transcript: { ...rest.transcript, provider: "elevenlabs", model: "" },
 		});
 	});
@@ -648,8 +649,8 @@ describe("PodNotes data schema", () => {
 				JSON.stringify(encodePodNotesData(decoded.settings, decoded.unknownFields)),
 			);
 		};
-		/** The root field this version adds to a 2.24.0 library when it saves. */
-		const ADDED = { elevenLabsSecretId: "" };
+		/** The root fields this version adds to a 2.24.0 library when it saves. */
+		const ADDED = { elevenLabsSecretId: "", openRouterSecretId: "" };
 
 		it.each([
 			[
@@ -731,7 +732,7 @@ describe("PodNotes data schema", () => {
 			],
 			["no key", structuredClone(released2240)],
 		])(
-			"a save of a library with %s adds the provider, the model and an empty ElevenLabs key reference, and changes nothing else",
+			"a save of a library with %s adds the provider, the model and empty ElevenLabs and OpenRouter key references, and changes nothing else",
 			(_state, data) => {
 				const decoded = decodePodNotesData(structuredClone(data));
 				const { provider, model } = decoded.settings.transcript;
@@ -772,16 +773,16 @@ describe("PodNotes data schema", () => {
 				...structuredClone(released2240),
 				transcript: {
 					...released2240.transcript,
-					provider: "openrouter",
-					model: "x-ai/grok-stt-2.0",
+					provider: "assemblyai",
+					model: "universal-3-6-pro",
 				},
 			};
 
 			const decoded = decodePodNotesData(structuredClone(file));
 
 			expect(decoded.settings.transcript).toMatchObject({
-				provider: "openrouter",
-				model: "x-ai/grok-stt-2.0",
+				provider: "assemblyai",
+				model: "universal-3-6-pro",
 			});
 			expect(decoded.warnings).toEqual([]);
 			expect(decoded.changed).toBe(false);
diff --git a/src/services/CredentialRepository.test.ts b/src/services/CredentialRepository.test.ts
index a3a832e7..7a9bfd2d 100644
--- a/src/services/CredentialRepository.test.ts
+++ b/src/services/CredentialRepository.test.ts
@@ -32,15 +32,18 @@ describe("CredentialRepository", () => {
 				openAI: "  sk-openai  ",
 				deepgram: "dg-key",
 				elevenLabs: "el-key",
+				openRouter: "or-key",
 			}),
 		).toEqual({
 			openAISecretId: "podnotes-openai-api-key",
 			deepgramSecretId: "podnotes-deepgram-api-key",
 			elevenLabsSecretId: "podnotes-elevenlabs-api-key",
+			openRouterSecretId: "podnotes-openrouter-api-key",
 		});
 		expect(values.get("podnotes-openai-api-key")).toBe("sk-openai");
 		expect(values.get("podnotes-deepgram-api-key")).toBe("dg-key");
 		expect(values.get("podnotes-elevenlabs-api-key")).toBe("el-key");
+		expect(values.get("podnotes-openrouter-api-key")).toBe("or-key");
 		expect(api.getSecret).toHaveBeenCalledWith("podnotes-openai-api-key");
 	});
 
diff --git a/src/services/TranscriptionService.test.ts b/src/services/TranscriptionService.test.ts
index ac735217..e61a2d4c 100644
--- a/src/services/TranscriptionService.test.ts
+++ b/src/services/TranscriptionService.test.ts
@@ -163,20 +163,20 @@ describe("TranscriptionService", () => {
 			"%s refuses a provider this version does not have, and sends nothing",
 			async (_command, run) => {
 				const plugin = createMockPlugin({
-					provider: "openrouter",
-					model: "x-ai/grok-stt-2.0",
+					provider: "assemblyai",
+					model: "universal-3-6-pro",
 				});
 
 				await run(new TranscriptionService(plugin));
 
 				expect(noticeMessages).toEqual([
-					"This version of PodNotes cannot transcribe with openrouter. Update PodNotes, or choose another provider in the transcript settings.",
+					"This version of PodNotes cannot transcribe with assemblyai. Update PodNotes, or choose another provider in the transcript settings.",
 				]);
 				expect(getEpisodeAudioBufferMock).not.toHaveBeenCalled();
 				expect(providerMock).not.toHaveBeenCalled();
 				expect(plugin.settings.transcript).toMatchObject({
-					provider: "openrouter",
-					model: "x-ai/grok-stt-2.0",
+					provider: "assemblyai",
+					model: "universal-3-6-pro",
 				});
 			},
 		);
@@ -486,7 +486,7 @@ describe("TranscriptionService", () => {
 				await vi.advanceTimersByTimeAsync(60 * 60_000);
 
 				expect(String(setMessage.mock.calls.at(-1)?.[0])).toMatch(
-					/\n\nSaved without speaker labels, because OpenAI does not label speakers\. These providers do: ElevenLabs, Deepgram\.$/,
+					/\n\nSaved without speaker labels, because OpenAI does not label speakers\. These providers do: ElevenLabs, Deepgram, OpenRouter\.$/,
 				);
 				expect(hide).not.toHaveBeenCalled();
 				expect(savedNote(plugin)).toBe("# Test Episode\n\nHello there. Hi!");
@@ -1220,8 +1220,426 @@ describe("TranscriptionService", () => {
 			},
 		);
 	});
+
+	describe("an OpenRouter transcript", () => {
+		const TRANSCRIPTIONS = "https://openrouter.ai/api/v1/audio/transcriptions";
+		const CATALOG = "https://openrouter.ai/api/v1/models?output_modalities=transcription";
+		const HOUR_MS = 60 * 60 * 1000;
+		const audio = new Uint8Array(2048).map((_, index) => (index * 13) % 241);
+		const useOpenRouter = (
+			overrides: { model?: string; speakers?: boolean; feeds?: FeedRepository } = {},
+		) => {
+			getEpisodeAudioBufferMock.mockResolvedValue({ buffer: audio.buffer, extension: "mp3" });
+			return createMockPlugin({
+				provider: "openrouter",
+				openRouterKey: "openrouter-key",
+				speakers: true,
+				...overrides,
+			});
+		};
+		/** A word as OpenRouter's verbose_json lists it, with a speaker when one is given. */
+		const word = (text: string, start: number, end: number, speaker?: number) => ({
+			word: text,
+			start,
+			end,
+			confidence: 0.99,
+			...(speaker !== undefined && { speaker, speaker_label: `speaker_${speaker}` }),
+		});
+		const answers = {
+			text: "Hello there. [laughter] Hi!",
+			duration: 11,
+			words: [
+				word("Hello", 1.2, 1.5, 0),
+				word("there.", 1.5, 1.9, 0),
+				{ ...word("[laughter]", 2, 3, 0), type: "audio_event" },
+				word("Hi!", 10.16, 10.5, 1),
+			],
+		};
+		/** OpenRouter's public catalog, listing each model with its end date or null. */
+		const catalog = (models: Record<string, string | null>) => ({
+			data: Object.entries(models).map(([id, expiration_date]) => ({
+				id,
+				name: id,
+				expiration_date,
+				endpoints: ["/api/v1/audio/transcriptions"],
+			})),
+		});
+		const EVERY_MODEL = catalog({
+			"x-ai/grok-stt-2.0": null,
+			"x-ai/grok-stt-1.0": "2026-11-15",
+			"elevenlabs/scribe-v2": null,
+			"microsoft/mai-transcribe-2": null,
+		});
+		/** Answers the catalog with `listed`, and each transcription request with `answer`. */
+		const openRouter = (
+			answer: (request: RequestUrlParam) => Response = () => Response.json(answers),
+			listed: unknown = EVERY_MODEL,
+		) =>
+			providerMock.mockImplementation(async (request) =>
+				request.url === CATALOG ? Response.json(listed) : answer(request),
+			);
+		/** The transcription requests the jobs sent, oldest first. */
+		const sent = () =>
+			providerMock.mock.calls
+				.map(([request]) => request)
+				.filter(({ url }) => url === TRANSCRIPTIONS);
+		const catalogReads = () =>
+			providerMock.mock.calls.filter(([request]) => request.url === CATALOG).length;
+		const sentJson = (request: RequestUrlParam) =>
+			JSON.parse(new TextDecoder().decode(sentBytes(request)));
+		const fields = async (request: RequestUrlParam) =>
+			Object.fromEntries(
+				[...(await sentForm(request))].filter(([, value]) => typeof value === "string"),
+			);
+		const sentModel = async (request: RequestUrlParam) =>
+			request.contentType === "application/json"
+				? sentJson(request).model
+				: (await sentForm(request)).get("model");
+		const link = (time: string) =>
+			`obsidian://podnotes?episodeName=Test%20Episode&url=https%3A%2F%2Fexample.com%2Ffeed.xml&time=${time}`;
+		const labeled = `# Test Episode\n\n[00:00:01](${link("1.2")}) **1:** Hello there.\n\n[00:00:10](${link("10.16")}) **2:** Hi!`;
+		const unlabeled = `# Test Episode\n\n[00:00:01](${link("1.2")}) Hello there.\n\n[00:00:10](${link("10.16")}) Hi!`;
+
+		test("Grok STT 2.0, the recommended model, gets even a public episode as base64 JSON, routed to xAI and asked there for speaker labels", async () => {
+			openRouter();
+			const plugin = useOpenRouter({ feeds: savedFeedRepository(publicFeed, [mockEpisode]) });
+
+			await expect(finalNotice(plugin)).resolves.toBe("Transcription completed and saved.");
+
+			expect(getEpisodeAudioBufferMock).toHaveBeenCalledOnce();
+			expect(sent()).toHaveLength(1);
+			const [request] = sent();
+			expect(request.method).toBe("POST");
+			expect(request.headers).toEqual({ Authorization: "Bearer openrouter-key" });
+			expect(request.contentType).toBe("application/json");
+			expect(sentJson(request)).toEqual({
+				model: "x-ai/grok-stt-2.0",
+				input_audio: { data: Buffer.from(audio).toString("base64"), format: "mp3" },
+				response_format: "verbose_json",
+				timestamp_granularities: ["word", "segment"],
+				provider: { only: ["xai"], options: { xai: { diarize: true } } },
+			});
+			expect(savedNote(plugin)).toBe(labeled);
+		});
+
+		test.each(["elevenlabs/scribe-v2", "microsoft/mai-transcribe-2"])(
+			"%s gets an upload as multipart, asked for speaker labels beside the model",
+			async (model) => {
+				openRouter();
+				const plugin = useOpenRouter({ model });
+
+				await transcribe(plugin);
+
+				expect(sent()).toHaveLength(1);
+				const [request] = sent();
+				expect(request.headers).toEqual({ Authorization: "Bearer openrouter-key" });
+				expect(await fields(request)).toEqual({
+					model,
+					response_format: "verbose_json",
+					"timestamp_granularities[]": "word",
+					diarize: "true",
+				});
+				expect(new Uint8Array(await (await sentFile(request)).arrayBuffer())).toEqual(
+					audio,
+				);
+				expect(savedNote(plugin)).toBe(labeled);
+			},
+		);
+
+		test.each(["x-ai/grok-stt-2.0", "elevenlabs/scribe-v2", "microsoft/mai-transcribe-2"])(
+			"with speaker labels off, %s is asked for none, and the note names no speaker",
+			async (model) => {
+				openRouter();
+				const plugin = useOpenRouter({ model, speakers: false });
+
+				await expect(finalNotice(plugin)).resolves.toBe(
+					"Transcription completed and saved.",
+				);
+
+				expect(sent()).toHaveLength(1);
+				expect(sentText(sent()[0])).not.toContain("diarize");
+				expect(savedNote(plugin)).toBe(unlabeled);
+			},
+		);
+
+		test.each(["elevenlabs/scribe-v2", "microsoft/mai-transcribe-2"])(
+			"with speaker labels off, %s is still asked for word times, which OpenRouter sends only when asked",
+			async (model) => {
+				openRouter((request) =>
+					Response.json(
+						/timestamp_granularities|diarize/.test(sentText(request))
+							? {
+									...answers,
+									words: answers.words.map(
+										({ speaker: _speaker, speaker_label: _label, ...rest }) =>
+											rest,
+									),
+								}
+							: {
+									text: answers.text,
+									duration: 11,
+									segments: [{ id: 0, start: 0, end: 11, text: answers.text }],
+								},
+					),
+				);
+				const plugin = useOpenRouter({ model, speakers: false });
+
+				await expect(finalNotice(plugin)).resolves.toBe(
+					"Transcription completed and saved.",
+				);
+				expect(savedNote(plugin)).toBe(unlabeled);
+			},
+		);
+
+		test("Scribe v2 uploads the episode once when OpenRouter's provider cannot download its address", async () => {
+			openRouter((request) =>
+				request.contentType === "application/json"
+					? Response.json(
+							{
+								error: {
+									message:
+										"Provider could not download input_audio.url; ensure it is publicly reachable and serves a supported audio file",
+									code: 400,
+								},
+							},
+							{ status: 400 },
+						)
+					: Response.json(answers),
+			);
+			const plugin = useOpenRouter({
+				model: "elevenlabs/scribe-v2",
+				feeds: savedFeedRepository(publicFeed, [mockEpisode]),
+			});
+
+			await expect(finalNotice(plugin)).resolves.toBe("Transcription completed and saved.");
+
+			expect(sent().map(({ contentType }) => contentType === "application/json")).toEqual([
+				true,
+				false,
+			]);
+			expect(getEpisodeAudioBufferMock).toHaveBeenCalledOnce();
+			expect(savedNote(plugin)).toBe(labeled);
+		});
+
+		test("Scribe v2 takes a public episode by its address in one request, and its audio is never loaded", async () => {
+			openRouter();
+			const plugin = useOpenRouter({
+				model: "elevenlabs/scribe-v2",
+				feeds: savedFeedRepository(publicFeed, [mockEpisode]),
+			});
+
+			await expect(finalNotice(plugin)).resolves.toBe("Transcription completed and saved.");
+
+			expect(getEpisodeAudioBufferMock).not.toHaveBeenCalled();
+			expect(sent()).toHaveLength(1);
+			const [request] = sent();
+			expect(request.headers).toEqual({ Authorization: "Bearer openrouter-key" });
+			expect(request.contentType).toBe("application/json");
+			expect(sentJson(request)).toEqual({
+				model: "elevenlabs/scribe-v2",
+				input_audio: { url: "https://example.com/episode.mp3", format: "mp3" },
+				response_format: "verbose_json",
+				timestamp_granularities: ["word"],
+				diarize: true,
+			});
+			expect(savedNote(plugin)).toBe(labeled);
+		});
+
+		test("a 40 MB episode goes in parts of at most 18 MB and 1,800 s, one at a time, timed to the millisecond from the episode's start", async () => {
+			const stream = MP3_STREAMS.mpeg1At96Kbps;
+			const frames = Math.ceil(40_000_000 / stream.frameBytes);
+			getEpisodeAudioBufferMock.mockResolvedValue({
+				buffer: mp3Bytes(stream, frames).buffer,
+				extension: "mp3",
+			});
+			const partBytes: number[] = [];
+			openRouter((request) => {
+				partBytes.push(
+					Buffer.from(sentJson(request).input_audio.data, "base64").byteLength,
+				);
+				return Response.json({ words: [word(`Part ${partBytes.length}.`, 1, 1.5)] });
+			});
+			const plugin = createMockPlugin({
+				provider: "openrouter",
+				openRouterKey: "openrouter-key",
+			});
+
+			await expect(finalNotice(plugin)).resolves.toBe("Transcription completed and saved.");
+
+			expect(partBytes.length).toBeGreaterThan(2);
+			expect(partBytes.reduce((sum, bytes) => sum + bytes)).toBe(frames * stream.frameBytes);
+			for (const bytes of partBytes) {
+				expect(bytes).toBeLessThanOrEqual(18_000_000);
+				expect(mp3Seconds(stream, bytes)).toBeLessThanOrEqual(1800);
+			}
+			// Each part's word is 1 s into it.
+			const expected = partBytes.map(
+				(_, index) =>
+					Math.round((mp3Seconds(stream, sumOf(partBytes.slice(0, index))) + 1) * 1000) /
+					1000,
+			);
+			const note = savedNote(plugin);
+			const times = [...note.matchAll(/time=([\d.]+)\)/g)].map(([, time]) => time);
+			expect(times).toEqual(expected.map(String));
+			expect(note).toContain(`Part ${partBytes.length}.`);
+		});
+
+		test("labels from two parts never name the same speaker, and the notice says labels restart in each", async () => {
+			getEpisodeAudioBufferMock.mockResolvedValue(twoPartAudio());
+			openRouter(() =>
+				Response.json({ words: [word("Hello.", 1, 1.5, 0), word("Hi.", 10, 10.5, 1)] }),
+			);
+			const plugin = createMockPlugin({
+				provider: "openrouter",
+				openRouterKey: "openrouter-key",
+				speakers: true,
+			});
+
+			await expect(finalNotice(plugin)).resolves.toBe(
+				"OpenRouter transcribed this episode in 2 parts, and speaker labels restart in each, so one person can have several labels.",
+			);
+
+			expect(sent()).toHaveLength(2);
+			const labels = [...savedNote(plugin).matchAll(/\*\*(\d+):\*\* (\w+)/g)].map(
+				([, speaker, text]) => `${speaker} ${text}`,
+			);
+			expect(labels).toEqual(["1 Hello", "2 Hi", "3 Hello", "4 Hi"]);
+		});
+
+		test("speaker labels asked for and none returned, as from a route that ignores the option, saves the note and says so", async () => {
+			openRouter(() =>
+				Response.json({ words: [word("Hello", 1.2, 1.5), word("there.", 1.5, 1.9)] }),
+			);
+			const plugin = useOpenRouter();
+
+			await expect(finalNotice(plugin)).resolves.toBe(
+				"Saved without speaker labels, because Grok STT 2.0 returned none.",
+			);
+
+			expect(savedNote(plugin)).toBe(
+				`# Test Episode\n\n[00:00:01](${link("1.2")}) Hello there.`,
+			);
+		});
+
+		test.each<[name: string, status: number, message: string, shown: string]>([
+			[
+				"402",
+				402,
+				"Insufficient credits. Add more using https://openrouter.ai/settings/credits SENTINEL",
+				"Your OpenRouter account is out of credit. Add credit there, then try again.",
+			],
+			[
+				"404 for a model no route of which meets the account's privacy settings",
+				404,
+				"No endpoints found matching your data policy (Zero data retention). Configure: https://openrouter.ai/settings/privacy SENTINEL",
+				"OpenRouter does not offer the x-ai/grok-stt-2.0 model under your OpenRouter privacy settings. Change them there, or choose another model in the transcript settings.",
+			],
+			[
+				"404",
+				404,
+				"No endpoints found for x-ai/grok-stt-2.0. SENTINEL",
+				"OpenRouter does not offer the x-ai/grok-stt-2.0 model to this API key.",
+			],
+			[
+				"401",
+				401,
+				"No cookie auth credentials found SENTINEL",
+				"OpenRouter rejected the API key. Check it in the transcript settings.",
+			],
+		])(
+			"a %s is said in PodNotes' words, with none of OpenRouter's, and no other part is sent",
+			async (_name, status, message, shown) => {
+				getEpisodeAudioBufferMock.mockResolvedValue(twoPartAudio());
+				openRouter(() => Response.json({ error: { message, code: status } }, { status }));
+				const plugin = createMockPlugin({
+					provider: "openrouter",
+					openRouterKey: "openrouter-key",
+				});
+
+				await expect(finalNotice(plugin)).resolves.toBe(`Transcription failed: ${shown}`);
+
+				expect(sent()).toHaveLength(1);
+				expect(plugin.app.vault.create).not.toHaveBeenCalled();
+			},
+		);
+
+		test("a chosen model the catalog no longer lists runs the recommended one, and the notice says so", async () => {
+			openRouter(
+				undefined,
+				catalog({ "x-ai/grok-stt-2.0": null, "microsoft/mai-transcribe-2": null }),
+			);
+			const plugin = useOpenRouter({ model: "elevenlabs/scribe-v2" });
+
+			await expect(finalNotice(plugin)).resolves.toBe(
+				"OpenRouter no longer offers ElevenLabs Scribe v2, so PodNotes used Grok STT 2.0.",
+			);
+
+			expect(await Promise.all(sent().map(sentModel))).toEqual(["x-ai/grok-stt-2.0"]);
+		});
+
+		test("a model whose end date has come is skipped, and the next one is recommended", async () => {
+			const today = new Date().toISOString().slice(0, 10);
+			openRouter(
+				undefined,
+				catalog({
+					"x-ai/grok-stt-2.0": today,
+					"elevenlabs/scribe-v2": null,
+					"microsoft/mai-transcribe-2": null,
+				}),
+			);
+			const plugin = useOpenRouter();
+
+			await expect(finalNotice(plugin)).resolves.toBe("Transcription completed and saved.");
+
+			expect(await Promise.all(sent().map(sentModel))).toEqual(["elevenlabs/scribe-v2"]);
+		});
+
+		test("a catalog that cannot be read leaves every model offered, and the next job reads it again", async () => {
+			let reads = 0;
+			providerMock.mockImplementation(async (request) => {
+				if (request.url !== CATALOG) return Response.json(answers);
+				return ++reads === 1
+					? new Response("", { status: 503 })
+					: Response.json(catalog({ "x-ai/grok-stt-2.0": null }));
+			});
+			const plugin = useOpenRouter({ model: "elevenlabs/scribe-v2" });
+
+			await transcribe(plugin);
+			await transcribe(plugin);
+
+			expect(reads).toBe(2);
+			expect(await Promise.all(sent().map(sentModel))).toEqual([
+				"elevenlabs/scribe-v2",
+				"x-ai/grok-stt-2.0",
+			]);
+		});
+
+		test("the catalog is read again only once a day has passed", async () => {
+			vi.useFakeTimers({ toFake: ["Date"] });
+			try {
+				openRouter();
+				const plugin = useOpenRouter();
+
+				await transcribe(plugin);
+				vi.setSystemTime(Date.now() + 23 * HOUR_MS);
+				await transcribe(plugin);
+				expect(catalogReads()).toBe(1);
+
+				vi.setSystemTime(Date.now() + 2 * HOUR_MS);
+				await transcribe(plugin);
+				expect(catalogReads()).toBe(2);
+				expect(sent()).toHaveLength(3);
+			} finally {
+				vi.useRealTimers();
+			}
+		});
+	});
 });
 
+function sumOf(numbers: readonly number[]): number {
+	return numbers.reduce((sum, number) => sum + number, 0);
+}
+
 function deepgramAnswer(words: Record<string, unknown>[]) {
 	return { results: { channels: [{ alternatives: [{ words }] }] } };
 }
diff --git a/src/services/TranscriptionService.ts b/src/services/TranscriptionService.ts
index f6948d91..013fce2c 100644
--- a/src/services/TranscriptionService.ts
+++ b/src/services/TranscriptionService.ts
@@ -17,7 +17,7 @@ import {
 	renderTranscriptBody,
 	timestampStyle,
 } from "./publishedTranscript";
-import { transcribe, transcriptionChoice } from "./transcription";
+import { refreshModels, transcribe, transcriptionChoice } from "./transcription";
 
 export const TRANSCRIBE_FROM_AUDIO_COMMAND = "Transcribe current episode from audio";
 
@@ -256,6 +256,7 @@ export class TranscriptionService {
 		updateNotice: (message: string) => void,
 	): Promise<Outcome> {
 		const { settings, credentials, feeds } = this.plugin;
+		await this.waitForLifecycle(refreshModels(settings.transcript.provider));
 		const choice = transcriptionChoice(settings);
 		if (choice.provider === undefined) throw new Error(unknownProvider(choice.label));
 		const apiKey = credentials.get(settings, choice.provider);
diff --git a/src/services/publishedTranscript/parse.ts b/src/services/publishedTranscript/parse.ts
index a0a0d34e..c6c18afb 100644
--- a/src/services/publishedTranscript/parse.ts
+++ b/src/services/publishedTranscript/parse.ts
@@ -187,6 +187,6 @@ export function untimed(paragraphs: string[]): ParsedTranscript | undefined {
 	return isNonEmpty(paragraphs) ? { kind: "untimed", paragraphs } : undefined;
 }
 
-function isNonEmpty<T>(items: readonly T[]): items is NonEmpty<T> {
+export function isNonEmpty<T>(items: readonly T[]): items is NonEmpty<T> {
 	return items.length > 0;
 }
diff --git a/src/services/transcription/cues.ts b/src/services/transcription/cues.ts
index 3017b02c..e55520f9 100644
--- a/src/services/transcription/cues.ts
+++ b/src/services/transcription/cues.ts
@@ -51,6 +51,14 @@ function isTimed(parts: readonly TranscribedPart[]): parts is readonly TimedPart
 	return parts.every(({ transcript }) => !transcript || "words" in transcript);
 }
 
+/**
+ * Seconds to the millisecond, as finely as providers time words. A part's start is a sum of
+ * frame lengths, so a word's time in the episode would otherwise carry float noise into its link.
+ */
+function toMilliseconds(seconds: number): number {
+	return Math.round(seconds * 1000) / 1000;
+}
+
 /** Speakers are numbered in the order they first speak. A provider's label names a speaker only within its own part. */
 function cuesOf(parts: readonly TimedPart[], speakers: boolean): TranscriptCue[] {
 	const numbers = new Map<string, string>();
@@ -62,15 +70,15 @@ function cuesOf(parts: readonly TimedPart[], speakers: boolean): TranscriptCue[]
 	return parts.flatMap(({ start, transcript }, index): TranscriptCue[] =>
 		transcript
 			? transcript.words.map((word) => ({
-					start: start + word.start,
-					end: start + word.end,
+					start: toMilliseconds(start + word.start),
+					end: toMilliseconds(start + word.end),
 					speaker:
 						speakers && word.speaker !== undefined
 							? numberOf(`${index}:${word.speaker}`)
 							: undefined,
 					text: word.text,
 				}))
-			: [{ start, text: failedPartMarker(index) }],
+			: [{ start: toMilliseconds(start), text: failedPartMarker(index) }],
 	);
 }
 
diff --git a/src/services/transcription/http.ts b/src/services/transcription/http.ts
index 42ec7c2f..77ee686b 100644
--- a/src/services/transcription/http.ts
+++ b/src/services/transcription/http.ts
@@ -6,6 +6,7 @@ export type FailureKind =
 	| "auth"
 	| "credits"
 	| "model-unavailable"
+	| "privacy"
 	| "rejected"
 	| "unfetched"
 	| "rate-limited"
@@ -44,6 +45,8 @@ const SENTENCES: Record<FailureKind, (context: FailureContext, status?: number)
 		`Your ${provider} account is out of credit. Add credit there, then try again.`,
 	"model-unavailable": ({ provider, model }) =>
 		`${provider} does not offer the ${model} model to this API key.`,
+	privacy: ({ provider, model }) =>
+		`${provider} does not offer the ${model} model under your ${provider} privacy settings. Change them there, or choose another model in the transcript settings.`,
 	rejected: ({ provider }) => `${provider} could not transcribe this audio.`,
 	unfetched: ({ provider }) => `${provider} could not fetch the episode.`,
 	"rate-limited": ({ provider }) =>
diff --git a/src/services/transcription/index.ts b/src/services/transcription/index.ts
index d92930fd..024499ec 100644
--- a/src/services/transcription/index.ts
+++ b/src/services/transcription/index.ts
@@ -1,2 +1,8 @@
 export { transcribe } from "./transcribe";
-export { offeredModels, PROVIDER_LABELS, transcriptionChoice } from "./registry";
+export {
+	catalogs,
+	offeredModels,
+	PROVIDER_LABELS,
+	refreshModels,
+	transcriptionChoice,
+} from "./registry";
diff --git a/src/services/transcription/providers/openrouter.ts b/src/services/transcription/providers/openrouter.ts
new file mode 100644
index 00000000..bf96d5b3
--- /dev/null
+++ b/src/services/transcription/providers/openrouter.ts
@@ -0,0 +1,180 @@
+import { arrayBufferToBase64 } from "obsidian";
+import { isPlainObject } from "src/persistence/codecUtils";
+import type { NonEmpty } from "src/services/publishedTranscript/parse";
+import { fetchJsonWithTimeout } from "src/utility/networkRequest";
+import type {
+	Listing,
+	ModelProfile,
+	PartInput,
+	PartTranscript,
+	Provider,
+	ProviderRequest,
+	Word,
+} from "./types";
+
+const TRANSCRIPTIONS_URL = "https://openrouter.ai/api/v1/audio/transcriptions";
+const CATALOG_URL = "https://openrouter.ai/api/v1/models?output_modalities=transcription";
+
+/**
+ * OpenRouter takes 25 MB a request and gives the model 60 s to answer. Parts of 24 MB and
+ * 1,980 s were answered in 20 to 31 s, so these leave room.
+ */
+const PART_CAPS = { maxUploadBytes: 18_000_000, maxSeconds: 1800 };
+
+type Body = (input: PartInput) => Promise<ProviderRequest["body"]>;
+
+/** The formats `input_audio.format` names, by the type of the file PodNotes sends. MP3 otherwise. */
+const FORMATS: Readonly<Record<string, string>> = {
+	"audio/mp4": "m4a",
+	"audio/ogg": "ogg",
+	"audio/wav": "wav",
+	"audio/flac": "flac",
+	"audio/webm": "webm",
+};
+
+/**
+ * xAI reads speaker labels from its own options. A request OpenRouter routes elsewhere
+ * ignores them and is answered with no speakers, so the route is pinned to xAI.
+ */
+const grok: Body = async ({ model, speakers, audio }) => {
+	if ("url" in audio) throw new Error("Grok STT takes no audio address.");
+	return {
+		model: model.id,
+		input_audio: {
+			data: arrayBufferToBase64(await audio.file.arrayBuffer()),
+			format: FORMATS[audio.file.type] ?? "mp3",
+		},
+		response_format: "verbose_json",
+		timestamp_granularities: ["word", "segment"],
+		provider: { only: ["xai"], ...(speakers && { options: { xai: { diarize: true } } }) },
+	};
+};
+
+/**
+ * Scribe v2 and MAI-Transcribe 2 take `diarize` beside the model, and list words only when
+ * asked for speakers or word times. Only Scribe v2 fetches an address.
+ */
+const topLevelDiarize: Body = async ({ model, speakers, audio }) => {
+	if ("url" in audio) {
+		return {
+			model: model.id,
+			input_audio: { url: audio.url, format: "mp3" },
+			response_format: "verbose_json",
+			timestamp_granularities: ["word"],
+			...(speakers && { diarize: true }),
+		};
+	}
+	const form = new FormData();
+	form.append("model", model.id);
+	form.append("file", audio.file);
+	form.append("response_format", "verbose_json");
+	form.append("timestamp_granularities[]", "word");
+	if (speakers) form.append("diarize", "true");
+	return form;
+};
+
+const MODELS: NonEmpty<ModelProfile & { readonly body: Body }> = [
+	{
+		id: "x-ai/grok-stt-2.0",
+		label: "Grok STT 2.0",
+		speakers: true,
+		url: false,
+		...PART_CAPS,
+		body: grok,
+	},
+	{
+		id: "elevenlabs/scribe-v2",
+		label: "ElevenLabs Scribe v2",
+		speakers: true,
+		url: true,
+		...PART_CAPS,
+		body: topLevelDiarize,
+	},
+	{
+		id: "microsoft/mai-transcribe-2",
+		label: "MAI-Transcribe 2",
+		speakers: true,
+		url: false,
+		...PART_CAPS,
+		body: topLevelDiarize,
+	},
+];
+
+/**
+ * https://openrouter.ai/docs/guides/overview/multimodal/stt
+ *
+ * Each model asks for speaker labels its own way, and one asked the wrong way answers
+ * with none, so each model has the request it was measured with.
+ */
+export const openrouter: Provider = {
+	models: MODELS,
+	timeoutMs: 10 * 60_000,
+
+	async transcribe(input, send) {
+		const model = MODELS.find(({ id }) => id === input.model.id);
+		if (!model) throw new Error(`OpenRouter has no ${input.model.id} request.`);
+		return parse(
+			await send({
+				url: TRANSCRIPTIONS_URL,
+				headers: { Authorization: `Bearer ${input.apiKey}` },
+				body: await model.body(input),
+			}),
+		);
+	},
+
+	failure(status, body) {
+		const message =
+			isPlainObject(body) &&
+			isPlainObject(body.error) &&
+			typeof body.error.message === "string"
+				? body.error.message
+				: "";
+		// A 404 also answers a model whose every route breaks the account's privacy settings,
+		// such as zero data retention: "... matching your guardrail restrictions and data policy".
+		if (status === 404 && /data policy|zero data retention|\bzdr\b/i.test(message)) {
+			return "privacy";
+		}
+		if (status === 400 && /could not download input_audio\.url/i.test(message))
+			return "unfetched";
+		return undefined;
+	},
+
+	async catalog() {
+		const answer = await fetchJsonWithTimeout<unknown>(CATALOG_URL, { timeoutMs: 15_000 });
+		const entries = isPlainObject(answer) ? answer.data : undefined;
+		if (!Array.isArray(entries)) throw new Error("OpenRouter's catalog lists no models.");
+		const listing: Map<string, string | undefined> = new Map();
+		for (const entry of entries) {
+			if (!isPlainObject(entry) || typeof entry.id !== "string") continue;
+			const ends = entry.expiration_date;
+			listing.set(entry.id, typeof ends === "string" ? ends.slice(0, 10) : undefined);
+		}
+		return listing satisfies Listing;
+	},
+};
+
+function parse(answer: unknown): PartTranscript {
+	const words = isPlainObject(answer) ? answer.words : undefined;
+	if (!Array.isArray(words)) return { words: [] };
+	return {
+		words: words.flatMap((item: unknown): Word[] => {
+			// Scribe v2 also lists sounds, such as "[gentle music]", as `audio_event` items.
+			if (!isPlainObject(item) || (item.type ?? "word") !== "word") return [];
+			const { word: text, start, end, speaker } = item;
+			if (typeof text !== "string" || typeof start !== "number" || typeof end !== "number") {
+				return [];
+			}
+			return [
+				{
+					text,
+					start,
+					end,
+					speaker:
+						typeof speaker === "number" || typeof speaker === "string"
+							? `${speaker}`
+							: undefined,
+				},
+			];
+		}),
+	};
+}
diff --git a/src/services/transcription/providers/types.ts b/src/services/transcription/providers/types.ts
index 7362198b..ccca60b7 100644
--- a/src/services/transcription/providers/types.ts
+++ b/src/services/transcription/providers/types.ts
@@ -51,6 +51,9 @@ export interface ProviderRequest {
 /** POSTs one request and resolves with the JSON of a 2xx answer. Rejects with a TranscriptionError. */
 export type Send = (request: ProviderRequest) => Promise<unknown>;
 
+/** The models a provider's live catalog lists, by ID, each with the day it ends (`YYYY-MM-DD`) if it has one. */
+export type Listing = ReadonlyMap<string, string | undefined>;
+
 /** Everything that is one provider's own: its models, its request and how to read its answers. */
 export interface Provider {
 	/** Best first. The first is the one PodNotes recommends. */
@@ -60,4 +63,6 @@ export interface Provider {
 	transcribe(input: PartInput, send: Send): Promise<PartTranscript>;
 	/** What a failed answer means here, when the status alone does not say. `body` is the answer's JSON. */
 	failure?(status: number, body: unknown): FailureKind | undefined;
+	/** Reads which models the provider still serves. Rejects when it cannot tell. */
+	catalog?(): Promise<Listing>;
 }
diff --git a/src/services/transcription/registry.ts b/src/services/transcription/registry.ts
index b9bdd686..8ef354f1 100644
--- a/src/services/transcription/registry.ts
+++ b/src/services/transcription/registry.ts
@@ -1,10 +1,13 @@
+import { get, writable } from "svelte/store";
 import { isOption } from "src/persistence/codecUtils";
+import { isNonEmpty, type NonEmpty } from "src/services/publishedTranscript/parse";
 import { CREDENTIALS, type CredentialKind } from "src/types/Credentials";
 import type { IPodNotesSettings } from "src/types/IPodNotesSettings";
 import { deepgram } from "./providers/deepgram";
 import { elevenlabs } from "./providers/elevenlabs";
 import { openai } from "./providers/openai";
-import type { ModelProfile, Provider } from "./providers/types";
+import { openrouter } from "./providers/openrouter";
+import type { Listing, ModelProfile, Provider } from "./providers/types";
 
 /**
  * In the order the settings offer them. A provider is keyed by the API key it needs, so
@@ -13,6 +16,7 @@ import type { ModelProfile, Provider } from "./providers/types";
 export const PROVIDERS = {
 	elevenlabs,
 	deepgram,
+	openrouter,
 	openai,
 } satisfies Record<CredentialKind, Provider>;
 
@@ -23,15 +27,22 @@ export const PROVIDER_LABELS = Object.fromEntries(
 	PROVIDER_IDS.map((id) => [id, CREDENTIALS[id].label]),
 ) as Readonly<Record<CredentialKind, string>>;
 
+/** A model the settings offer, with the day its provider stops serving it when one is announced. */
+export interface OfferedModel extends ModelProfile {
+	readonly ends?: string;
+}
+
 /** A provider and a model this version can run. */
 export interface ProviderChoice {
 	readonly provider: CredentialKind;
 	/** The provider's name, for buttons and notices. */
 	readonly label: string;
-	/** The stored model, or the provider's first when none is stored or `unknownModel` is. */
-	readonly model: ModelProfile;
+	/** The stored model, or the first offered when none is stored or the stored one cannot run. */
+	readonly model: OfferedModel;
 	/** The stored model ID, when this version has no such model. */
 	readonly unknownModel?: string;
+	/** The stored model, when the provider's catalog no longer offers it. */
+	readonly withdrawnModel?: ModelProfile;
 	/** The settings ask for speaker labels. Whether the model has them is `model.speakers`. */
 	readonly speakers: boolean;
 }
@@ -59,18 +70,36 @@ export function transcriptionChoice({
 	if (!isOption(PROVIDERS, provider)) return { provider: undefined, label: provider, speakers };
 	const models = offeredModels(provider);
 	const model = models.find(({ id }) => id === stored);
+	const withdrawn = model
+		? undefined
+		: PROVIDERS[provider].models.find(({ id }) => id === stored);
 	return {
 		provider,
 		label: PROVIDER_LABELS[provider],
 		model: model ?? models[0],
-		unknownModel: model || !stored ? undefined : stored,
+		unknownModel: model || withdrawn || !stored ? undefined : stored,
+		withdrawnModel: withdrawn,
 		speakers,
 	};
 }
 
-/** The models the settings offer for a provider, best first. The first is the recommended one. */
-export function offeredModels(provider: CredentialKind): Provider["models"] {
-	return PROVIDERS[provider].models;
+/**
+ * The models the settings offer for a provider, best first. The first is the recommended
+ * one. A provider's catalog only takes models away: those it does not list, and those whose
+ * end date has come. A catalog that would take every model away is not followed.
+ */
+export function offeredModels(provider: CredentialKind): NonEmpty<OfferedModel> {
+	const { models } = PROVIDERS[provider];
+	const listing = get(catalogs).get(provider)?.listing;
+	if (!listing) return models;
+	const today = new Date().toISOString().slice(0, 10);
+	const offered = models.flatMap((model): OfferedModel[] => {
+		if (!listing.has(model.id)) return [];
+		const ends = listing.get(model.id);
+		if (ends === undefined) return [model];
+		return ends > today ? [{ ...model, ends }] : [];
+	});
+	return isNonEmpty(offered) ? offered : models;
 }
 
 /** The names of the providers whose recommended model labels speakers. */
@@ -79,3 +108,44 @@ export function providersWithSpeakers(): string[] {
 		(id) => PROVIDER_LABELS[id],
 	);
 }
+
+const CATALOG_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * The last catalog read of each provider that has a catalog, in memory only. A failed read
+ * is not kept, so the next one asks again.
+ */
+export const catalogs = writable<ReadonlyMap<CredentialKind, { at: number; listing: Listing }>>(
+	new Map(),
+);
+
+const reading = new Map<CredentialKind, Promise<void>>();
+
+/**
+ * Reads the provider's catalog when it has one and the last read is missing or a day old.
+ * Resolves once the read is done, whether or not it worked.
+ */
+export function refreshModels(storedProvider: string): Promise<void> {
+	if (!isOption(PROVIDERS, storedProvider)) return Promise.resolve();
+	const provider: CredentialKind = storedProvider;
+	const source: Provider = PROVIDERS[provider];
+	const last = get(catalogs).get(provider);
+	if (!source.catalog || (last && Date.now() - last.at < CATALOG_MAX_AGE_MS)) {
+		return Promise.resolve();
+	}
+	let pending = reading.get(provider);
+	if (!pending) {
+		pending = source
+			.catalog()
+			.then(
+				(listing) =>
+					catalogs.update((read) =>
+						new Map(read).set(provider, { at: Date.now(), listing }),
+					),
+				() => {},
+			)
+			.finally(() => reading.delete(provider));
+		reading.set(provider, pending);
+	}
+	return pending;
+}
diff --git a/src/services/transcription/transcribe.ts b/src/services/transcription/transcribe.ts
index dba19dc7..a1c3b21d 100644
--- a/src/services/transcription/transcribe.ts
+++ b/src/services/transcription/transcribe.ts
@@ -30,6 +30,7 @@ const ENDS_THE_JOB: ReadonlySet<FailureKind> = new Set([
 	"auth",
 	"credits",
 	"model-unavailable",
+	"privacy",
 	"rejected",
 ]);
 
@@ -105,10 +106,30 @@ export async function transcribe(job: TranscriptionJob): Promise<Transcript> {
 			`This version of PodNotes has no ${choice.unknownModel} model, so ${choice.label} used ${model.label}.`,
 		);
 	}
+	if (choice.withdrawnModel) {
+		warnings.push(
+			`${choice.label} no longer offers ${choice.withdrawnModel.label}, so PodNotes used ${model.label}.`,
+		);
+	}
 	if (choice.speakers && !model.speakers) {
 		warnings.push(
 			`Saved without speaker labels, because ${choice.label} does not label speakers. These providers do: ${providersWithSpeakers().join(", ")}.`,
 		);
 	}
+	// A request routed where the speaker option is ignored is answered without speakers.
+	const labeled = parts.some(
+		({ transcript }) =>
+			transcript &&
+			"words" in transcript &&
+			transcript.words.some((word) => word.speaker !== undefined),
+	);
+	if (speakers && !labeled) {
+		warnings.push(`Saved without speaker labels, because ${model.label} returned none.`);
+	}
+	if (speakers && labeled && parts.length > 1) {
+		warnings.push(
+			`${choice.label} transcribed this episode in ${parts.length} parts, and speaker labels restart in each, so one person can have several labels.`,
+		);
+	}
 	return { content, warnings };
 }
diff --git a/src/settingsMigrations.test.ts b/src/settingsMigrations.test.ts
index fbb4fc7f..402c51de 100644
--- a/src/settingsMigrations.test.ts
+++ b/src/settingsMigrations.test.ts
@@ -213,12 +213,12 @@ describe("migrateTranscriptSettings", () => {
 
 	it("keeps a provider and a model this version does not have", () => {
 		const migrated = migrateTranscriptSettings(
-			{ provider: "openrouter", model: "x-ai/grok-stt-2.0" },
+			{ provider: "assemblyai", model: "universal-3-6-pro" },
 			true,
 		);
 
-		expect(migrated.provider).toBe("openrouter");
-		expect(migrated.model).toBe("x-ai/grok-stt-2.0");
+		expect(migrated.provider).toBe("assemblyai");
+		expect(migrated.model).toBe("universal-3-6-pro");
 	});
 
 	it("coalesces non-boolean enabled / non-string fields to defaults", () => {
diff --git a/src/settingsTransfer.test.ts b/src/settingsTransfer.test.ts
index be34bc75..95705fed 100644
--- a/src/settingsTransfer.test.ts
+++ b/src/settingsTransfer.test.ts
@@ -215,13 +215,20 @@ describe("serializeSettings", () => {
 			openAISecretId: "podnotes-openai-api-key",
 			deepgramSecretId: "podnotes-deepgram-api-key",
 			elevenLabsSecretId: "podnotes-elevenlabs-api-key",
+			openRouterSecretId: "podnotes-openrouter-api-key",
 		});
-		const secrets = { openAI: "sk-secret", deepgram: "dg-secret", elevenLabs: "el-secret" };
+		const secrets = {
+			openAI: "sk-secret",
+			deepgram: "dg-secret",
+			elevenLabs: "el-secret",
+			openRouter: "or-secret",
+		};
 
 		const without = serializeSettings(settings, {}, "2.16.0", NOW, new Map());
 		expect(without.settings).not.toHaveProperty("openAISecretId");
 		expect(without.settings).not.toHaveProperty("deepgramSecretId");
 		expect(without.settings).not.toHaveProperty("elevenLabsSecretId");
+		expect(without.settings).not.toHaveProperty("openRouterSecretId");
 
 		const withKeys = serializeSettings(settings, { secrets }, "2.16.0", NOW, new Map());
 		expect(withKeys.version).toBe(2);
@@ -604,14 +611,19 @@ describe("parseImport", () => {
 				type: SETTINGS_EXPORT_TYPE,
 				version: 2,
 				settings: { defaultVolume: 0.5, openAISecretId: "not-transferable" },
-				secrets: { openAI: " sk ", deepgram: "dg", elevenLabs: "el" },
+				secrets: { openAI: " sk ", deepgram: "dg", elevenLabs: "el", openRouter: "or" },
 			}),
 		);
 
 		expect(result.ok).toBe(true);
 		if (result.ok) {
 			expect(result.settings).not.toHaveProperty("openAISecretId");
-			expect(result.secrets).toEqual({ openAI: "sk", deepgram: "dg", elevenLabs: "el" });
+			expect(result.secrets).toEqual({
+				openAI: "sk",
+				deepgram: "dg",
+				elevenLabs: "el",
+				openRouter: "or",
+			});
 		}
 	});
 
@@ -910,15 +922,15 @@ describe("the transcription provider in a settings file", () => {
 
 	it("imports the provider and model a file names, also ones this version does not have", () => {
 		const settings = makeSettings();
-		settings.transcript.provider = "openrouter";
-		settings.transcript.model = "x-ai/grok-stt-2.0";
+		settings.transcript.provider = "assemblyai";
+		settings.transcript.model = "universal-3-6-pro";
 		const file = JSON.stringify(serializeSettings(settings, {}, "2.26.0", NOW, new Map()));
 
 		const { transcript } = imported(makeSettings(), file);
 
 		expect([transcript.provider, transcript.model]).toEqual([
-			"openrouter",
-			"x-ai/grok-stt-2.0",
+			"assemblyai",
+			"universal-3-6-pro",
 		]);
 	});
 
@@ -986,10 +998,13 @@ describe("describeSecrets (#168)", () => {
 		expect(describeSecrets({})).toEqual([]);
 		expect(describeSecrets({ openAI: "sk" })).toEqual(["OpenAI API key"]);
 		expect(describeSecrets({ deepgram: "dg" })).toEqual(["Deepgram API key"]);
-		expect(describeSecrets({ openAI: "sk", deepgram: "dg", elevenLabs: "el" })).toEqual([
+		expect(
+			describeSecrets({ openAI: "sk", deepgram: "dg", elevenLabs: "el", openRouter: "or" }),
+		).toEqual([
 			"OpenAI API key",
 			"Deepgram API key",
 			"ElevenLabs API key",
+			"OpenRouter API key",
 		]);
 	});
 
diff --git a/src/types/Credentials.ts b/src/types/Credentials.ts
index 9cc79d2c..cd75efd1 100644
--- a/src/types/Credentials.ts
+++ b/src/types/Credentials.ts
@@ -7,6 +7,7 @@ export const CREDENTIALS = {
 	openai: { settingsKey: "openAISecretId", exportKey: "openAI", label: "OpenAI" },
 	deepgram: { settingsKey: "deepgramSecretId", exportKey: "deepgram", label: "Deepgram" },
 	elevenlabs: { settingsKey: "elevenLabsSecretId", exportKey: "elevenLabs", label: "ElevenLabs" },
+	openrouter: { settingsKey: "openRouterSecretId", exportKey: "openRouter", label: "OpenRouter" },
 } as const;
 
 export type CredentialKind = keyof typeof CREDENTIALS;
diff --git a/src/ui/settings/PodNotesSettingsTab.test.ts b/src/ui/settings/PodNotesSettingsTab.test.ts
index 26c3ca3f..47e6b649 100644
--- a/src/ui/settings/PodNotesSettingsTab.test.ts
+++ b/src/ui/settings/PodNotesSettingsTab.test.ts
@@ -10,12 +10,19 @@ import PodNotes from "src/main";
 import { decodePodNotesData } from "src/persistence/podNotesData";
 import { PlayerController } from "src/player/PlayerController";
 import { FeedUrlRepository } from "src/services/FeedUrlRepository";
+import { catalogs } from "src/services/transcription";
 import { episodeListLimit, plugin as pluginStore } from "src/store";
 import type { IPodNotesSettings } from "src/types/IPodNotesSettings";
 import { PodNotesSettingsTab } from "./PodNotesSettingsTab";
 import { attachDataFileWriter, dataFileText } from "../../../tests/mocks/dataFileWriter";
 import { FakeDocument } from "../../../tests/mocks/fakeMedia";
 import { fakeQuickAdd, unusableQuickAdd } from "../../../tests/mocks/quickAdd";
+import { providerMock } from "../../../tests/mocks/providerRequestUrl";
+
+vi.mock("obsidian", async (importOriginal) => ({
+	...(await importOriginal<typeof import("obsidian")>()),
+	requestUrl: (await import("../../../tests/mocks/providerRequestUrl")).providerRequestUrl,
+}));
 
 const openTabs = new Set<PodNotesSettingsTab>();
 
@@ -29,6 +36,8 @@ afterEach(() => {
 		tab.containerEl.remove();
 	}
 	openTabs.clear();
+	providerMock.mockReset();
+	catalogs.set(new Map());
 	vi.useRealTimers();
 	vi.restoreAllMocks();
 	pluginStore.set(undefined as never);
@@ -186,6 +195,7 @@ describe("sections", () => {
 					"OpenAI API key",
 					"Deepgram API key",
 					"ElevenLabs API key",
+					"OpenRouter API key",
 					"Model",
 					"Speaker labels",
 					"Speaker label format",
@@ -326,6 +336,7 @@ describe("Transcripts", () => {
 		expect(options(provider())).toEqual([
 			["elevenlabs", "ElevenLabs"],
 			["deepgram", "Deepgram"],
+			["openrouter", "OpenRouter"],
 			["openai", "OpenAI"],
 		]);
 		expect(provider()).toHaveDisplayValue("OpenAI");
@@ -410,10 +421,10 @@ describe("Transcripts", () => {
 
 	test("a provider this version does not have stays selected under its stored name, with no key or model row", async () => {
 		const { ui, provider, keyButtons, writes } = openTranscripts(
-			transcript({ provider: "openrouter", model: "x-ai/grok-stt-2.0" }),
+			transcript({ provider: "assemblyai", model: "universal-3-6-pro" }),
 		);
 
-		expect(provider()).toHaveDisplayValue("openrouter");
+		expect(provider()).toHaveDisplayValue("assemblyai");
 		expect(keyButtons()).toEqual([]);
 		expect(ui.queryByRole("combobox", { name: "Model" })).toBeNull();
 		expect(await writes()).toBe(0);
@@ -432,6 +443,64 @@ describe("Transcripts", () => {
 		expect(model()).toHaveDisplayValue("nova-9");
 		expect(await writes()).toBe(0);
 	});
+
+	describe("OpenRouter", () => {
+		const CATALOG = "https://openrouter.ai/api/v1/models?output_modalities=transcription";
+		/** Answers OpenRouter's catalog, listing each model with its end date or null. */
+		const listing = (models: Record<string, string | null>) =>
+			providerMock.mockImplementation(async (request) =>
+				request.url === CATALOG
+					? Response.json({
+							data: Object.entries(models).map(([id, expiration_date]) => ({
+								id,
+								expiration_date,
+							})),
+						})
+					: new Response("", { status: 404 }),
+			);
+
+		test("choosing it shows its API key row and its three models, Grok STT 2.0 recommended", async () => {
+			const { provider, model, keyButtons, disk } = openTranscripts();
+
+			choose(provider(), "openrouter");
+
+			expect(keyButtons()).toEqual(["Link... OpenRouter API key"]);
+			await settled();
+			expect(options(model())).toEqual([
+				["", "Recommended (Grok STT 2.0)"],
+				["x-ai/grok-stt-2.0", "Grok STT 2.0"],
+				["elevenlabs/scribe-v2", "ElevenLabs Scribe v2"],
+				["microsoft/mai-transcribe-2", "MAI-Transcribe 2"],
+			]);
+			expect(model()).toHaveDisplayValue("Recommended (Grok STT 2.0)");
+			expect((await disk()).transcript).toMatchObject({ provider: "openrouter", model: "" });
+		});
+
+		test("the catalog read as the row draws leaves out a model it does not list and dates one that ends", async () => {
+			listing({ "x-ai/grok-stt-2.0": "2099-01-31", "microsoft/mai-transcribe-2": null });
+			const { model } = openTranscripts(transcript({ provider: "openrouter" }));
+
+			await settled();
+
+			expect(options(model())).toEqual([
+				["", "Recommended (Grok STT 2.0, ends 2099-01-31)"],
+				["x-ai/grok-stt-2.0", "Grok STT 2.0, ends 2099-01-31"],
+				["microsoft/mai-transcribe-2", "MAI-Transcribe 2"],
+			]);
+		});
+
+		test("a chosen model the catalog no longer lists stays selected, marked as no longer offered", async () => {
+			listing({ "x-ai/grok-stt-2.0": null, "microsoft/mai-transcribe-2": null });
+			const { model, writes } = openTranscripts(
+				transcript({ provider: "openrouter", model: "elevenlabs/scribe-v2" }),
+			);
+
+			await settled();
+
+			expect(model()).toHaveDisplayValue("ElevenLabs Scribe v2, no longer offered");
+			expect(await writes()).toBe(0);
+		});
+	});
 });
 
 describe("text fields", () => {
diff --git a/src/ui/settings/PodNotesSettingsTab.ts b/src/ui/settings/PodNotesSettingsTab.ts
index 0424052d..39e9aa2b 100644
--- a/src/ui/settings/PodNotesSettingsTab.ts
+++ b/src/ui/settings/PodNotesSettingsTab.ts
@@ -40,12 +40,18 @@ import type { Episode } from "src/types/Episode";
 import type { PodcastFeed } from "src/types/PodcastFeed";
 import { NEXT_TRACK_ACTIONS, PREVIOUS_TRACK_ACTIONS } from "src/types/Headset";
 import type { IPodNotesSettings } from "src/types/IPodNotesSettings";
-import { get } from "svelte/store";
+import { get, type Readable } from "svelte/store";
 import { exportOPML, importOPML } from "src/opml";
 import { isOption } from "src/persistence/codecUtils";
 import { decodePodNotesData, PODNOTES_DATA_SCHEMA_VERSION } from "src/persistence/podNotesData";
 import { privateFeedAddresses, protectPrivateFeeds } from "src/services/privateFeeds";
-import { offeredModels, PROVIDER_LABELS, transcriptionChoice } from "src/services/transcription";
+import {
+	catalogs,
+	offeredModels,
+	PROVIDER_LABELS,
+	refreshModels,
+	transcriptionChoice,
+} from "src/services/transcription";
 import {
 	describeSecrets,
 	mergeImportedSettings,
@@ -483,9 +489,13 @@ export class PodNotesSettingsTab extends PluginSettingTab {
 		return complete;
 	}
 
-	private follow(setting: Setting, show: (settings: IPodNotesSettings) => void): () => void {
+	private follow(
+		setting: Setting,
+		show: (settings: IPodNotesSettings) => void,
+		store: Readable<unknown> = plugin,
+	): () => void {
 		const { win } = setting.settingEl;
-		const unsubscribe = plugin.subscribe(() => show(this.plugin.settings));
+		const unsubscribe = store.subscribe(() => show(this.plugin.settings));
 		const stop = () => {
 			if (!this.follows.delete(stop)) return;
 			win.removeEventListener("pagehide", stop);
@@ -671,27 +681,37 @@ export class PodNotesSettingsTab extends PluginSettingTab {
 			name: "Model",
 			visible: () => transcriptionChoice(this.plugin.settings).provider !== undefined,
 			render: (setting) => {
-				let stop = () => {};
+				const stops: (() => void)[] = [];
 				setting.addDropdown((dropdown) => {
 					dropdown.onChange((model) => {
 						this.plugin.settings.transcript.model = model;
 						this.changed();
 					});
-					stop = this.follow(setting, (settings) => {
+					const draw = (settings: IPodNotesSettings) => {
 						const choice = transcriptionChoice(settings);
 						if (choice.provider === undefined) return;
+						void refreshModels(choice.provider);
 						const models = offeredModels(choice.provider);
+						const name = ({ label, ends }: { label: string; ends?: string }) =>
+							ends ? `${label}, ends ${ends}` : label;
 						dropdown.selectEl.empty();
-						dropdown.addOption("", `Recommended (${models[0].label})`);
-						for (const { id, label } of models) dropdown.addOption(id, label);
-						// A model a newer PodNotes stored stays selected, under its stored name.
+						dropdown.addOption("", `Recommended (${name(models[0])})`);
+						for (const model of models) dropdown.addOption(model.id, name(model));
+						// A stored model that cannot run stays selected, so the row shows what was chosen.
 						if (choice.unknownModel) {
 							dropdown.addOption(choice.unknownModel, choice.unknownModel);
 						}
+						if (choice.withdrawnModel) {
+							const { id, label } = choice.withdrawnModel;
+							dropdown.addOption(id, `${label}, no longer offered`);
+						}
 						dropdown.setValue(settings.transcript.model);
-					});
+					};
+					stops.push(this.follow(setting, draw), this.follow(setting, draw, catalogs));
 				});
-				return stop;
+				return () => {
+					for (const stop of stops) stop();
+				};
 			},
 		};
 	}
diff --git a/tests/e2e/journey-resilience.test.ts b/tests/e2e/journey-resilience.test.ts
index 015edc8c..87e7ed68 100644
--- a/tests/e2e/journey-resilience.test.ts
+++ b/tests/e2e/journey-resilience.test.ts
@@ -43,12 +43,16 @@ import {
 	installElevenLabsStub,
 	installItunesStub,
 	installOpenAIStub,
+	installOpenRouterStub,
 	itunesSearchTerms,
+	openRouterCatalogReads,
+	openRouterRequests,
 	pubDate,
 	removeDeepgramTripwire,
 	removeElevenLabsStub,
 	removeItunesStub,
 	removeOpenAIStub,
+	removeOpenRouterStub,
 	startFixtureServer,
 	transcriptionUploads,
 } from "./journey/fixtures";
@@ -888,6 +892,125 @@ describe("resilience journeys", () => {
 		expect(server.requests().filter((request) => request.endsWith(".wav"))).toEqual([]);
 	}, 60_000);
 
+	describe("OpenRouter", () => {
+		const secretId = "podnotes-openrouter-api-key-464646";
+		/** Seeds `show` as playing `spoken` on OpenRouter's `model`, with a key and the stub. */
+		const transcribeWithOpenRouter = async (
+			show: FixtureFeed,
+			spoken: FixtureEpisode,
+			model: string,
+		) => {
+			const context = getContext();
+			const { obsidian, sandbox } = context;
+			const server = await serve(show);
+			const previousSecret = await obsidian.dev.evalJson<string | null>(
+				`app.secretStorage.getSecret(${jsLiteral(secretId)})`,
+			);
+			onTestFinished(() =>
+				obsidian.dev.evalJson(
+					previousSecret === null
+						? `app.secretStorage.deleteSecret(${jsLiteral(secretId)}), true`
+						: `app.secretStorage.setSecret(${jsLiteral(secretId)}, ${jsLiteral(previousSecret)}), true`,
+				),
+			);
+			await obsidian.dev.evalJson(
+				`app.secretStorage.setSecret(${jsLiteral(secretId)}, "sk-or-journey-test"), true`,
+			);
+			await seedLibrary(context, server, {
+				subscriptions: [show],
+				current: storedEpisode(server, show, spoken),
+				transcription: { provider: "openrouter", secretId, model },
+			});
+			await installOpenRouterStub(
+				obsidian,
+				"Journey transcript opens here.",
+				"A second speaker answers.",
+			);
+			onTestFinished(() => removeOpenRouterStub(obsidian));
+			const notePath = `Transcripts/${show.title}/${spoken.title}.md`;
+
+			await runCommand(obsidian, `${PLUGIN_ID}:podnotes-transcribe`);
+			await sandbox.waitForExists(notePath, { timeoutMs: 30_000 });
+
+			const link = (time: number) =>
+				`obsidian://podnotes?episodeName=Spoken%20Episode&url=${encodeURIComponent(server.feedUrl(show))}&time=${time}`;
+			expect(
+				(await readVaultText(obsidian, sandbox.path(notePath))).replace(
+					/^Date: .+$/m,
+					"Date: <date>",
+				),
+			).toBe(
+				`# Spoken Episode\n\nPodcast: ${show.title}\nDate: <date>\n\n` +
+					`[00:00:00](${link(0)}) **1:** Journey transcript opens here.\n\n` +
+					`[00:00:12](${link(12)}) **2:** A second speaker answers.`,
+			);
+			expect(await openRouterCatalogReads(obsidian)).toEqual([null]);
+			return server;
+		};
+
+		test("J-TR-09 a public episode goes to Scribe v2 by its address in one request, and its audio is not fetched", async () => {
+			const { obsidian } = getContext();
+			const spoken: FixtureEpisode = {
+				title: "Spoken Episode",
+				seconds: 4,
+				pubDate: pubDate(0),
+			};
+			const show: FixtureFeed = {
+				title: "Journey OpenRouter Scribe",
+				slug: "openrouter-scribe",
+				artwork: true,
+				episodes: [spoken],
+			};
+
+			const server = await transcribeWithOpenRouter(show, spoken, "elevenlabs/scribe-v2");
+
+			expect(await openRouterRequests(obsidian)).toEqual([
+				{
+					method: "POST",
+					authorization: "Bearer sk-or-journey-test",
+					contentType: "application/json",
+					model: "elevenlabs/scribe-v2",
+					diarize: true,
+					url: server.mediaUrl(show, spoken),
+					audioBytes: 0,
+					sha256: null,
+				},
+			]);
+			expect(server.requests().filter((request) => request.endsWith(".wav"))).toEqual([]);
+		}, 60_000);
+
+		test("J-TR-10 Grok STT 2.0 gets the episode's audio as base64 in one request", async () => {
+			const { obsidian } = getContext();
+			const spoken: FixtureEpisode = {
+				title: "Spoken Episode",
+				seconds: 4,
+				pubDate: pubDate(0),
+			};
+			const show: FixtureFeed = {
+				title: "Journey OpenRouter Grok",
+				slug: "openrouter-grok",
+				artwork: true,
+				episodes: [spoken],
+			};
+
+			const server = await transcribeWithOpenRouter(show, spoken, "");
+
+			const audio = server.audio(show, spoken);
+			expect(await openRouterRequests(obsidian)).toEqual([
+				{
+					method: "POST",
+					authorization: "Bearer sk-or-journey-test",
+					contentType: "application/json",
+					model: "x-ai/grok-stt-2.0",
+					diarize: true,
+					url: null,
+					audioBytes: audio.byteLength,
+					sha256: createHash("sha256").update(audio).digest("hex"),
+				},
+			]);
+		}, 60_000);
+	});
+
 	test("J-TR-05 feed text cannot give the transcript note a block ID or an inline field", async () => {
 		const context = getContext();
 		const { obsidian, sandbox } = context;
diff --git a/tests/e2e/journey/fixtures.ts b/tests/e2e/journey/fixtures.ts
index d2d7b047..e4da9deb 100644
--- a/tests/e2e/journey/fixtures.ts
+++ b/tests/e2e/journey/fixtures.ts
@@ -599,3 +599,115 @@ export async function removeElevenLabsStub(obsidian: ObsidianClient): Promise<vo
 		return true;
 	})()`);
 }
+
+export type OpenRouterRequest = Readonly<{
+	method: string;
+	authorization: string | null;
+	contentType: string | null;
+	model: string | null;
+	diarize: boolean;
+	/** The address the request named in place of the audio. */
+	url: string | null;
+	audioBytes: number;
+	/** Of the audio the request carried, decoded from base64 for JSON. */
+	sha256: string | null;
+}>;
+
+const OPENROUTER_TRANSCRIPTIONS_URL = "https://openrouter.ai/api/v1/audio/transcriptions";
+const OPENROUTER_CATALOG_URL =
+	"https://openrouter.ai/api/v1/models?output_modalities=transcription";
+
+/**
+ * Answers OpenRouter's transcriptions with `first` from one speaker at 0 s and `second` from
+ * another 12 s in, and its catalog with the three models PodNotes offers.
+ */
+export async function installOpenRouterStub(
+	obsidian: ObsidianClient,
+	first: string,
+	second: string,
+): Promise<void> {
+	await obsidian.dev.evalJsonAsync(`(async () => {
+		if (window.__podnotesJourneyOpenRouter) throw new Error("The OpenRouter stub is already installed.");
+		const ipc = window.electron.ipcRenderer;
+		const originalSend = ipc.send;
+		const requests = [];
+		const catalogReads = [];
+		const spoken = (sentence, speaker, from) => sentence.split(" ").map((word, index) => {
+			const start = from + index * 0.4;
+			return { word, start, end: start + 0.3, speaker, speaker_label: "speaker_" + speaker, confidence: 0.99 };
+		});
+		const words = [...spoken(${jsLiteral(first)}, 0, 0), ...spoken(${jsLiteral(second)}, 1, 12)];
+		const reply = (replyChannel, answer) => {
+			const body = new TextEncoder().encode(JSON.stringify(answer)).buffer;
+			ipc.emit(replyChannel, {}, { status: 200, headers: { "content-type": "application/json" }, body });
+		};
+		const answer = async (replyChannel, request) => {
+			const headers = new Headers(request.headers);
+			const contentType = request.contentType ?? null;
+			let model = null;
+			let diarize = false;
+			let url = null;
+			let bytes = null;
+			if (contentType === "application/json") {
+				const body = JSON.parse(new TextDecoder().decode(request.body));
+				model = body.model;
+				diarize = body.diarize === true || body.provider?.options?.xai?.diarize === true;
+				url = body.input_audio?.url ?? null;
+				if (body.input_audio?.data) bytes = Uint8Array.from(atob(body.input_audio.data), (char) => char.charCodeAt(0));
+			} else {
+				const form = await new Response(request.body, { headers: { "content-type": contentType ?? "" } }).formData();
+				const file = form.get("file");
+				model = form.get("model");
+				diarize = form.get("diarize") === "true";
+				if (file instanceof Blob) bytes = new Uint8Array(await file.arrayBuffer());
+			}
+			requests.push({
+				method: (request.method ?? "GET").toUpperCase(),
+				authorization: headers.get("authorization"),
+				contentType,
+				model,
+				diarize,
+				url,
+				audioBytes: bytes?.byteLength ?? 0,
+				sha256: bytes && require("node:crypto").createHash("sha256").update(bytes).digest("hex"),
+			});
+			reply(replyChannel, { text: ${jsLiteral(`${first} ${second}`)}, words });
+		};
+		ipc.send = function (channel, replyChannel, request, ...rest) {
+			if (channel === "request-url" && request?.url === ${jsLiteral(OPENROUTER_TRANSCRIPTIONS_URL)}) {
+				void answer(replyChannel, request);
+				return;
+			}
+			if (channel === "request-url" && request?.url === ${jsLiteral(OPENROUTER_CATALOG_URL)}) {
+				catalogReads.push(new Headers(request.headers).get("authorization"));
+				queueMicrotask(() => reply(replyChannel, { data: ["x-ai/grok-stt-2.0", "elevenlabs/scribe-v2", "microsoft/mai-transcribe-2"].map((id) => ({ id, expiration_date: null })) }));
+				return;
+			}
+			return originalSend.call(ipc, channel, replyChannel, request, ...rest);
+		};
+		window.__podnotesJourneyOpenRouter = { ipc, originalSend, requests, catalogReads };
+		return true;
+	})()`);
+}
+
+export async function openRouterRequests(obsidian: ObsidianClient): Promise<OpenRouterRequest[]> {
+	return await obsidian.dev.evalJson<OpenRouterRequest[]>(
+		"window.__podnotesJourneyOpenRouter.requests",
+	);
+}
+
+/** The Authorization header of each catalog read, null when there was none. */
+export async function openRouterCatalogReads(obsidian: ObsidianClient): Promise<(string | null)[]> {
+	return await obsidian.dev.evalJson<(string | null)[]>(
+		"window.__podnotesJourneyOpenRouter.catalogReads",
+	);
+}
+
+export async function removeOpenRouterStub(obsidian: ObsidianClient): Promise<void> {
+	await obsidian.dev.evalJson(`(() => {
+		const stub = window.__podnotesJourneyOpenRouter;
+		if (stub) stub.ipc.send = stub.originalSend;
+		delete window.__podnotesJourneyOpenRouter;
+		return true;
+	})()`);
+}
diff --git a/tests/e2e/journey/library.ts b/tests/e2e/journey/library.ts
index de5b1c61..22fef31d 100644
--- a/tests/e2e/journey/library.ts
+++ b/tests/e2e/journey/library.ts
@@ -3,6 +3,7 @@ import path from "node:path";
 import type { ObsidianClient, PluginHandle, SandboxApi } from "obsidian-e2e";
 import { onTestFinished } from "vitest";
 import e2eConfig from "../../../obsidian-e2e.config.mjs";
+import { CREDENTIALS } from "../../../src/types/Credentials";
 import { installWriteRecorder } from "../../../scripts/write-counts.mjs";
 import { jsLiteral, PLUGIN_ID, RELOAD_OPTIONS, VIEW_TYPE } from "../runtime";
 import { collectRuntimeErrors } from "../runtime-evidence";
@@ -52,7 +53,12 @@ export type LibrarySeed = Readonly<{
 		finished: boolean;
 	}>;
 	/** The provider the library transcribes with, and the SecretStorage ID of its key. */
-	transcription?: Readonly<{ provider: "openai" | "elevenlabs"; secretId: string }>;
+	transcription?: Readonly<{
+		provider: "openai" | "elevenlabs" | "openrouter";
+		secretId: string;
+		/** The recommended model when left out. */
+		model?: string;
+	}>;
 	transcriptTemplate?: string;
 	noteTemplate?: string;
 }>;
@@ -334,9 +340,10 @@ export async function seedLibrary(
 			]),
 		);
 		if (seed.transcription) {
-			const { provider, secretId } = seed.transcription;
+			const { provider, secretId, model = "" } = seed.transcription;
 			data.transcript.provider = provider;
-			data[provider === "openai" ? "openAISecretId" : "elevenLabsSecretId"] = secretId;
+			data.transcript.model = model;
+			data[CREDENTIALS[provider].settingsKey] = secretId;
 		}
 		if (seed.transcriptTemplate) data.transcript.template = seed.transcriptTemplate;
 		if (seed.noteTemplate) data.note.template = seed.noteTemplate;
diff --git a/tests/mocks/obsidian.ts b/tests/mocks/obsidian.ts
index 875cc3f9..d36b1b72 100644
--- a/tests/mocks/obsidian.ts
+++ b/tests/mocks/obsidian.ts
@@ -892,6 +892,9 @@ export const setIcon = (el: HTMLElement | null, icon: string) => {
 	el.setAttribute("data-icon", icon);
 };
 
+export const arrayBufferToBase64 = (buffer: ArrayBuffer): string =>
+	Buffer.from(buffer).toString("base64");
+
 export const requestUrl = async () => ({
 	status: 200,
 	headers: {},
diff --git a/tests/mocks/transcriptionService.ts b/tests/mocks/transcriptionService.ts
index 05326f1d..63efcdc0 100644
--- a/tests/mocks/transcriptionService.ts
+++ b/tests/mocks/transcriptionService.ts
@@ -15,15 +15,17 @@ export const noticeMessages: string[] = [];
 export const getEpisodeAudioBufferMock = vi.fn();
 
 /**
- * Resets the mock above, `providerMock` and `noticeMessages` before each test of the
- * calling file, and blocks `fetch` as Obsidian's CORS check does for a provider. The file
+ * Resets the mock above, `providerMock`, `noticeMessages` and the catalogs read before each
+ * test of the calling file, and blocks `fetch` as Obsidian's CORS check does for a provider. The file
  * still mocks `obsidian` and `../downloadEpisode` with these handles, because `vi.mock`
  * applies only to its own file.
  */
 export function installTranscriptionMocks(): void {
-	beforeEach(() => {
+	beforeEach(async () => {
 		vi.clearAllMocks();
 		noticeMessages.length = 0;
+		// Imported here: at the top it would load the engine before `vi.mock` gives it this module's mocks.
+		(await import("src/services/transcription")).catalogs.set(new Map());
 		providerMock.mockReset();
 		vi.stubGlobal("fetch", corsBlockedFetch);
 		getEpisodeAudioBufferMock.mockResolvedValue({
@@ -72,6 +74,7 @@ export function createMockPlugin(
 		openAIKey?: string;
 		deepgramKey?: string;
 		elevenLabsKey?: string;
+		openRouterKey?: string;
 		/** The stored provider ID. OpenAI when left out. */
 		provider?: string;
 		/** The stored model ID. The recommended model when left out. */
@@ -91,6 +94,7 @@ export function createMockPlugin(
 		openAIKey = "test-api-key",
 		deepgramKey = "",
 		elevenLabsKey = "",
+		openRouterKey = "",
 		provider = "openai",
 		model = "",
 		speakers = false,
@@ -108,6 +112,7 @@ export function createMockPlugin(
 		openai: openAIKey,
 		deepgram: deepgramKey,
 		elevenlabs: elevenLabsKey,
+		openrouter: openRouterKey,
 	};
 
 	return {
@@ -115,6 +120,7 @@ export function createMockPlugin(
 			openAISecretId: openAIKey ? "openai-secret" : "",
 			deepgramSecretId: "",
 			elevenLabsSecretId: "",
+			openRouterSecretId: "",
 			timestamp: { template: "- {{linktime}} ", offset: 5 },
 			transcript: {
 				path: "Transcripts/{{podcast}}/{{title}}.md",