Captivate MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Captivate MCPcompare downloads for my last two episodes"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Captivate MCP
An MCP server for Captivate.fm podcast hosting. It lets Claude (or any MCP client) read your shows, episodes and listening analytics, so you can ask things like:
"How did last week's episode do in its first 7 days compared to the previous three?"
"Which countries and apps do my listeners use this quarter?"
"Show me monthly downloads for the past year."
The server is read-only: it never creates, edits or publishes anything in your Captivate account.
Unofficial project, not affiliated with Captivate. Built on the public Captivate API.
Tools
Tool | What it returns |
| All podcasts you have access to |
| Show details and RSS feed URL |
| Episodes of a show (optionally scheduled only, filtered by title) |
| Full episode details: show notes, media, transcript fields |
| Downloads and unique listeners for a show or episode in a date range |
| All-time downloads for a show or episode |
| Downloads per month, past 12 months |
| Average downloads per interval (default 28 days) |
| Time series plus breakdowns by country, app, OS, device, episode |
| Side-by-side performance of two or more episodes |
| Listening behaviour and drop-off in Captivate's web player |
Related MCP server: Klaviyo MCP
Get your API credentials
In Captivate, open My Account → API and generate an API token. You need two values:
CAPTIVATE_USER_ID– your user ID shown on that pageCAPTIVATE_API_TOKEN– the API token
Install
Requires Node.js 18 or newer.
Claude Code
claude mcp add captivate \
-e CAPTIVATE_USER_ID=your-user-id \
-e CAPTIVATE_API_TOKEN=your-api-token \
-- npx -y github:DannyOosterveer/captivate-mcpClaude Desktop
Add this to claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"captivate": {
"command": "npx",
"args": ["-y", "github:DannyOosterveer/captivate-mcp"],
"env": {
"CAPTIVATE_USER_ID": "your-user-id",
"CAPTIVATE_API_TOKEN": "your-api-token"
}
}
}
}From source
git clone https://github.com/DannyOosterveer/captivate-mcp.git
cd captivate-mcp
npm installThen point your MCP client at node /path/to/captivate-mcp/dist/index.js with the two environment variables set.
Notes
Dates are ISO 8601 (
2026-01-31or2026-01-31T00:00:00Z).The API token is exchanged for a session token on first use and refreshed automatically when it expires.
CAPTIVATE_API_URLcan override the API base URL (defaulthttps://api.captivate.fm).
License
MIT
Available Tools
11 toolscompare_episodesCompare episodesARead-only
Compare download performance of several episodes of the same show (aligned from each publish date).
| Name | Required | Description | Default |
|---|---|---|---|
| show_id | Yes | Captivate show ID (from list_shows) | |
| episode_ids | Yes | Two or more episode IDs to compare |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already covers the safety profile, and the description adds a genuine behavioral detail: series are aligned from each publish date, so comparisons are age-normalized. It does not disclose the comparison output shape, any cap on episode count, or whether a fixed lookback window applies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with the key scope qualifier in parentheses. Nothing wasted, nothing buried.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter read-only tool with full schema coverage and an explicit alignment rule, this is nearly complete. Minor gap: with no output schema, it says nothing about what the comparison result contains (metric, granularity, window).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (baseline 3), and the description adds a real constraint not encoded in the schema: all episode_ids must belong to the same show, matching show_id. That semantic linkage is useful; it does not add format/syntax detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (compare) and resource (download performance of several episodes), plus the 'same show' scope and the alignment-to-publish-date basis. No sibling does comparison, so it is distinguishable, though it never names an alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by 'several episodes of the same show' — an agent can infer this is for multi-episode comparison rather than single-episode lookup (get_episode). But there is no explicit when-to-use / when-not guidance or reference to a sibling tool for single-episode or aggregate downloads.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_average_downloadsAverage downloadsARead-only
Average downloads per interval (e.g. per 28 days) over the life of the show.
| Name | Required | Description | Default |
|---|---|---|---|
| show_id | Yes | Captivate show ID (from list_shows) | |
| interval_days | No | Interval length in days (default 28) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already tells the agent this is a safe read. The description adds useful semantics (it is an average, not a raw count, and the window is lifetime rather than a caller-supplied date range), but says nothing about rounding, zero-download handling, or return shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with the metric and the averaging window front-loaded. Nothing redundant and nothing padding the definition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter read tool with a fully documented schema and a readOnly annotation, this is close to sufficient — the only real gap is the absence of any hint about what the response contains or how the average is computed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both show_id and interval_days documented in the schema including the default of 28. The description's 'e.g. per 28 days' merely echoes that default and adds no new meaning, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific metric ('average downloads') with scope ('per interval, over the life of the show'), which implicitly separates it from get_total_downloads and get_monthly_downloads. It stops short of naming those siblings explicitly, so an agent must infer the distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Use is only implied: the 'life of the show' lifetime window and the interval framing hint at when this beats get_total_downloads or get_monthly_downloads, but no alternative is named and no exclusion is stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_episodeGet episodeBRead-only
Full details of one episode: show notes, media URL, transcript fields, SEO fields, etc.
| Name | Required | Description | Default |
|---|---|---|---|
| episode_id | Yes | Captivate episode ID (from list_episodes) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already declares the safe-read profile, so the description's main contribution is naming the returned field groups (show notes, media URL, transcript, SEO). It does not mention permissions, not-found behavior, or size of payload.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One front-loaded sentence with no filler. The trailing 'etc.' slightly weakens precision but keeps it tight.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a detail-fetch tool with no output schema, the description gives only a partial sketch of return fields and trails off with 'etc.', so an agent cannot fully anticipate the response shape. It is adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the sole parameter is fully documented, including a regex pattern and provenance from list_episodes. The description adds no parameter detail beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Full details of one episode') and enumerates the field categories returned, which distinguishes it from list_episodes or get_show. No explicit sibling callout, keeping it just short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the single episode_id parameter, and the schema points to list_episodes as the source of IDs. However, the description never states when to use this versus list_episodes or compare_episodes, leaving the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_monthly_downloadsMonthly downloadsARead-only
Downloads per month over the past 12 months for a show, or for a single episode.
| Name | Required | Description | Default |
|---|---|---|---|
| show_id | Yes | Captivate show ID (from list_shows) | |
| episode_id | No | Captivate episode ID (from list_episodes) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes this is a safe read operation, lowering the disclosure burden. The description adds useful scope and time-window context but does not explain whether downloads are counted on publish date, download date, or another basis, nor does it mention rate limits or data freshness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with zero waste. The metric and time window are front-loaded, followed immediately by the scope options.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only analytics tool with no output schema, the description covers what is measured and the available scopes. It still leaves gaps around what the returned monthly data looks like, whether months are calendar-aligned, and whether the current partial month is included.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds meaning by clarifying that show_id alone yields show-level monthly downloads, while adding episode_id narrows the result to a single episode – a scoping distinction the schema itself does not state.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific metric (monthly downloads), a specific time window (past 12 months), and the two supported scopes (show-level or single-episode). It implicitly separates itself from siblings like get_total_downloads and get_average_downloads by specifying per-month granularity, but it does not explicitly name those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the phrase 'for a show, or for a single episode', which suggests passing episode_id for episode-level data. However, there is no explicit guidance on when to choose this over get_range_analytics, get_total_downloads, get_average_downloads, or compare_episodes, and no exclusion conditions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_overview_analyticsOverview analyticsBRead-only
Downloads for a show (with its top episodes in that period) or for a single episode over a date range.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | End date, ISO 8601 (e.g. 2026-01-31 or 2026-01-31T00:00:00Z) | |
| start | Yes | Start date, ISO 8601 (e.g. 2026-01-31 or 2026-01-31T00:00:00Z) | |
| show_id | Yes | Captivate show ID (from list_shows) | |
| episode_id | No | Limit to one episode | |
| top_episodes | No | Show-level only: how many top episodes to include, ranked by downloads in the period (default 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already establishes the safety profile; the description adds that show-level results include top episodes in the period and that episode-level scope is supported. It does not disclose return shape, pagination, auth, or rate limits, but those gaps are less severe given the annotation and schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The definition is a single waste-free sentence that front-loads the downloads resource and the show/episode branch. It is appropriately sized and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With five parameters but 100% schema coverage and a readOnly annotation, the main operation is adequately conveyed. Still, the absence of output schema leaves return values undescribed, and the lack of sibling guidance makes selection among the many analytics tools less complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3; the description reinforces the show-vs-episode branching and that top episodes are period-ranked at show level. It adds little syntax or mapping beyond the schema, which already documents required dates, show_id, episode_id, and top_episodes default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource (downloads) and the two scopes (a show with top episodes, or a single episode) over a date range, so the operation is clear. It does not name or distinguish itself from siblings such as get_total_downloads, get_range_analytics, or compare_episodes, so sibling differentiation is missing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies the tool is for date-ranged download overviews for a show or episode, but never states when to choose it over get_total_downloads, get_monthly_downloads, get_range_analytics, or compare_episodes. No exclusions or prerequisites are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_range_analyticsAnalytics for a date rangeARead-only
Detailed analytics for a show or episode in a date range: downloads over time plus breakdowns by country, listening app/browser, OS, device, episode and private subscriber.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | End date, ISO 8601 (e.g. 2026-01-31 or 2026-01-31T00:00:00Z) | |
| start | Yes | Start date, ISO 8601 (e.g. 2026-01-31 or 2026-01-31T00:00:00Z) | |
| show_id | Yes | Captivate show ID (from list_shows) | |
| interval | No | Bucket size for the time series, e.g. 1d, 7d, 1M (default 1d) | |
| timezone | No | IANA timezone, e.g. Europe/Amsterdam (default UTC) | |
| breakdowns | No | Which breakdowns to include (default: all; byEpisode only applies to shows) | |
| episode_id | No | Limit to one episode | |
| country_code | No | Filter to one country (ISO 3166-1 alpha-2, e.g. NL) | |
| breakdown_time_series | No | Also return the time series per breakdown item (default false: totals only, much smaller) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint=true already declaring safety, the description still earns credit by describing the return payload (time series plus named breakdowns) in the absence of an output schema. It does not mention cost/latency for a potentially heavy multi-breakdown query or any auth requirements, which keeps it from a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence, front-loaded with scope and then the payload, with no redundant or filler text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 9-parameter analytics tool with no output schema, the description adequately signals the return shape, but it omits any routing guidance against the many overlapping analytics siblings and says nothing about the cost of requesting all breakdowns plus per-item time series. Adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so interval, timezone, breakdowns, episode_id, country_code, and breakdown_time_series are all documented in the schema. The description adds no parameter-level meaning beyond what those field descriptions already say; baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific resource (show or episode analytics in a date range) and enumerates the returned dimensions: downloads time series plus country, app/browser, OS, device, episode and private-subscriber breakdowns. That clearly distinguishes it from narrow siblings like get_total_downloads or get_monthly_downloads, though it does not name any sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There are ten sibling tools, several of which return overlapping download analytics (get_overview_analytics, get_total_downloads, get_monthly_downloads, get_average_downloads, compare_episodes), yet the description gives no when-to-use guidance, no prerequisites, and no exclusions. An agent must infer that 'detailed' means the heavier, richer tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_showGet showARead-only
Full details of one show, including its RSS feed URL.
| Name | Required | Description | Default |
|---|---|---|---|
| show_id | Yes | Captivate show ID (from list_shows) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already establishes this is a safe read. The description adds useful content context, that the RSS feed URL is included in the response, but says nothing about error behavior for invalid/missing show IDs or what 'full details' otherwise covers.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no wasted words, and the most decision-relevant detail (RSS feed URL) appears immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description is the only signal about return contents; 'full details' is vague and only one field (RSS feed URL) is enumerated. Adequate for a simple single-entity read, but it leaves the response shape largely unknown.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the only parameter is documented there with its source (list_shows) and pattern. The description adds nothing about show_id, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Full details of one show') and notes the distinguishing payload (RSS feed URL). It is clearly a single-show read versus the sibling list_shows/get_episode, though it never names those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied — 'one show' suggests use when a single record is needed rather than a listing, but there is no explicit when-to-use or when-not-to-use guidance and no alternative named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_total_downloadsAll-time downloadsARead-only
All-time total downloads for a show, or for a single episode.
| Name | Required | Description | Default |
|---|---|---|---|
| show_id | Yes | Captivate show ID (from list_shows) | |
| episode_id | No | Captivate episode ID (from list_episodes) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already covers the safety profile, so the description only needs to add context. It adds the all-time scope and the fact that omitting episode_id yields show-level totals, but says nothing about what the returned number represents (platforms, refresh cadence, precision).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that front-loads the scope (all-time) and the two aggregation levels. Nothing extraneous.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so ideally the description would say the response is a single total count, but for a two-parameter read-only metric tool this is nearly complete. Minor gaps around what the count includes remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline would be 3, but the description adds real semantics: episode_id is a narrowing filter and the call aggregates at show level when it is absent. That is meaning beyond the schema's bare 'Captivate episode ID (from list_episodes)'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource (total downloads) and scopes it to all-time, with the two aggregation levels (show or single episode) named. It implicitly separates itself from get_monthly_downloads and get_average_downloads via 'all-time', but never names those siblings explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'all-time' qualifier hints at when to prefer this over the period-based download tools, but no explicit when-to-use or when-not-to-use guidance is given. An agent must infer the choice from the sibling names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_web_player_analyticsWeb player analyticsBRead-only
Listening behaviour in Captivate's web player for one episode: listeners, seconds listened, average % listened and drop-off per position.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | End date, ISO 8601 (e.g. 2026-01-31 or 2026-01-31T00:00:00Z) | |
| start | Yes | Start date, ISO 8601 (e.g. 2026-01-31 or 2026-01-31T00:00:00Z) | |
| show_id | Yes | Captivate show ID (from list_shows) | |
| timezone | No | IANA timezone (default UTC) | |
| episode_id | Yes | Captivate episode ID (from list_episodes) | |
| duration_seconds | No | Episode duration in seconds (looked up from the episode's media when omitted) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already covers the safety profile, and the description adds that results are per-episode listening metrics (listeners, seconds, average %, drop-off). It omits anything about the required date window, timezone handling, or how drop-off positions are reported, which are the real behavioural gaps for this call.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single tight sentence with the resource and metric list front-loaded; nothing is padded. It could be marginally better structured by leading with the verb, but it is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description usefully names the returned metrics, and the schema fully covers inputs. Missing only the date-range semantics and any note that some metrics depend on duration_seconds being resolvable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all six parameters (including show_id/episode_id sourcing hints and the duration_seconds fallback) are fully documented in the schema. The description adds nothing beyond that, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names the specific resource (web player listening analytics for a single episode) and enumerates the metrics returned. Scope 'for one episode' distinguishes it from portfolio-level siblings like get_overview_analytics and compare_episodes, though the verb is implicit rather than stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this versus get_range_analytics, get_overview_analytics or compare_episodes. The single-episode scope hints at usage but no conditions, prerequisites or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_episodesList episodesARead-only
List the episodes of a show (newest first) with id, title, status, publish date and episode/season number. Use get_episode for show notes and transcripts.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of episodes to return | |
| search | No | Case-insensitive filter on the episode title | |
| show_id | Yes | Captivate show ID (from list_shows) | |
| scheduled_only | No | Only return scheduled (not yet published) episodes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as a read-only operation, and the description adds useful behavioral context: results are newest-first and include a defined field set. It does not discuss pagination, default limit behavior, or whether scheduled_only changes ordering, which keeps it from a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences, both front-loaded with purpose and then the alternative routing. There is no filler, and the most important distinction is stated immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description usefully names the returned fields and ordering. Annotations cover the safety profile. Gaps remain around pagination and default limits, but an agent has enough to select and call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so each parameter is already documented in the schema. The description mentions the returned fields but does not add syntax, defaults, or interaction details for show_id, limit, search, or scheduled_only beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (list episodes of a show), adds ordering (newest first), and enumerates the fields returned. It also explicitly distinguishes itself from get_episode, which handles notes and transcripts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Names the alternative get_episode and the condition for using it (show notes and transcripts). It does not explain when not to use this list tool or how it relates to filtering options like scheduled_only, but the core routing guidance is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_showsList showsARead-only
List all podcasts (shows) the authenticated Captivate user has access to.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
readOnlyHint=true already declares this is a safe read operation, so the description's main added value is the access-scope constraint (only shows the authenticated user can see). It says nothing about ordering, pagination, or result size, which for a list-all tool is a real gap even under a lower annotation-adjusted bar.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that identifies the resource, the scope, and the auth boundary with no filler. Nothing could be removed without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter read-only list tool with an annotation covering the safety profile, the description gives enough to call it correctly. The only thing an agent might still want is result shape or pagination behavior, and there is no output schema to cover that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is no param semantics for the description to compensate for; the empty schema is self-explanatory. Baseline 4 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('List') and resource ('all podcasts (shows)'), scoped to what the authenticated Captivate user can access. It is distinguishable from get_show by the plural/all framing, but the description never names or contrasts any sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'the authenticated Captivate user has access to' implies the context of use (discovering available shows before fetching a single one), but no when-not-to-use or explicit alternative such as get_show is stated. Guidance is inferable rather than given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
11 tool updates
v0.1.0- First observed
compare_episodes - First observed
get_average_downloads - First observed
get_episode - First observed
get_monthly_downloads - First observed
get_overview_analytics - First observed
get_range_analytics - First observed
get_show - First observed
get_total_downloads - First observed
get_web_player_analytics - First observed
list_episodes - First observed
list_shows
TDQS
Scored across 11 tools
Core show and episode tools are clearly distinct, and most analytics tools are separated by metric or granularity. However, get_overview_analytics and get_range_analytics both return date-range download data and could still be confused for general download queries.
All tool names use snake_case with predictable prefixes: list_, get_, and compare_. Resource names are clear and the pattern is applied consistently across the entire set.
Eleven tools is a reasonable size for a read/analytics-focused podcast server. The set is slightly analytics-heavy with six analytics-related tools, but each maps to a distinct metric or reporting mode.
The surface covers show and episode retrieval plus a broad analytics range including totals, monthly trends, averages, detailed ranges, web-player behaviour, and episode comparisons. Gaps are minor if this is intended as a read-only server: there are no write or lifecycle management operations, and web-player analytics is only exposed at episode level.
Maintenance
Related MCP Connectors
Your podcast's search rankings, keywords, charts, reviews and connected analytics, read-only
Read podcasts, episodes, seasons and download and listener analytics in Simplecast.
Read-only MCP access to sessions, funnels, campaigns, errors, live visitors, and anomalies.
Read-only access to InfluSense influencer discovery, ratings, watchlists, and reports via MCP.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceRead-only access to Google Analytics 4 reporting data, including traffic overview, top pages, traffic sources, and conversion events, supporting custom report queries via MCP.MIT
- AlicenseAqualityBmaintenanceEnables read-only access to Klaviyo marketing data, including campaigns, flows, segments, metrics, reports, and customer profiles, across multiple Klaviyo accounts.2420 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables read-only access to cookieless web analytics aggregates such as sites, visitors, pages, sources, live activity, funnels, and uptime monitoring through OAuth 2.1-secured Streamable HTTP tools.MIT
- AlicenseBqualityCmaintenanceEnables read-only access to HackerOne Hacker API data including program policies, structured scopes, scope exclusions, hacktivity/prior art, and your own reports through MCP clients.8MIT