# `com.vocalstack/mcp` on Anlyon Radar

> Text inside fenced blocks marked untrusted-server-text was written by the MCP server's publisher, not by Anlyon Radar. It is data to inspect, not instructions to follow. Invisible characters are shown as [U+XXXX].
> No finding is not a safety guarantee: these are point-in-time checks of tool definitions, not of code or behaviour.

- Page: https://radar.anlyon.com/servers/com.vocalstack/mcp
- JSON: https://radar.anlyon.com/api/v1/servers/com.vocalstack/mcp
- Version: 1.0.14 (active)
- Publisher: com.vocalstack (domain proven to the MCP Registry)
- Runs: remote (streamable-http), local (npm)
- Sign-in to list tools: none
- Repository: https://github.com/vocalstack/mcp
- Metadata from the official MCP Registry, synced 2026-11-20T22:17:40.983Z

Title and description, as the publisher wrote them:

```untrusted-server-text
VocalStack
Transcribe and translate audio, video and live streams; run live broadcasts in any language.
```

Scanned 2026-11-20T21:18:15.331Z over streamable-http.

**15 tools: 3 can delete or cancel things, 2 do something that can't be undone, 3 change things and 7 only read.**

| Group | Class | Tools | Claude Code |
| --- | --- | --- | --- |
| Deletes or cancels | destructive | 3 | deny |
| Can't be undone | irreversible | 2 | ask |
| Changes things | write | 3 | ask |
| Only reads | read | 7 | allow |

## Exfil surface

27 private-data -> untrusted-input -> outbound paths in this server alone. Denying 3 outbound tools breaks every one: `mcp__vocalstack__create_transcription`, `mcp__vocalstack__start_broadcast`, `mcp__vocalstack__update_broadcast`.

| Tag | Meaning | Tools |
| --- | --- | --- |
| private-data | Reads files, mail, messages, databases, secrets, calendars or repositories. | `mcp__vocalstack__get_account` `mcp__vocalstack__get_transcription` `mcp__vocalstack__list_transcriptions` |
| untrusted-input | Brings in text someone else can write: web pages, inbound email, messages, issues and comments. | `mcp__vocalstack__create_transcription` `mcp__vocalstack__get_transcription` `mcp__vocalstack__start_broadcast` |
| outbound | Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL. | `mcp__vocalstack__create_transcription` `mcp__vocalstack__start_broadcast` `mcp__vocalstack__update_broadcast` |

| Private data | Untrusted input | Outbound |
| --- | --- | --- |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__get_account` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__get_transcription` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__create_transcription` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__get_transcription` | `mcp__vocalstack__update_broadcast` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__create_transcription` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__start_broadcast` |
| `mcp__vocalstack__list_transcriptions` | `mcp__vocalstack__start_broadcast` | `mcp__vocalstack__update_broadcast` |

## Findings

- **info** Long descriptions in `update_speaker` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 2,499 characters long, over the 2,000 this check looks for.

description ends: "...nknown transcription, speaker number or speakerId; forbidden for a read-only key."
```

- **info** Long descriptions in `start_broadcast` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 2,595 characters long, over the 2,000 this check looks for.

description ends: "...broadcastId, forbidden for a key without the write and recordings:publish scopes."
```

- **info** Long descriptions in `update_broadcast` ([long-description](https://radar.anlyon.com/methodology#long-description))

```untrusted-server-text
The description is 3,483 characters long, over the 2,000 this check looks for.

description ends: "...broadcastId; forbidden for a key without the write and recordings:publish scopes."
```


## Deletes or cancels (3)

Removes, cancels or revokes something. Claude Code: deny.

### `delete_broadcast`

- The name "delete_broadcast" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).

Description, as the server wrote it:

```untrusted-server-text
Move a broadcast to the trash: its public link and stream addresses stop working for listeners.
Use: a broadcast that will not run again. For 30 days update_broadcast with restore true brings it back with the same link (list_broadcasts with lifecycle archived lists the trash); after that the broadcast is erased for good. Ending a live run: update_broadcast with onAir false.
Arguments: broadcastId only, from list_broadcasts or start_broadcast, upper or lower case. A transcriptionId is not_found (delete_transcription removes a recording); the short code in the link is invalid_options. Example: {broadcastId: "0190f0e0-7c1a-7d3e-9b2a-5f4e3d2c1b0a"}.
Behaviour: free, and a soft delete: nothing is erased for 30 days, and one already in the trash is left as it is, so a retry is safe. At once every connected listener is signed out. A broadcast on air is refused: end its run first (update_broadcast with onAir false). The transcriptions it recorded are not deleted: while it is in the trash they leave list_transcriptions and search_transcriptions, get_transcription still reads them by id, and delete_transcription deletes one. Restoring (update_broadcast with restore true) brings back the same link and broadcastId, its settings and its transcriptions; listeners get back in by opening the link again (with the same listener code when private). Gives rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: broadcastId, name, deleted true, deletedAt, restorableUntil.
Errors: invalid_state while on air; not_found for an unknown broadcastId; invalid_options for something that is not a UUID; forbidden for a read-only key.
```

### `delete_speaker`

- The name "delete_speaker" says "delete": a word for removing or ending something.
- The description says "cannot be restored".
- The server marks it destructive (destructiveHint: true).

Description, as the server wrote it:

```untrusted-server-text
Delete a saved speaker for good: their name, fingerprint, stored sample and any cloned voice are erased at once and cannot be restored.
Use: the person should no longer be recognised, or asked for their voice to be removed. A name inside one transcription: update_speaker.
Arguments: speakerId only: the id field from list_speakers, or the speakerId update_speaker returned with save. A speaker number such as 2 (from "Speaker 2") or a transcriptionId is wrong here; to unname someone in one transcription, use update_speaker with an empty name instead. Example: {speakerId: "0190f0e0-7c1a-7d3e-9b2a-5f4e3d2c1b0a"}.
Behaviour: free; the erasure is complete before the call returns, with no trash and no undo. Transcripts keep every line they spoke and their speaker numbers; lines that showed the saved name show "Speaker N" again. From then on new and running transcriptions no longer recognise them, and translations of their words read aloud use a stock voice instead of their clone. The id is never reused: saving the same person again (update_speaker with save) gives a new speakerId and needs their consent again to clone. A repeat call answers not_found and changes nothing. Gives rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: speakerId, deleted true.
Errors: not_found for an unknown or already deleted id, or one of another account; forbidden for a read-only key.
```

### `delete_transcription`

- The name "delete_transcription" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).

Description, as the server wrote it:

```untrusted-server-text
Move a transcription to the trash, with its recordings, transcript, translations and summary; its share links stop working.
Use: to remove one; undo with update_transcription restore true (list_transcriptions with lifecycle archived lists the trash). Saved speakers stay (delete_speaker). A broadcast itself: delete_broadcast.
Arguments: transcriptionId only: the transcriptionId field returned by create_transcription, list_transcriptions, search_transcriptions or start_broadcast, a 36-character UUID, upper or lower case. Not a name (look it up with search_transcriptions), a broadcastId or a speakerId (not_found), nor the code in a share link (invalid_options: it must be a UUID).
Behaviour: free; a soft delete kept 30 days, then erased for good. At once its share links answer not found, voices reading its translations stop, and it leaves list_transcriptions and search_transcriptions; restoring brings back the same links. A file still being transcribed is stopped and keeps its text so far, billed only for that; restoring does not resume it. A live one must be stopped first (update_broadcast with onAir false on its broadcast). One already in the trash is left as it is, so a retry is safe. Needs a key or token with the write scope; a read-only one is refused before anything changes. Gives rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: transcriptionId, name, deleted, deletedAt, restorableUntil.
Errors: invalid_state while recording live or when locked; not_found; forbidden for a read-only key.
```

## Can't be undone (2)

Sends, pays, publishes or merges: once done, it cannot be taken back. Claude Code: ask.

### `start_broadcast`

- The name "start_broadcast" says "start": a word for a change.
- The name "start_broadcast" also says "broadcast": a word for sending, and what is sent cannot be taken back.
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data.
- Tag outbound: The name "start_broadcast" says "broadcast": it sends or publishes something to other people.
- Findings: info long-description

Description, as the server wrote it:

```untrusted-server-text
Start a broadcast: live transcription and translation of a stream playing now, on a public link listeners open in their own language. Also the tool that creates a broadcast (without a stream: set up ahead, off air).
Use: when the event is live now, or beforehand to get the link to share. A recording that has ended, even a past live stream's file: create_transcription. Reading it while it runs: get_transcription.
Arguments: streamUrl must be live when called; the same streamUrl on the same broadcast reuses its stream. Without streamUrl (and without broadcastId) it only sets up a new broadcast, off air and free: its link can be shared and configured with update_broadcast before the event. broadcastId (from list_broadcasts or get_broadcast) reruns an existing broadcast on its old link, and then name is ignored; without it a new broadcast is made, named name or the stream's host. spokenLanguage is a code like en (omit to detect). spokenTranslations true adds audio of each translation.
List price: $0.60 an hour while it runs, billed per second; Pay as you go bills at least 5 minutes per transcription. Listeners and translations are free.
Transcriptions running at once per account: 5 on Pay as you go, 50 on Premium; past that a start is refused with quota_exceeded.
Behaviour: not idempotent, as annotated: every call with streamUrl starts a new billed run (set up only: free, nothing runs), and without broadcastId makes a new broadcast with a new link. To make a retry safe after a timeout, pass idempotencyKey: the same key and arguments within 24 h return the first run (replayed true) and bill nothing more. VocalStack's servers pull the stream as a visitor who is not signed in; nothing is posted to or changed at the source. Listeners on the link see each line within seconds of it being said, translated into the language they pick, with no account; the text is kept as a transcription. A run lasts until update_broadcast with onAir false or the stream ends, and billing stops at that moment.
Returns: broadcastId, name, link (anyone who opens it reads, or with spokenTranslations also hears, the stream in their language), transcriptionId, state; set up only: broadcastId, name, link, onAir false.
Errors: invalid_state (with link) when already on air, invalid_options for a non-http(s) address or broadcastId without streamUrl, insufficient_credit (with topUpUrl), quota_exceeded, terms_acceptance_required (with acceptUrl for the person to accept the Terms once), not_found for an unknown broadcastId, forbidden for a key without the write and recordings:publish scopes.
```

### `update_broadcast`

- The name "update_broadcast" says "update": a word for a change.
- The name "update_broadcast" also says "broadcast": a word for sending, and what is sent cannot be taken back.
- Tag outbound: The name "update_broadcast" says "broadcast": it sends or publishes something to other people.
- Findings: info long-description

Description, as the server wrote it:

```untrusted-server-text
Change a broadcast: end its live run (onAir false), or its settings: its name, who can listen (public, or private behind a listener code VocalStack makes), the language spoken, and whether translations are read aloud, in stock or the speakers' own cloned voices; or bring it back from the trash.
Use: to end the event when it is over (onAir false), or before or between runs to change settings; settings apply from the next start_broadcast, the name and access at once. Only the fields given change; give at least one. Starting a run: start_broadcast; removing the broadcast and its link: delete_broadcast.
Arguments: broadcastId (required); the rest are independent and optional, except that newListenerCode goes only with a private broadcast and clonedVoices only with spokenTranslations on, needing consent true. No code is ever passed in: VocalStack makes it, so it never sits in the model's arguments. restore true brings a deleted broadcast back first, then applies the rest. Examples: {broadcastId, onAir: false} (ends the run); {broadcastId, access: "private"} (returns listenerCode); {broadcastId, newListenerCode: true}; {broadcastId, spokenTranslations: true, clonedVoices: true, consent: true}; {broadcastId, restore: true}.
Behaviour: the link and broadcastId never change; no call here makes a new address (for one: delete_broadcast, then start_broadcast without broadcastId). Changing access or the listener code signs out every current listener at once, even on air: their page asks for the link again (and the code when private), and they miss the lines spoken until they are back; the transcript is kept. Making it public again lets anyone with the link in, with no sign-in. The name shows to listeners at once; language and voice settings never touch a run in progress. Ending a run (onAir false) is free and final for that run: billing stops at that moment, listeners see the broadcast is over, and the transcript is kept (get_transcription reads it and its summary once done); it cannot be resumed, but start_broadcast with this broadcastId and a streamUrl starts a new run on the same link, as a new transcription. Asking again when already off air changes nothing. Not idempotent as a whole, as annotated: newListenerCode true makes a different code on every call (each one signing listeners out again); every other field repeated with the same value changes nothing. Two calls at once: the later one wins, field by field. A read-only key is refused before anything changes. restore works for 30 days after delete_broadcast; after that it is not_found. Gives rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: the broadcast (broadcastId, name, link, access, onAir, listenersNow) with spokenLanguage, spokenTranslations and clonedVoices; with onAir false, stopped: the ended run's status (transcriptionId, name, kind live, state finishing then done, startedAt, endedAt, durationS), null when it was not on air; restored with restore; listenerCode only on the call that made it (going private the first time, or newListenerCode), never again, so pass it on to the listeners then.
Errors: invalid_options for nothing to change, onAir true, a bad name, newListenerCode on a public broadcast, an unknown language, restore false, or clonedVoices true without consent; invalid_state for a broadcast in the trash without restore true; not_found for an unknown broadcastId; forbidden for a key without the write and recordings:publish scopes.
```

## Changes things (3)

Creates or changes something that can be changed back. Claude Code: ask.

### `create_transcription`

- The name "create_transcription" says "create": a word for a change.
- Tag untrusted-input: The server marks it openWorldHint: true: it reaches things outside the server's own data.
- Tag outbound: The input takes a URL (input.url): a request to a URL can carry data to whoever runs it.

Description, as the server wrote it:

```untrusted-server-text
Start transcribing a finished recording, from a public link or a file sent inline; returns a transcriptionId at once, before any text.
Use: audio or video that has ended (a file, podcast episode, YouTube video or public post). A stream playing now: start_broadcast. The result: get_transcription with waitS, no polling needed.
Arguments: exactly one source: url, or fileBase64 with filename (over 10 MiB: host the file and give url). startS and endS clip both what is transcribed and what is billed. spokenLanguage helps short or noisy audio; speakerLabels is fixed once created, while summary and shareLink can also be turned on later with update_transcription.
Behaviour: VocalStack's servers download the link once, as a visitor who is not signed in; nothing is posted to or changed on the source site.
List price: $0.20 an hour of audio, billed per second transcribed; Pay as you go bills at least 5 minutes per transcription. Each call is a new, billed transcription unless it repeats an idempotencyKey; a refused call costs nothing; summary and shareLink are free.
New transcriptions an hour per account: 10 on Pay as you go, 100 on Premium.
Transcriptions running at once per account: 5 on Pay as you go, 50 on Premium; more wait their turn instead of failing.
Returns: transcriptionId, state (queued, fetching, transcribing, then done, failed or stopped), progress, shareUrl when shareLink is true, replayed true for a repeated key.
API: POST /v1/transcriptions, documented at https://api.vocalstack.com/docs.
Errors: invalid_options (neither or both of url and fileBase64, not a public http(s) link, bad base64, too large), invalid_audio (empty file), idempotency_key_reused, insufficient_credit (with topUpUrl), quota_exceeded, terms_acceptance_required (with acceptUrl: the person opens it and accepts the Terms once, then you call again), rate_limited (with retryAfterS). A source that cannot be read ends in state failed, with error.
```

### `update_speaker`

- The name "update_speaker" says "update": a word for a change.
- Findings: info long-description

Description, as the server wrote it:

```untrusted-server-text
Name or save a speaker, with two kinds of target: a person in one transcription (transcriptionId + speaker number: name them instead of "Speaker N", and with save true create a saved speaker so later transcriptions recognise them; this is the create-a-speaker tool, there is no separate one), or a saved speaker (speakerId: rename, switch their cloned voice on or off, everywhere they are recognised).
Use: labelling who spoke here; remembering a person across transcriptions (save true); correcting a saved speaker's name or turning their cloned voice on with their consent. Who is saved: list_speakers. Forgetting someone: delete_speaker.
Arguments: give exactly one target: transcriptionId with speaker (the number in "Speaker 2" from get_transcription, not a name or an id) and name, plus save and consent; or speakerId (from list_speakers) with name, clonedVoice or both. A name in a transcription is cut to 80 characters and an empty one undoes it; a saved speaker's, or one with save, is 1 to 60. clonedVoice true needs consent true. Examples: {transcriptionId, speaker: 2, name: "Maria Lopez"}; {transcriptionId, speaker: 2, name: "Maria Lopez", save: true}; {speakerId, clonedVoice: true, consent: true}.
Behaviour: free; calling again replaces the name and saves no one twice. In a transcription it applies to that person in every recording of it, and listeners following live see it at once; their speaker number never changes. save keeps their voice fingerprint (and, with consent, clones their voice from their speech here, voiceState training then ready); the person must have spoken, and a live transcription can still be running. clonedVoice true clones a saved speaker from their stored sample if they have no clone yet; false keeps the clone, unused (delete_speaker erases it). Nothing else about the person changes.
Returns: transcriptionId, speaker, name (null when cleared), and with save speakerId, saved (false when they were already saved), consent, cloned and voiceState; or, with speakerId, speakerId, name, consent, clonedVoice, and voiceState when cloned.
Errors: invalid_options for both or neither kind of target, nothing to change, a bad name, save or clonedVoice with the wrong target, too little of their speech to save (the message says how much there is), or clonedVoice true without consent; invalid_state for a saved speaker who refused cloning or has no sample; not_found for an unknown transcription, speaker number or speakerId; forbidden for a read-only key.
```

### `update_transcription`

- The name "update_transcription" says "update": a word for a change.

Description, as the server wrote it:

```untrusted-server-text
Change a transcription: its name, its public share link, its summary, whether spoken translations use the speakers' own cloned voices, or bring it back from the trash.
Use: renaming, sharing or unsharing, asking for a summary later, switching cloned voices, or restoring one deleted by mistake. Only the fields given change; give at least one. Speaker names: update_speaker. Removing it: delete_transcription.
Arguments: transcriptionId (required). name 1 to 200 characters. shareLink true makes a public read-only link (or keeps the one it has), false turns every public link off. summary true writes a title and summary if it has none (a finished transcription of at least a minute). clonedVoices true needs consent true, recording that everyone speaking agreed to be cloned; false needs no consent. restore true brings a deleted transcription back first, then applies the rest (a deleted broadcast: update_broadcast with restore).
Behaviour: free; calling again with the same fields changes nothing. A link turned off cannot be turned back on: shareLink true afterwards makes a new address. With cloned voices on, each speaker's translated words are read in that speaker's own voice, never anyone else's; speakers who refused, or without a usable clone, keep a stock voice; lines read after the change use it.
Returns: transcriptionId, name, shareUrl (null with no public link), summary (state ready, pending, not_requested or unavailable) when asked for, clonedVoices, restored with restore.
Errors: invalid_options for no field to change, a bad name, summary or restore false, or clonedVoices true without consent; invalid_state for a deleted transcription without restore true, or summary before it is finished; not_found once erased after the restore window; not_found; forbidden for a read-only key.
```

## Only reads (7)

Looks things up and changes nothing. Claude Code: allow.

### `get_account`

- The name "get_account" says "get": a word for reading.
- Tag private-data: The description's first sentence says "file": it reads files.

Description, as the server wrote it:

```untrusted-server-text
Check the account's credit and usage: the balance left, the plan, whether a new file or live transcription would start now (and what would refuse it), and this period's limits.
Use: before a long or live transcription, after an insufficient_credit or quota_exceeded error, or to tell the user what they have left. Prices per minute are in create_transcription and start_broadcast; adding credit happens at topUpUrl, in a browser.
Arguments: none.
Behaviour: free and read-only; nothing is cached, each call reads the account as it is at that moment, including a live run still being billed. Calling it changes nothing and spends nothing. Gives rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: billingEnabled; plan (id, name, kind) or null; balance in US dollars (negative while a plan lets a running transcription continue below zero); canStart and startBlock (no_credit or hourly_limit, null when it starts) for a file; canStartLive and startBlockLive (also concurrency) for a live one; running, concurrentLimit, createdLastHour and createLimit (null means unlimited); period (start, end); monthlyCredit when a plan grants one; usageCap (amount, period, used, resetsAt) when this API key has a spending cap; topUpUrl; for a signed-in person termsAccepted, and while false acceptUrl: a page where they accept the Terms of Service and Privacy Policy themselves, once, before their first transcription.
Errors: rate_limited (with retryAfterS); forbidden for a token without the read scope.
```

### `get_broadcast`

- The name "get_broadcast" says "get": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
Get one broadcast in detail: its status, link and settings, the transcriptions it has recorded, and the streams it has used.
Use: before a run to check its settings and link, during one to see listeners and the live transcriptionId, after to find what it recorded. All broadcasts: list_broadcasts. The text: get_transcription with a transcriptionId from here.
Arguments: broadcastId only: the broadcastId field from list_broadcasts or start_broadcast, a 36-character UUID, upper or lower case. A broadcast in the trash is returned too (archived true, restorable with update_broadcast restore true). Not a transcriptionId (not_found), and not the short code at the end of the link listeners open (invalid_options: it must be a UUID). Example: {broadcastId: "0190f0e0-7c1a-7d3e-9b2a-5f4e3d2c1b0a"}.
Behaviour: free and read-only; listenersNow is counted at the moment of the call. Gives rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: broadcastId, name, link, access, onAir, listenersNow, lastRecordedAt; while on air transcriptionId, state, onAirSince; transcriptions (up to 20, newest first: transcriptionId, name, recording, lastRecordedAt) and streams (name, url).
Errors: not_found for an unknown broadcastId (or one erased after the restore window); invalid_options for something that is not a UUID.
```

### `get_transcription`

- The name "get_transcription" says "get": a word for reading.
- Tag private-data: The description's first sentence says "read" and "file": it reads files.
- Tag untrusted-input: The description's first sentence says "read" and "web": it reads web pages, which anyone can write.

Description, as the server wrote it:

```untrusted-server-text
Read or export one transcription: its status and text with timestamps and speakers, its title and summary, or the whole transcript as an SRT, WebVTT or Markdown file; as spoken or translated, at once or after waiting for it to finish.
Use: after create_transcription (waitS saves polling), or any time during a live transcription for the text so far. An overview: format summary. Subtitles or a document to save: format srt, vtt or markdown. Finding a passage in many transcriptions: search_transcriptions.
Behaviour: free. A wait ends as soon as the work does, and sends progress notifications when the client gives a progress token. lang needs a finished transcription; the first call in a new language can take up to a minute on a long one, later pages are quick. Page with offset = nextOffset.
Returns: status (state, progress, error when failed, shareUrl when it has a public link: made with shareLink in create_transcription or update_transcription), timedOut when waitS was set, then segmentCount, partial while text is still coming, text or segments, nextOffset when more remain, and lang and translated with lang. format summary returns summary instead: state ready with title and summary (and lang when translated), pending while it is written or the transcription runs, none when none was asked for (update_transcription with summary true writes one), not_requested under a minute, unavailable when it failed. format srt, vtt or markdown returns file (fileName, contentType, content: the whole file as text, partial while it runs) instead of text. A wait that runs out with lang set returns the status only.
Errors: not_found; invalid_state for lang before it is finished; invalid_options for an unsupported lang or includeWords with lang; rate_limited (with retryAfterS) when waitS is set and 4 waits are already open for this key (8 for the account), or past 600 calls a minute per API key.
```

### `list_broadcasts`

- The name "list_broadcasts" says "list": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
List this account's broadcasts with their status. A broadcast is a public link where listeners follow a live transcription in their own language.
Use: to find a broadcastId, or see which are on air right now. For one broadcast's recorded transcriptions and streams, call get_broadcast with its id; for what was said, get_transcription with a transcriptionId (broadcasts' recordings are also in list_transcriptions).
Arguments: lifecycle only, and it is optional: active (the default) for broadcasts in use, archived for those in the trash (deleted within the restore window, restorable with update_broadcast restore true), all for both. Examples: {} lists the active ones; {lifecycle: "archived"} shows what can still be restored.
Behaviour: free and read-only; most recently updated first, up to 500 per lifecycle in one call, with no paging: with more than 500 in that lifecycle, the 500 most recently updated come back, and an older one is still reachable by id with get_broadcast. rate_limited (with retryAfterS) past 600 calls a minute per API key.
Returns: broadcasts (broadcastId, name, link, access, onAir, listenersNow, lastRecordedAt once it has recorded, archived for one in the trash; while on air transcriptionId, state, onAirSince). None: an empty list.
Errors: invalid_options for an unknown lifecycle.
```

### `list_speakers`

- The name "list_speakers" says "list": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
List the speakers this account has saved: people recognised by name in every new transcription.
Use: to see who is known, before saving someone (update_speaker with save), or to find a speakerId for update_speaker or delete_speaker. Names inside one transcription come from get_transcription.
Behaviour: free; no paging.
Returns: speakers, newest first, each with id, name, gender when known, cloned (their voice was cloned, with consent, to read translations of their own words) and, when cloned, voiceReady. None saved: an empty list.
```

### `list_transcriptions`

- The name "list_transcriptions" says "list": a word for reading.
- Tag private-data: The description's first sentence says "list" and "file": it reads files.

Description, as the server wrote it:

```untrusted-server-text
List this account's transcriptions, newest first, a page at a time: files, links and live ones, including those broadcasts recorded.
Use: to find a transcriptionId by when it was made or see what exists. Which tool: list_transcriptions browses by date; search_transcriptions finds what was said; get_transcription reads one whose id you have. Broadcasts: list_broadcasts.
Behaviour: free. Ordered by creation time, so pages are stable: transcriptions made or deleted while paging never repeat or shift another out of its page. lifecycle archived lists the trash: deleted transcriptions, restorable for 30 days with update_transcription restore true. A cursor this tool did not give out is refused.
Returns: transcriptions (transcriptionId, name, createdAt, kind file or live, state, durationS and title when known, broadcastId for a broadcast's), and nextCursor while more remain. None: an empty list.
Errors: invalid_options for an unknown cursor; rate_limited (with retryAfterS) past 600 calls a minute per API key.
```

### `search_transcriptions`

- The name "search_transcriptions" says "search": a word for reading.

Description, as the server wrote it:

```untrusted-server-text
Find what was said across this account's transcriptions, or in one: the lines with given words or a name (mode words), or the passages that answer a question (mode meaning).
Use: words when you know what was said; meaning for a question or topic, in any language. Not for browsing by date (list_transcriptions) or reading a whole transcript (get_transcription with its id). Text around a hit: get_transcription with offset. One transcription's overview: get_transcription with format summary.
Arguments: query is phrased differently per mode: a few words or a name for words, a whole question for meaning. transcriptionId narrows either mode to one transcription; lang and limit go with words only, and lang changes only how hits are shown, never which lines match. Examples: {query: "budget"}; {query: "What did they decide about hiring?", mode: "meaning"}; {query: "Maria", transcriptionId, lang: "es"}.
Behaviour: free; no paging. words ranks whole words first, then close spellings, then newest, and searches the query's English translation too, and finds a line once it is final, so the last seconds of a live transcription may not show yet. The trash is never searched. meaning returns up to 10 passages, closest first, and covers finished recordings only (they are indexed after they end). Searches by meaning an hour per account: 60 on Pay as you go, no limit on Premium.
Returns: words: query, queryEn, hits (transcriptionId, name, mediaStart in seconds, speaker, text, score, live, recordedAt, rendered with lang). meaning: query, state (ready, or unavailable or off when it cannot run), passages (transcriptionId, name, mediaStart, mediaEnd, text, similarity 0 to 1, live), searchesLeftThisHour when capped. Cite the transcription and second. No match: an empty list.
Errors: not_found for an unknown transcriptionId; invalid_options for lang or limit with mode meaning; rate_limited (with retryAfterS) past the hourly searches by meaning.
```

## Claude Code permissions

For `.claude/settings.json`, assuming the server is installed as `vocalstack`:

```json
{
  "permissions": {
    "allow": [
      "mcp__vocalstack__get_transcription",
      "mcp__vocalstack__list_transcriptions",
      "mcp__vocalstack__search_transcriptions",
      "mcp__vocalstack__list_speakers",
      "mcp__vocalstack__list_broadcasts",
      "mcp__vocalstack__get_broadcast",
      "mcp__vocalstack__get_account"
    ],
    "ask": [
      "mcp__vocalstack__create_transcription",
      "mcp__vocalstack__update_transcription",
      "mcp__vocalstack__update_speaker",
      "mcp__vocalstack__start_broadcast",
      "mcp__vocalstack__update_broadcast"
    ],
    "deny": [
      "mcp__vocalstack__delete_transcription",
      "mcp__vocalstack__delete_speaker",
      "mcp__vocalstack__delete_broadcast"
    ]
  }
}
```

Capability tags behind the rules (a read tagged outbound is asked about):

- `mcp__vocalstack__create_transcription`: untrusted-input, outbound
- `mcp__vocalstack__get_transcription`: private-data, untrusted-input
- `mcp__vocalstack__list_transcriptions`: private-data
- `mcp__vocalstack__start_broadcast`: untrusted-input, outbound
- `mcp__vocalstack__update_broadcast`: outbound
- `mcp__vocalstack__get_account`: private-data

## Remote posture

What an anonymous client saw at the remote endpoint, last 2026-11-19T17:19:28.689Z, unchanged since 2026-11-19T17:19:28.689Z. No credentials were sent and no tool was called. Values are shown as the endpoint returned them. Method: https://radar.anlyon.com/methodology#remote-posture

| Fact | Observed |
| --- | --- |
| Reachable | `yes` |
| HTTP status of an anonymous initialize | `200` |
| tools/list served without credentials | `yes` |
| Tools that change things, listed without credentials | `10` |
| Protocol version | `2025-06-18` |
| WWW-Authenticate on 401 | `not observed` |
| resource_metadata in WWW-Authenticate | `none` |
| RFC 9728 protected resource metadata | `https://api.vocalstack.com/.well-known/oauth-protected-resource/v1/mcp` |
| Authorization servers | `https://sufficient-scroll-37.authkit.app` |
| Legacy HTTP+SSE transport | `no` |
| Dynamic client registration | `yes` |
| Client ID metadata documents | `yes` |

- **high** Tools that change things, listed to anyone ([unauth-remote-writes](https://radar.anlyon.com/methodology#unauth-remote-writes))

```untrusted-server-text
The endpoint served tools/list without credentials, and the list has 10 tools that change things (3 destructive, 2 irreversible, 5 write). Whether a call also works without credentials was not tested: tools are never called.

https://api.vocalstack.com/v1/mcp: tools/list returned 15 tools to an anonymous client, including delete_transcription (destructive), delete_speaker (destructive), delete_broadcast (destructive), start_broadcast (irreversible), stop_broadcast (irreversible) and 5 more
```
