Podcast intelligence for agents: transcripts, clips, speaker diarization, mention tracking.
Maintain this server? Claim it
Call this server's tools from your browser. Nothing to install.
Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.
Tool list from our last check. Connect live to refresh it.
Create an alert that watches a single entity and sets up recurring email delivery to external recipients whenever it is mentioned on a podcast episode (kind=ENTITY_MENTION) or appears as a speaker (kind=PODCAST_SPEAKER). Pass the entity slug from a resolve tool — resolve a name with particle_entity_resolve, then create the alert with the slug it returns. An alert watches exactly one entity; to cover several entities, call this tool once per entity. An active alert emails future matches to its configured recipients at the selected delivery cadence until paused or deleted. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. When a name has no entity slug, or its entity has no podcast coverage (a startup known by a brand that differs from its legal name, a product, a drug, a code word), create a kind=KEYWORD_MENTION alert with `keyword` instead of `entities`. It fires whenever the phrase is spoken — the match particle_podcast_search_transcripts makes for a double-quoted keyword_search phrase (words adjacent and in order), not the looser unquoted match — so also set `description` to say what the phrase means; that is how same-name mentions of something else are filtered out. Use the optional `filters` object to narrow what gets surfaced on every channel (matches list, realtime email, daily/weekly digest). Four independent axes: `languages` (BCP-47-like tags like ['en','pt-BR'] — empty means all languages), `relevance` (EVERYTHING returns on-target + incidental matches, RELEVANT narrows to on-target only — dropping passing mentions), `source_popularity` (ANY keeps every source, POPULAR keeps only matches from podcasts in the top 5% by chart popularity), and `speaker_roles` (PODCAST_SPEAKER alerts only — REPLACES the default appearance set GUEST/PANELIST/CORRESPONDENT/AUDIENCE/SOUNDBITE_SPEAKER; sending it on an ENTITY_MENTION alert errors with unprocessable_entity). Billing: creating an active alert can move an eligible organization's subscription from its credit/trial phase to paid fixed-fee billing. Explain this possible billing change and obtain the user's explicit confirmation before creating an active alert. Creating a paused alert (is_active=false) does not trigger this billing transition. After creation the alert immediately backfills matches from the past week (visible via particle_alert_list_matches) without sending emails for them. To see what an alert would catch BEFORE committing, use particle_alert_preview first. The created alert's id feeds particle_alert_get, particle_alert_update, particle_alert_delete, and particle_alert_list_matches. Alerts are not covered by zero data retention: the alert's definition and its matched results are stored as part of the alerts feature.
Human-readable title for the alert (e.g. 'OpenAI mentions').
What signal to watch for. ENTITY_MENTION (default) fires whenever a watched entity is mentioned on a podcast episode. PODCAST_SPEAKER fires only when a watched person is themself an identified speaker: by default as guest/panelist/correspondent/audience or in an excerpted soundbite (SOUNDBITE_SPEAKER), never as host; speaker_roles replaces that set. KEYWORD_MENTION fires whenever keyword is spoken — use it when the name has no entity slug (a resolve tool finds nothing, or the right entity has no episodes). Kind is fixed at creation.
Persistent narrowing applied to every surface the alert produces (matches list, realtime email, daily/weekly digest). Omit for no filters — every detected match is surfaced. See AlertFiltersInput for the four axes (languages, relevance, source_popularity, speaker_roles).
KEYWORD_MENTION alerts only (and required for them): the phrase to watch, e.g. Lightfield. Matches like a double-quoted keyword_search phrase — the words adjacent and in order, ignoring case and punctuation, on whole words — in topic-discussion and interview segments, never ad reads, intros, or outros. Also set description to say what the phrase means (e.g. 'Lightfield, the AI-native CRM'); it is how same-name mentions of something else get filtered out. A phrase that matched more than 700 podcast episodes in the past week is rejected as too broad.
The entity to watch, as a single slug from the resolve tools (particle_entity_resolve, particle_person_resolve, particle_company_resolve). Person, company, and place/other (knowledge-graph) slugs are all accepted; the resolved type is echoed back in the response. Exactly one for ENTITY_MENTION and PODCAST_SPEAKER — an alert watches a single entity, so create one alert per entity. Omit for KEYWORD_MENTION.
Whether the alert produces matches. Defaults to true. Set false to create it paused.
Optional longer description of what the alert is for.
Email addresses for recurring alert notifications. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. At least one recipient must be deliverable. When omitted, defaults to your account email if available; otherwise pass at least one.
Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read.
How often matches are emailed: REALTIME (default, one email per match), DAILY (one bundled email each morning), or WEEKLY (one bundled email Monday).
The server marks this tool as destructive. Running it may delete or overwrite data on the server or in any account you connected with your headers.
Create an alert that watches a single entity and sets up recurring email delivery to external recipients whenever it is mentioned on a podcast episode (kind=ENTITY_MENTION) or appears as a speaker (kind=PODCAST_SPEAKER). Pass the entity slug from a resolve tool — resolve a name with particle_entity_resolve, then create the alert with the slug it returns. An alert watches exactly one entity; to cover several entities, call this tool once per entity. An active alert emails future matches to its configured recipients at the selected delivery cadence until paused or deleted. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. When a name has no entity slug, or its entity has no podcast coverage (a startup known by a brand that differs from its legal name, a product, a drug, a code word), create a kind=KEYWORD_MENTION alert with `keyword` instead of `entities`. It fires whenever the phrase is spoken — the match particle_podcast_search_transcripts makes for a double-quoted keyword_search phrase (words adjacent and in order), not the looser unquoted match — so also set `description` to say what the phrase means; that is how same-name mentions of something else are filtered out. Use the optional `filters` object to narrow what gets surfaced on every channel (matches list, realtime email, daily/weekly digest). Four independent axes: `languages` (BCP-47-like tags like ['en','pt-BR'] — empty means all languages), `relevance` (EVERYTHING returns on-target + incidental matches, RELEVANT narrows to on-target only — dropping passing mentions), `source_popularity` (ANY keeps every source, POPULAR keeps only matches from podcasts in the top 5% by chart popularity), and `speaker_roles` (PODCAST_SPEAKER alerts only — REPLACES the default appearance set GUEST/PANELIST/CORRESPONDENT/AUDIENCE/SOUNDBITE_SPEAKER; sending it on an ENTITY_MENTION alert errors with unprocessable_entity). Billing: creating an active alert can move an eligible organization's subscription from its credit/trial phase to paid fixed-fee billing. Explain this possible billing change and obtain the user's explicit confirmation before creating an active alert. Creating a paused alert (is_active=false) does not trigger this billing transition. After creation the alert immediately backfills matches from the past week (visible via particle_alert_list_matches) without sending emails for them. To see what an alert would catch BEFORE committing, use particle_alert_preview first. The created alert's id feeds particle_alert_get, particle_alert_update, particle_alert_delete, and particle_alert_list_matches. Alerts are not covered by zero data retention: the alert's definition and its matched results are stored as part of the alerts feature.
| Argument | Type | Description |
|---|---|---|
| kind | string | What signal to watch for. ENTITY_MENTION (default) fires whenever a watched entity is mentioned on a podcast episode. PODCAST_SPEAKER fires only when a watched person is themself an identified speaker: by default as guest/panelist/correspondent/audience or in an excerpted soundbite (SOUNDBITE_SPEAKER), never as host; speaker_roles replaces that set. KEYWORD_MENTION fires whenever keyword is spoken — use it when the name has no entity slug (a resolve tool finds nothing, or the right entity has no episodes). Kind is fixed at creation. |
| title* | string | Human-readable title for the alert (e.g. 'OpenAI mentions'). |
| filters | object | Persistent narrowing applied to every surface the alert produces (matches list, realtime email, daily/weekly digest). Omit for no filters — every detected match is surfaced. See AlertFiltersInput for the four axes (languages, relevance, source_popularity, speaker_roles). |
| keyword | string | KEYWORD_MENTION alerts only (and required for them): the phrase to watch, e.g. Lightfield. Matches like a double-quoted keyword_search phrase — the words adjacent and in order, ignoring case and punctuation, on whole words — in topic-discussion and interview segments, never ad reads, intros, or outros. Also set description to say what the phrase means (e.g. 'Lightfield, the AI-native CRM'); it is how same-name mentions of something else get filtered out. A phrase that matched more than 700 podcast episodes in the past week is rejected as too broad. |
| entities | array | The entity to watch, as a single slug from the resolve tools (particle_entity_resolve, particle_person_resolve, particle_company_resolve). Person, company, and place/other (knowledge-graph) slugs are all accepted; the resolved type is echoed back in the response. Exactly one for ENTITY_MENTION and PODCAST_SPEAKER — an alert watches a single entity, so create one alert per entity. Omit for KEYWORD_MENTION. |
Delete an alert. This is a soft delete: the alert stops producing matches and disappears from particle_alert_list, but its past matches and deliveries are retained for audit. To pause an alert instead of removing it, use particle_alert_update with is_active=false. Only the alert's creator or an organization OWNER or ADMIN can delete it; an API key acts as the user who created the key. Other callers get a 403.
| Argument | Type | Description |
|---|---|---|
| alert_id* | string | Alert id to delete. |
{
"type": "object",
"required": [
"alert_id"
],
"properties": {
"alert_id": {
"type": "string",
"description": "Alert id to delete."
}
}
}Fetch a single alert's full configuration — title, kind, cadence, watched entities (with names), notification emails, and any active filters (languages, relevance, source_popularity, speaker_roles). The `filters` section is omitted when the alert carries none. By default the response is just the configuration; request include=['matches'] to embed the most recent matches it has caught and include=['deliveries'] for the email audit log. For the full, paginated match history with transcript excerpts, use particle_alert_list_matches.
| Argument | Type | Description |
|---|---|---|
| include | array | Optional sections to embed: 'matches' for the most recent matches the alert has caught, 'deliveries' for the email delivery audit log. |
| alert_id* | string | Alert id from particle_alert_list or particle_alert_create. |
| match_limit | integer | How many recent matches to embed when include=matches (1-25, default 5). Use particle_alert_list_matches for full pagination and transcript windows. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"required": [
"alert_id"
],
"properties": {
"include": {
"type": "array",
"items": {
"enum": [
"matches",
"deliveries"
],
"type": "string"
},
"description": "Optional sections to embed: 'matches' for the most recent matches the alert has caught, 'deliveries' for the email delivery audit log."
},
"alert_id": {
"type": "string",
"description": "Alert id from particle_alert_list or particle_alert_create."
},
"match_limit": {
"type": "integer",
"maximum": 25,
"minimum": 1,
"description": "How many recent matches to embed when include=matches (1-25, default 5). Use particle_alert_list_matches for full pagination and transcript windows."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}List the alerts in your project, newest first. Each entry carries the alert `id` — feed it into particle_alert_get for full configuration, particle_alert_list_matches for what it has caught, or particle_alert_update / particle_alert_delete to manage it.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Alerts per page (1-100, default 25). |
| cursor | string | Opaque pagination cursor from a previous response's cursor field. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"limit": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Alerts per page (1-100, default 25)."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response's cursor field."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}List the matches an alert has caught, newest first — the payoff of an alert. Each match names the watched entity and the podcast episode it was detected on (with episode and podcast slugs that feed particle_podcast_get_episode and particle_podcast_resolve). Use view=detailed to include the transcript excerpts around each mention, and after/before to scope to a date range. Backfilled matches (from the past-week sweep at creation) are flagged and never triggered an email.
| Argument | Type | Description |
|---|---|---|
| view | string | Detail level. 'summary' (default) returns each match's entity, episode, and counts. 'detailed' also includes the transcript excerpt windows around each mention. |
| after | string | Only matches detected on or after this ISO date (e.g. 2026-05-01). |
| limit | integer | Matches per page (1-100, default 25). |
| before | string | Only matches detected on or before this ISO date. |
| cursor | string | Opaque pagination cursor from a previous response's cursor field. |
| alert_id* | string | Alert id whose matches to list. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
Preview how often an alert would fire BEFORE creating it. Sweeps the past N days (default 7, max 30) for the given entity (or keyword, for kind=KEYWORD_MENTION) and returns the total match count, a per-day breakdown, and a small sample of the most recent matches with episode context. Use this to size an alert (REALTIME vs DAILY vs WEEKLY cadence) or to confirm the entity slug watches the right thing, then call particle_alert_create with the same entity slug (for KEYWORD_MENTION, the same keyword instead). Pass the same `filters` you plan to save so the estimate matches what the alert would surface — the languages and speaker_roles axes narrow the sweep; relevance and source_popularity are read-time projections that don't, so the count is an upper bound when relevance=RELEVANT. Starts a background sweep and caches its progress and results; it does not create an alert or send notifications.
| Argument | Type | Description |
|---|---|---|
| kind | string | Signal to preview. Defaults to ENTITY_MENTION. |
| filters | object | Same as particle_alert_create.filters. Pass the filters you intend to save so the estimate reflects what the alert would actually surface. Only languages and speaker_roles narrow the historical sweep; relevance and source_popularity are read-time projections that don't run on historical episodes, so setting them leaves the count unchanged (the estimate is an upper bound when relevance=RELEVANT). |
| keyword | string | Same as particle_alert_create.keyword — required for KEYWORD_MENTION. A phrase that matched more than 700 podcast episodes in the past week is rejected as too broad, as on create. |
| entities | array | The entity to preview, as a single slug (from the resolve tools), same as particle_alert_create.entities — exactly one for entity kinds, omitted for KEYWORD_MENTION. |
Update an existing alert. Only the fields you pass change; the entities and notifications lists, when provided, replace the whole set (pass a single entity slug from the resolve tools, same as particle_alert_create — an alert watches exactly one entity). A KEYWORD_MENTION alert takes a new `keyword` instead of `entities`. Use is_active to pause or resume an alert without deleting it. An alert's kind is fixed at creation — to change it, create a new alert. Notification changes affect future recurring email delivery to external recipients; resuming an alert restarts delivery to its configured destinations. Alert emails follow delivery_cadence until paused or deleted. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. The optional `filters` object replaces the alert's filter set wholesale — omit to leave the existing filters unchanged, send {} to clear all filters. Same four axes as particle_alert_create.filters: `languages`, `relevance` (EVERYTHING/RELEVANT), `source_popularity` (ANY/POPULAR), and `speaker_roles` (PODCAST_SPEAKER alerts only — sending it on an ENTITY_MENTION alert returns unprocessable_entity). Alerts are not covered by zero data retention: the alert's definition and its matched results are stored as part of the alerts feature.
| Argument | Type | Description |
|---|---|---|
| title | string | New title. |
| filters | object | Replace the alert's filter set wholesale. Omit to leave the existing filters unchanged; send an empty object {} to clear all filters. Same four axes as particle_alert_create.filters (languages, relevance, source_popularity, speaker_roles). |
| keyword | string | Replacement phrase for a KEYWORD_MENTION alert; omit to leave it unchanged. Not accepted on other kinds. Matches already recorded keep the phrase they fired on. |
Dispatch any public Particle tool by name. Compatibility fallback for harnesses that block calling tools that weren't advertised on tools/list — every public Particle tool is executable by name, so prefer calling discovered tools directly when your harness allows it. Identical metering and plan gating apply either way. Use particle_catalog to discover tool names and input schemas. A tool particle_catalog lists but your tools/list lacks (client lists go stale after a deploy) is callable here: never report it unavailable.
| Argument | Type | Description |
|---|---|---|
| tool* | string | Flat name of any public Particle tool (e.g. 'particle_podcast_get_episode'). Discover names and schemas with particle_catalog. |
| arguments | object | Arguments object for the target tool, matching its input schema. |
{
"type": "object",
"required": [
"tool"
],
"properties": {
"tool": {
"type": "string",
"description": "Flat name of any public Particle tool (e.g. 'particle_podcast_get_episode'). Discover names and schemas with particle_catalog."
},
"arguments": {
"type": "object",
"description": "Arguments object for the target tool, matching its input schema."
}
}
}Browse the full Particle tool catalog. Your tools/list shows only the default categories, but EVERY public Particle tool is callable by name regardless of what was advertised — call this tool to discover the rest. Without arguments: the categorical menu (every category with tool names, one-line summaries, and an `↳` line listing each tool's expand options). With `category`: the full input schema for each of that category's tools, ready to call. Two conventions the one-line summaries don't convey, so read tools through this lens: - Tools are lean by default and EXPAND. Most return a minimal payload and opt into richer sections via an `include` array (e.g. a company's people, products, and competitors; a person's roles and podcast appearances) or change behavior via a `mode`/`format` switch. The `↳` line names these — a tool does far more than its summary alone implies. - Responses are a graph; slugs are edges. A slug a tool returns (person, company, podcast, episode, publisher, guest) is a valid input to the other tools, so you resolve once and then traverse: company → its people → a person's podcast appearances → that episode's transcript and every entity in it. Categories on offer: - `system` (always-on): Discovery meta-tools: browse the full tool catalog and call any tool by name. - `podcasts` (default): Resolve podcasts, list and fetch episodes, search transcripts, and find entity mentions. - `people` (default): Resolve people and entities to canonical handles and fetch person profiles. - `companies` (default): Resolve companies and fetch company profiles with people, products, and competitors. - `topics` (default): Browse the hierarchical topic taxonomy used to classify podcast episodes. - `podcast_rankings` (default): Podcast chart rankings: current charts, movers, and ranking history. - `podcast_guests` (default): Podcast guest directory, trending guests, and per-guest appearance profiles. - `podcast_advertising` (opt-in): Podcast advertising intelligence: sponsor rosters, ad presence, and sponsor leaderboards. - `podcast_publishers` (opt-in): Podcast publisher profiles with their shows, bias profile, and suitability profile. - `podcast_ratings` (opt-in): Listener review ratings for podcasts: summaries and recent rating lists. - `podcast_bias` (opt-in): Corpus-wide political-bias views: publisher leaderboards and publishers by bias result. - `podcast_suitability` (opt-in): Corpus-wide GARM brand-suitability views: publisher leaderboards and category exposure. - `alerts` (default): Create and manage alerts that watch entities for podcast mentions or speaker appearances, preview match frequency, and review the matches an alert has caught. - `radar` (opt-in): Display selected research results as embedded Radar cards, with a Markdown fallback. Rendering is free and does not fetch data. Opt-in categories can also be advertised on tools/list by adding `?include=<category>` (comma-separated, or `all`) to the connection URL, or the X-Particle-Include header. `?exclude=` hides default categories; `?tools=<name,...>` pins the advertised list to exact tools instead. Discovery is free; tool execution is metered and plan-gated as usual.
Return a bundled profile for one company: identifiers (slug, ticker, domain, CIK, QID, linked entity), name, and description. Request optional sections via `include`: 'people' for current leadership and notable people (person slugs feed `particle_person_get`), 'products' for the three-level product hierarchy, 'competitors' for the competitor list, 'external_links' for the company's LinkedIn, social profiles, domain, Wikidata QID, SEC CIK and tickers. The default response is lean — include only what you need. For sponsor/advertising analytics on this company, use `particle_company_get_podcast_ad_presence` instead.
| Argument | Type | Description |
|---|---|---|
| include | array | Optional response sections: 'people' (current leadership and notable people), 'products' (three-level product hierarchy), 'competitors' (competitor list), 'podcast_recommendations' (the ten podcasts the company could advertise on next, with the shows it already buys that led there; premium), 'external_links' (LinkedIn, social profiles, domain, Wikidata QID, SEC CIK and tickers). Default response is lean — request only what you need. |
| company_slug* | string | Company identifier — accepts slug (e.g. 'nvidia'), domain (e.g. 'nvidia.com'), or canonical ID. If you already know the domain you can call this tool directly without first running particle_company_resolve. |
| product_status | string | Comma-separated lifecycle filter for include=products (e.g. 'active' or 'active,announced'). Allowed values: active, announced, discontinued, rumored. Defaults to 'active'. |
Resolve a company by free-text name, ticker, SEC CIK, Wikidata QID, or domain. Returns candidates with the agent-facing identifier (`slug`, falling back to `domain` or `id`) you should pass to `particle_company_get`, `particle_company_get_podcast_ad_presence`, `particle_podcast_find_mentions` (as `company_slug`), or `particle_podcast_list_episodes`. At least one identifier is required. Multiple are ANDed together — useful for disambiguating (e.g. ticker plus a name hint). For people or other knowledge-graph entities (not companies) use `particle_entity_resolve` instead.
| Argument | Type | Description |
|---|---|---|
| cik | string | SEC Central Index Key (e.g. '0000320193'). Comma-separated for bulk. |
| qid | string | Wikidata QID (e.g. 'Q312'). Comma-separated for bulk. |
| limit | integer | Maximum candidates to return (1-25, default 5). |
| query | string | Free-text company name (case-insensitive). Use for human-typed names. |
| domain | string | Company website domain (e.g. 'apple.com'). Comma-separated for bulk. |
| ticker | string | Stock ticker symbol (e.g. 'NVDA', 'AAPL'). Comma-separated for multi-ticker lookup. |
One knowledge-graph entity's profile: name, kind, description, and Wikipedia link. Use it to confirm what a slug from `particle_entity_resolve` actually refers to — especially for the long tail that isn't a person or company (places, organizations, events, products, concepts). When the entity is a linked person or company the response carries the person_slug / company_slug — prefer `particle_person_get` / `particle_company_get` for those, which return the full profiles. Entity slugs feed `particle_podcast_find_mentions`, `particle_podcast_get_episode_timeseries`, and the alert tools.
| Argument | Type | Description |
|---|---|---|
| entity_slug* | string | Knowledge-graph entity slug or encoded ID from particle_entity_resolve, episode entity listings, or mention payloads (e.g. 'germany', 'bitcoin'). |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"required": [
"entity_slug"
],
"properties": {
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug or encoded ID from particle_entity_resolve, episode entity listings, or mention payloads (e.g. 'germany', 'bitcoin')."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}Resolve any named thing — person, company, place, or other entity — by free-text name in one union search. Each candidate carries a `type` and the canonical `slug` for that type: - `person`: the canonical person slug. Feed it into `particle_person_get`, every `person_slug` parameter (`particle_podcast_find_mentions`, `particle_podcast_search_transcripts`, `particle_podcast_list_episodes`), or `particle_podcast_get_guest`'s `guest_slug`. - `company`: the canonical company slug. Feed it into `particle_company_get` and every `company_slug` parameter. - `place`/`other`: a bare entity slug. Feed it into the `entity_slug` parameter on `particle_podcast_find_mentions`, `particle_podcast_search_transcripts`, and `particle_podcast_list_episodes` to filter by that entity. Use this first whenever you only have a name and don't know what kind of thing it names. If you already know it's a person, `particle_person_resolve` ranks people only; for companies with a known ticker, domain, CIK, or QID, `particle_company_resolve` has more identifier surface. For bulk resolution, pass a comma-separated `query` (e.g. "sam altman, nvidia, davos") — each name is resolved independently in a single call and `limit` applies per query.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Maximum candidates per query (1-10, default 5). |
| query* | string | Free-text name(s) of a person, organization, place, or company to resolve (e.g. 'sam altman', 'nvidia'). Case-insensitive. Comma-separated for bulk lookup (e.g. 'sam altman, kara swisher, marc andreessen') — each query is resolved independently and grouped in the response. |
{
"type": "object",
"required": [
"query"
],
"properties": {
"limit": {
"type": "integer",
"maximum": 10,
"minimum": 1,
"description": "Maximum candidates per query (1-10, default 5)."
},
"query": {
"type": "string",
"description": "Free-text name(s) of a person, organization, place, or company to resolve (e.g. 'sam altman', 'nvidia'). Case-insensitive. Comma-separated for bulk lookup (e.g. 'sam altman, kara swisher, marc andreessen') — each query is resolved independently and grouped in the response."
}
}
}Describe one occupation or field of research and, on request, who is booked under it: its parent, children and crosswalk by default; `include: ["top_guests"]` ranks the guests listed under it by podcast appearances in a window (default the last 30 days, at most 90), and `include: ["top_podcasts"]` ranks the shows that booked them. `standing="established"` ranks only credentialed or recognized experts — "the shows that book established finance experts" is `field` plus top_podcasts plus standing. A broad code covers everything below it. Take codes from `particle_expertise_resolve`, which turns free text ("doctors", "finance") into them; on `unresolved_reference` or `not_found`, resolve and retry. Guest slugs work with `particle_person_get` (`include: ["expertise"]`) and `particle_podcast_get_guest`; podcast slugs with every podcast tool. For a multi-criteria guest search (practicing, seniority, capacity, employer, all-time) use `particle_podcast_list_guests`; for one show's guest mix use `particle_podcast_resolve` with `include: ["guest_expertise"]`.
| Argument | Type | Description |
|---|---|---|
| field | string | A field of research's ANZSRC 2020 code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). Pass exactly one of occupation or field. |
| limit | integer | Rows per top_ section (1-25, default 10). |
| since | string | Window start for the top_ sections (YYYY-MM-DD). Defaults to 30 days before until; the window may span at most 90 days. |
| until | string | Window end for the top_ sections (YYYY-MM-DD, inclusive). Defaults to now. |
Turn free text into the occupation and field-of-research codes the speaker-expertise filters take. When a question restricts who is speaking by occupation, profession, credentials or industry ("doctors", "medical professionals", "economists", "people in finance", "lawyers"), the filters, not search wording, decide who speaks. `guest_occupation` takes the everyday word itself, so the first search can carry it without waiting for this tool: call it to see or choose among the codes, and when a filter returns `unresolved_reference`, then retry with the code. Codes are SOC 2018 occupations (with their ISCO-08 equivalents) and ANZSRC 2020 fields of research. 'cardiologist' finds SOC 29-1212 Cardiologists; 'finance' finds the finance fields. Each code comes back with its slug, level, parent and the parameters that accept it: `occupation`/`field` on `particle_podcast_list_guests` and `particle_expertise_get`, and `guest_occupation`/`guest_field` on `particle_podcast_find_mentions`, `particle_podcast_list_episodes`, `particle_podcast_search_transcripts`, `particle_podcast_get_episode_timeseries` and `particle_podcast_resolve`. Pass `parent` to walk the hierarchy one level down (a SOC major group's minor groups, then broad groups, then occupations; a division's groups); a group such as `physicians` or an everyday name such as `doctors` filters everything below it. A word no occupation names may name a field (`oncologists` finds field 3211 Oncology) or a capacity: `founders` comes back as the capacity `executive_founder`, which `capacity` on `particle_podcast_list_guests` and `guest_capacity` on the episode and mention tools take. Not for people or companies — use `particle_person_resolve`, `particle_company_resolve` or `particle_entity_resolve`. Not the topic taxonomy either: `particle_topic_browse` classifies what episodes are about, these codes classify what speakers know.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Maximum codes to return (1-25, default 5). |
| query |
Return a person's profile: name, current role, and bio, keyed by the canonical person slug from `particle_person_resolve`. Request optional sections via `include`: 'external_links' for LinkedIn/Wikipedia/social profiles, 'podcast_appearances' for their most recent podcast appearances (episode and podcast slugs included for follow-up calls), 'companies' for the full role history, 'sports' for an athlete's or coach's current team (NFL, MLB and NHL rosters), sports, teams (with years and leagues) and leagues, with entity slugs for `particle_entity_get` (only the current team says where a player is today: a team with no end year may be one they left), 'expertise' for what they know and how established they are (standing, seniority, the occupations and fields they are listed under — codes that `guest_occupation`/`guest_field` and `particle_expertise_get` accept). The default response is lean. For podcast-guest analytics (appearance stats, suitability exposure, co-appearance graph) use `particle_podcast_get_guest` with the same slug.
| Argument | Type | Description |
|---|---|---|
| include | array | Optional response sections: 'external_links' (LinkedIn, Wikipedia, social profiles), 'podcast_appearances' (recent podcast appearances with episode and podcast slugs), 'companies' (the full role history, current role included and marked), 'sports' (the current team of an NFL, MLB or NHL player, sports played, and teams played for or coached with years and leagues), 'expertise' (what they know and how established they are: standing, seniority, experience, the occupations and fields they are listed under with codes the guest_ filters accept, organization, credential). Default response is lean — request only what you need. |
| person_slug* | string | Canonical person slug from particle_person_resolve (e.g. 'sam-altman'), or the encoded person ID. |
Resolve a person by free-text name. Returns ranked candidates with the canonical person `slug` — the stable handle accepted by `particle_person_get`, by every `person_slug` parameter (`particle_podcast_find_mentions`, `particle_podcast_search_transcripts`, `particle_podcast_list_episodes`), and by `particle_podcast_get_guest`'s `guest_slug`. For bulk resolution, pass a comma-separated `query` — each name resolves independently in one call. For organizations, places, or mixed/unknown entity kinds use `particle_entity_resolve`; for companies with a known ticker or domain use `particle_company_resolve`.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Maximum candidates per query (1-10, default 5). |
| query* | string | Free-text person name (e.g. 'sam altman'). Case-insensitive. Comma-separated for bulk lookup — each name is resolved independently and grouped in the response. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"required": [
"query"
],
"properties": {
"limit": {
"type": "integer",
"maximum": 10,
"minimum": 1,
"description": "Maximum candidates per query (1-10, default 5)."
},
"query": {
"type": "string",
"description": "Free-text person name (e.g. 'sam altman'). Case-insensitive. Comma-separated for bulk lookup — each name is resolved independently and grouped in the response."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}Find dialogue lines where a specific person or company is named in podcast transcripts. ## Three response modes **`format="summary"` (default, wide scan).** Returns up to `limit` episodes (reverse-chronological), each with metadata + the first 10 mention-only lines (just the lines naming the entity, no surrounding dialogue). Use this to see *what's been said across episodes* and decide which episodes are worth reading in full. Paginate older episodes with `cursor`. **`format="detail"` (narrow drill-in).** Requires `episode_slug`. Returns the full mention windows with `context_lines` of surrounding dialogue around each mention. Pass one slug for a single episode, or up to 10 comma-separated slugs (e.g. `episode_slug="all-in-200,all-in-201,all-in-202"`) to multi-get several episodes in one call. `limit`/`cursor` don't apply. **`format="compact"` (screening).** The same episodes as summary, each with its mention count, the strings it was mentioned as, and the segments carrying the mentions (id, title, type, first mention time) — no dialogue lines at all, the smallest shape. `limit` and `cursor` page it exactly as summary. Use it to fan out over many entities or a long date range and decide where to read; the segment ids are citations, and `format="detail"` with the episode slug reads the lines. ## Workflow Two patterns, depending on what you already know: - **No specific episode in mind:** call `format="summary"` first to scan, then call `format="detail"` with the slug(s) of the episodes worth reading in full. For most questions (sentiment, recurring themes, who said what when), summary alone has enough signal and the second call isn't needed. - **Already have the episode slug** (e.g. user mentioned the episode by name, or you have it from another tool like `particle_podcast_get_episode` or `particle_podcast_search_transcripts`): skip summary entirely and call `format="detail"` with `episode_slug` directly. ## Examples *Wide scan, then drill in:* User asks "what has All-In said about OpenAI recently?". Call `format="summary"`, `company_slug="openai"`, `podcast_slug="all-in"`, `since="2025-11-01"`, `limit=20`. Read the mention lines per episode; if 2-3 episodes have substantive discussion, call `format="detail"`, `episode_slug="slug1,slug2,slug3"` for full context in one round-trip. *Direct drill-in:* User says "In All-In #200 they discuss OpenAI's strategy — pull the full quotes". Call `format="detail"`, `episode_slug="all-in-200"`, `company_slug="openai"` directly — no summary needed. ## Who said it The `guest_` filters keep only the mentions a matching guest spoke: `guest_field="banking-finance-and-investment"` with `guest_standing="established"` reads what established finance experts said about a company. When the question names who speaks ("doctors", "economists", "people in finance"), resolve the words with `particle_expertise_resolve` first and filter by the code; on `unresolved_reference`, resolve and retry rather than dropping the filter. A word no occupation names may name a capacity instead ("founders", "politicians"): pass it as `guest_capacity`. Each episode lists its identified speakers with their occupation codes, standing and seniority. For the split of all mentions across occupations or fields use `particle_podcast_get_share_of_voice`. ## When NOT to use this tool For dialogue that *discusses* a topic without naming a specific person or company (paraphrase-tolerant search), use `particle_podcast_search_transcripts` instead — that one ranks segments by relevance to a free-text query. For how often the subject comes up, or which shows mentioned it this week versus last, use `particle_podcast_get_mention_trends` instead of paging this tool once per period; its podcast slugs come back here as `podcast_slug` to read what a show said. ## Required inputs One of `person_slug`, `company_slug`, or `entity_slug` is required: `person_slug` for a person, `company_slug` for a company, `entity_slug` for any other knowledge-graph entity (places, organizations, events, concepts). Resolve a name to a slug first with `particle_person_resolve`, `particle_company_resolve`, or `particle_entity_resolve`. Slugs are case-insensitive on input.
Return a bundled overview of one podcast episode: title, podcast, speakers (with entity slugs), top mentioned entities, and segment/clip counts. By default the response is lean — counts plus the top mentioned entities. Request optional sections via `include`: 'segments' for the structural outline with timestamps, 'entities' for the complete entity list, 'clips' for engagement-ranked highlight clips, 'topics' for topic classifications with slugs, 'guest_expertise' for each guest's expertise and whether they spoke within their field, or 'transcript' for the dialogue transcript (narrow it by speaker or time range via `transcript_speaker` / `transcript_start` / `transcript_end` — full transcripts are large). For "every line about X in this episode" use `particle_podcast_find_mentions` with `episode_slug` instead — that returns the dialogue around each mention with `is_mention` flags. For the ad reads inside the episode use `particle_podcast_get_episode_ads` (premium).
| Argument | Type | Description |
|---|---|---|
| include | array | Optional response sections: 'transcript' (bounded dialogue transcript — large for long episodes; narrow it with the transcript_* sub-params), 'segments' (structural outline with timestamps), 'entities' (complete mentioned-entity list instead of the top 20), 'clips' (engagement-ranked highlight clips), 'topics' (topic classifications with slugs), 'related' (the five episodes from OTHER shows most related to this one — slug, show, score, band; for the full ranked list with the basis behind each match call particle_podcast_list_related_episodes), 'guest_expertise' (each guest's expertise read and how the episode used it: whether they spoke within their field, whether the appearance was promotional, how they were introduced). Default response is lean — request only what you need. |
| episode_slug* | string | Episode slug or canonical ID. A particle.pro or Radar episode link also works. |
Time-bucketed episode counts — the purpose-built answer to "how often is X discussed over time". Counts episodes matching the same filters as `particle_podcast_list_episodes` (person, company, entity, podcast, keyword, language, duration, transcript availability) per day, week, or month, plus range totals. `keyword_search` additionally counts matching transcript segments per bucket (exact counts); `semantic_search` does the same by meaning, with the same similarity threshold as `particle_podcast_search_transcripts` (lower bounds for pathologically broad queries), and requires `published_after`. The two cannot be combined. Use this for appearance, publication, or topic trend lines instead of paging `particle_podcast_list_episodes`, `particle_podcast_find_mentions`, or `particle_podcast_search_transcripts` once per period. For how often a person, company or brand is mentioned, use `particle_podcast_get_mention_trends`: it leaves ad reads out, where this tool counts an episode for a company or entity named only in its ad reads, and it says which podcasts carried the mentions. Buckets are UTC-aligned, zero-filled, and Monday-aligned for weeks; ranges are capped at 1000 buckets. At least one of podcast_slug, person_slug, company_slug, entity_slug, keyword_search, semantic_search, guest_occupation, or guest_field is required. The `guest_` filters count episodes by their guests' expertise (resolve the words to codes with `particle_expertise_resolve` first; on `unresolved_reference`, resolve and retry): `guest_field` alone charts how often a field's experts are booked; with `company_slug` it charts the company's episodes featuring those experts. They are episode-level and never check who spoke: with `keyword_search`, a matching segment counts when its episode had such a guest, even if the host said the words. For who said a keyword, use `particle_podcast_get_share_of_voice` with `keyword_search`.
| Argument | Type | Description |
|---|---|---|
| role | string | Role filter when person_slug, company_slug, or entity_slug is set. |
A guest's podcast-appearance profile: lifetime stats (appearances, distinct podcasts, first/last appearance) plus their most frequent podcasts. Guests are people — the same slug works with `particle_person_get` for the biographical profile. Request optional sections via `include`: 'appearances' for the most recent episode appearances (episode and podcast slugs included for follow-up calls), 'podcasts' for the per-podcast rollup, 'suitability' for brand-suitability exposure across the podcasts they appear on, 'recommended_podcasts' for the five shows they could plausibly appear on next — shows related to the ones they have guested on, minus those, with the venues behind each pick (the pitch list; branch on each row's band), 'in_field_appearances' for the most recent appearances where they spoke within their own field of expertise (what they know is what the episode drew on; `particle_person_get` with `include: ["expertise"]` says what that field is). Returns not_found for people who exist but have never appeared on a podcast — use `particle_person_get` for those.
| Argument | Type | Description |
|---|---|---|
| include | array | Optional response sections: 'appearances' (most recent episode appearances with episode/podcast slugs), 'podcasts' (per-podcast rollup of where they appear), 'suitability' (brand-suitability exposure across the podcasts they appear on), 'recommended_podcasts' (the five shows they could plausibly appear on next — shows related to the ones they have guested on, minus those, each with the venues that led there; the pitch list), 'in_field_appearances' (most recent appearances where they spoke within their own field of expertise). Default response is the profile + lifetime stats. |
| guest_slug* | string | Person slug (e.g. 'sam-altman') from particle_podcast_list_guests, particle_person_resolve, or particle_entity_resolve. |
How a person's, company's or entity's podcast mentions are moving, for tracking it week over week. Two modes: - `compare` (default): which podcasts mentioned it in a window (default the last 7 days, at most 90) and how each compares with the equal-length window before it: episode and mention line counts in both, the delta, and whether the show is `new` to the subject, `continuing`, or `dropped` it. Totals for both windows count every podcast. Filter with `change`, order with `sort` (`rising` and `falling` for the biggest movers), and page with `cursor`. Answers "which shows talked about Nike this week versus last?" in one call. - `timeseries`: mention counts per day, week or month over a range (omit `published_after` for all time), each bucket with its episodes, mention lines and distinct podcasts. Answers "is it rising?". `podcast_slug` charts one show. Mentions inside ad reads are left out unless `include_ads`, so a brand that advertises heavily is measured by what shows say about it. The newest day fills in over about a day as episodes are processed, so a window ending now reads slightly low and the current bucket is marked partial: compare full buckets. Podcast slugs in the response work with `particle_podcast_find_mentions` (with the same dates as `since` and `until`, to read what a show said) and `particle_podcast_list_episodes`. Not for the mention lines themselves (`particle_podcast_find_mentions`), appearance or topic trends by role or keyword (`particle_podcast_get_episode_timeseries`, which counts an episode for a company named only in its ad reads), or a split by who said it (`particle_podcast_get_share_of_voice`). To be told about new mentions as they air, create an alert with `particle_alert_create`.
| Argument | Type | Description |
|---|---|---|
| mode | string | 'compare' (default): which podcasts mentioned the subject in the window and how each compares with the equal-length window before it, with both windows' totals. 'timeseries': mention counts per day, week or month over a range, with the podcasts carrying them per bucket. |
Podcast chart rankings from Apple Podcasts and Spotify, in four modes: - `chart` (default): the current chart for a source/country/category slot, or — with `podcast_slug` — every chart slot that podcast currently holds. - `movers`: the biggest rank changes over `window_days` (risers, fallers, debuts, exits). - `history`: past snapshots for a chart slot, or — with `podcast_slug` — one podcast's chart history over time. - `slots`: the valid slot values — every source, country, and category_slug with live chart data — so filter values are discovered, not guessed. `source` narrows the country/category listings; other filters are ignored. Each row carries the matched `podcast_slug` when the chart entry is in the catalog — feed it into `particle_podcast_resolve` or any podcast tool. For a single podcast's at-a-glance chart presence, `particle_podcast_resolve` with `include: ["rankings"]` is one call instead of two.
| Argument | Type | Description |
|---|---|---|
| mode | string | What to return. 'chart' (default): the current chart — or, with podcast_slug, every chart slot the podcast currently holds. 'movers': biggest rank changes over window_days (risers, fallers, debuts, exits). 'history': past chart snapshots for a slot — or, with podcast_slug, one podcast's chart history. 'slots': the valid chart-slot values — every source, country, and category_slug with live data — for discovering filter values before a chart/movers/history call. |
| limit | integer | Rows per page (1-100, default 25). |
| since | string | Mode=history only: only snapshots captured on or after this ISO 8601 timestamp. |
| until | string |
Split a person's, company's or entity's podcast mentions by who said them: the speakers' occupations (SOC 2018) or fields of research (ANZSRC 2020). Answers "who is talking about NVIDIA — investors, engineers, journalists?" in one call: each group's mention lines, share, distinct speakers and episodes over a window (default the last 30 days, at most 365), optionally bucketed by day, week or month. `speakers="guests"` leaves hosts out; `level="detailed"` splits into detailed occupations or ANZSRC groups; `podcast_slug` or `publisher_slug` narrows to one show or network. `keyword_search` splits the lines that say a word or quoted phrase instead of an entity's mentions (who talks about prior authorization?), counting a line only when its own speaker said every word in it. Its window is at most 90 days, and a word said in too many episodes is refused with a way to narrow it. This is the per-speaker answer that `particle_podcast_get_episode_timeseries` with `keyword_search` and `guest_occupation` cannot give: that counts matching segments in episodes with such a guest, whoever spoke them. Shares are of the mentions spoken by someone with an expertise read, and a person listed under several codes counts in each, so shares can sum past 100%. Each group's code is a `guest_occupation` (or `guest_field`) value: pass it to `particle_podcast_find_mentions` with the same entity to read what that group said. For a keyword, `particle_podcast_search_transcripts` with the same `keyword_search` finds candidate passages: its guest filters keep segments with such a guest, so check each matching line's speaker, and host lines are not reached that way. Not for the mention lines themselves (`particle_podcast_find_mentions`) or for a brand's mention volume over time and the shows carrying it (`particle_podcast_get_mention_trends`).
| Argument | Type | Description |
|---|---|---|
| by | string | Group the speakers by 'occupation' (SOC 2018, default) or 'field' (ANZSRC 2020 fields of research). |
Browse AI-extracted highlight clips across the catalog, ranked by engagement potential — the shareable moments. Filter by podcast, episode, clip type (FUNNY, CONTROVERSIAL, INSIGHTFUL, ...), minimum engagement score, or speaker — `speaker` takes a person slug and returns only clips of that person talking ('an insightful Sam Altman clip'). Pass `clip_id` for one clip's full detail (description, social-hook intro, speaker, audio URL), plus `include: ["transcript"]` for its dialogue. For text-based clip discovery — finding clips about a topic or entity — use `particle_podcast_search_transcripts` instead: matching clips arrive inline on each search result. Episode slugs on every row feed `particle_podcast_get_episode`.
| Argument | Type | Description |
|---|---|---|
| type | string | Clip type filter. |
| limit | integer | Clips per page (1-50, default 10). |
| cursor | string | Opaque pagination cursor from a previous response. |
| clip_id | string | Return one clip's full detail instead of a listing. Clip IDs come from this tool, particle_podcast_get_episode with include=clips, and search-result overlapping clips. |
| include | array | With clip_id only: 'transcript' attaches the clip's dialogue transcript. |
| speaker | string | Restrict the listing to clips whose primary speaker is this person — a person slug (e.g. 'sam-altman' from particle_person_resolve), a knowledge-graph entity slug for the same person, or an ID. |
List episodes across the catalog with rich filters: by podcast, person, company, language, date range, duration, or transcript availability. By default it lists the episodes we have ingested. Pass `transcript_status` with `podcast_slug` to reach the show's back catalogue — older episodes discovered in its feed but not transcribed, marked requestable. Their transcript, segments, speakers and entities do not exist until one is requested. Use this for episode-level discovery when you only need metadata (title, duration, speakers, counts). For dialogue around a person in any episode, use `particle_podcast_find_mentions`. For ranked retrieval by topic, use `particle_podcast_search_transcripts`. The `guest_` filters list episodes by their guests' expertise (resolve the words to codes with `particle_expertise_resolve` first; on `unresolved_reference`, resolve and retry): `guest_occupation="cardiologists"` with `guest_practicing=true` lists episodes with a practicing cardiologist as a guest, and `guest_capacity="executive_founder"` lists episodes with a founder as a guest.
| Argument | Type | Description |
|---|---|---|
| role | string | Role filter when person_slug or company_slug is set. |
| limit | integer | Episodes per page (1-50, default 10). |
| cursor | string | Opaque pagination cursor from a previous response. |
| language | string | Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'. |
| entity_slug |
Browse podcast guests across the catalog, in two opinionated modes: - `directory` (default): the guest directory ranked by lifetime appearances (guests with 2+ appearances). - `trends`: who's making the rounds right now — guests with appearances on 2+ distinct podcasts in the last 30 days, which surfaces cross-show press tours rather than show regulars. The press-tour shape is enforced: every in-window appearance must be on a different podcast, each needs 5+ minutes of identified speaking time, mononymous catch-all people are excluded, and the in-window rate must be a 2x spike over the guest's lifetime baseline. `podcast_slug` switches the directory to one show's roster: every guest who has appeared on that podcast, ranked by appearances on the show (one-off guests included). `topic_slug` narrows either corpus mode to guests appearing on episodes about that topic. `occupation`/`field` (with `standing`, `seniority`, `practicing`, `capacity`, `employer`) keep guests by what they know: resolve the words ("doctors", "economists") to codes with `particle_expertise_resolve` first, and on `unresolved_reference` resolve and retry rather than dropping the filter. Every row names the guest's occupation codes, standing and seniority; `include: ["expertise"]` adds their organization. Guest slugs ARE person slugs — feed them into `particle_podcast_get_guest` for the appearance profile or `particle_person_get` for the person profile.
| Argument | Type | Description |
|---|---|---|
| mode | string | What to return. 'directory' (default): the guest directory ranked by lifetime appearances. 'trends': guests trending right now — appearances on 2+ distinct podcasts in the last 30 days (cross-show press tours, not regulars). |
| field | string | Only guests listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). Directory mode only. |
List the shows most related to a podcast, best first — "shows like this show". Each result carries the related show's slug, a calibrated score in (0,1], and a coarse band (strong: same beat and audience; moderate: overlapping subject or audience; weak: a loose connection) to branch on. Add `include: ["basis"]` to see WHY each pair is related: content similarity of recent episodes, shared topics, shared guests (named), same publisher, shared sponsors — use it to explain a recommendation or to keep only pairs related for the reason you care about (shared guests for booking, content for media planning). Related sets are precomputed per show from its transcripts, topic profile, guest roster, network and advertisers, restricted to the show's language. Only shows above a relatedness floor are listed, machine-generated and farmed feeds are never listed, and a publisher's duplicate feeds of one show appear once. An empty FIRST page is not an error: its `coverage` says whether the set is not computed yet, nothing cleared the floor, or the request's filters and the default policy removed everything; an empty page reached through a cursor is simply the end of the list. Not a topic browser: for shows that COVER a topic use `particle_podcast_resolve` with `topic_slug`. Not a guest lookup: for where a person has appeared use `particle_podcast_get_guest`. Not advertiser co-occurrence: use `particle_podcast_get_sponsors`. Every related show's slug feeds `particle_podcast_resolve`, `particle_podcast_list_episodes` and the other podcast tools; person slugs in the basis feed `particle_podcast_get_guest`, topic slugs feed `particle_podcast_resolve`'s `topic_slug`. For the five most related shows inline on a resolve, pass `include: ["related"]` to `particle_podcast_resolve` instead of calling this tool.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Results per page (1-50, default 10). |
| cursor | string |
Episodes from OTHER shows that cover the same story or subject as a given episode, best first — a live nearest-neighbour search over episode content, reranked on shared salient entities, shared topics and a shared news story. Each row carries a calibrated score and a band (strong / moderate / weak) to branch on; pass `include: ["basis"]` to see the signals behind every match. Each show contributes at most two episodes, the same content republished on another feed is collapsed to one row, and feeds the screens flag as machine-made or syndication spam are excluded. Use it when you already have an episode and want its coverage elsewhere ('who else covered this?'). Add `published_within_days` (7–30) to keep to the same news cycle; `same_podcast: true` admits the show's own episodes, which are otherwise excluded. Do NOT use it to find dialogue about a topic — that is `particle_podcast_search_transcripts` — nor to find every line naming an entity, which is `particle_podcast_find_mentions`. Episode slugs on every row feed `particle_podcast_get_episode`; podcast slugs feed `particle_podcast_resolve`.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Results per page (1-50, default 10). |
| cursor | string | Opaque pagination cursor from a previous response. |
| include | array | 'basis' attaches, per result, the signals behind the match: content similarity, shared entities with names, shared topics, a shared news story, shared guests, days apart. |
| episode_slug* | string | Episode slug or ID (from particle_podcast_list_episodes, particle_podcast_get_episode, or a search result). A particle.pro or Radar episode link also works. |
Find a podcast by free-text title, exact slug, iTunes ID, or RSS feed URL. Returns slug, title, episode count, bias, and the top recurring speakers (with entity slugs). Use the slug as the agent-facing handle to feed into other podcast tools (`particle_podcast_find_mentions`, `particle_podcast_list_episodes`, `particle_podcast_get_sponsors`). Free-text matching is forgiving — typos, missing or extra words, and pasted episode titles all work. Results are ordered best-match-first; text matches carry a `match_quality` field, and an empty list means the catalog has no plausible candidate. With all identifiers omitted, returns the most recently updated podcasts — useful for browsing the catalog when you don't have a name in mind. Narrow free-text browsing with `topic_slug` (topic concentration, descendants included), `suitability_tier`, or `min_popularity` (global popularity percentile over charting podcasts). Optional hydrations attach extra data to each result in the same call: - `include: ["external_links"]`: third-party platform presences (directories, social profiles, video channels, publisher websites) with resolved URLs and audience metrics. - `include: ["suitability"]`: per-category brand-suitability breakdown (12 categories with prevalence, treatment, derived risk level, reasoning, and evidence excerpts) — premium-grade data, requires a plan with premium endpoints. The high-level `suitability_tier` enum (SAFE / LIMITED / SENSITIVE / UNSAFE) is rendered on every result without opt-in. - `include: ["ratings_summary"]`: listener-review aggregate (average stars, count, per-platform breakdown). - `include: ["bias"]`: full political-bias analysis (the high-level bias enum is always rendered without opt-in). - `include: ["rankings"]`: current chart positions across sources/countries/categories — premium-grade data, requires a plan with premium endpoints. For movers and history use `particle_podcast_get_rankings`. - `include: ["format"]`: the show's format profile — how often episodes feature guests, detected production formats (interview, panel, call_in, solo_narrated), ad and video presence, episode-length distribution, publishing cadence, and the publish-day pattern. - `include: ["guest_expertise"]`: the show's guest mix — shares of its analyzed guest appearances by established, senior and in-field guests and promotional appearances, and the occupations and fields it books most. - `recent_episodes: N`: inline this many of each result's most recent episodes (slug, title, published_at, duration) — skip the follow-up `particle_podcast_list_episodes` call when you only need the most recent tail. Find shows by who they book with `guest_occupation` or `guest_field` (resolve the words to codes with `particle_expertise_resolve` first) and the share floors `min_established_guest_share`, `min_in_field_guest_share` and `max_promotional_guest_share`: `guest_field="banking-finance-and-investment"` with `min_established_guest_share=0.5` finds shows that book established finance experts. For the shows that booked an occupation's or field's guests most in a recent window, use `particle_expertise_get` with `include: ["top_podcasts"]`.
Search the podcast catalog by what is said in episodes — by meaning (`semantic_search`), by exact phrase (`keyword_search`), or both at once (hybrid ranking). This is THE way to retrieve relevant dialogue, segments, and clips: each result is one segment of one episode with bounded transcript windows pinpointing the highest-relevance lines, plus any highlight clips that overlap the segment inline on the match. Segments partition an episode's transcript — where start_line and end_line are present, every spoken line belongs to exactly one segment and one segment's end_line + 1 is the next one's start_line. They are contiguous in transcript lines, not in wall-clock seconds: the seconds between one segment's end_seconds and the next's start_seconds contain no transcribed speech. These matches do not carry the line ranges themselves — fetch them with `particle_podcast_get_episode` and `include: ["segments"]`, where their absence marks an episode segmented by an earlier version, a small share of which do leave lines uncovered. Clips are sparse, engagement-ranked highlights that overlap some segments. There is no separate clip-search tool — relevant clips arrive on these matches, and a known episode's full clip list is `particle_podcast_get_episode` with `include: ["clips"]`. A match window defaults to one line of context around each matched line; raise `context` to widen windows in place instead of fetching the full transcript. **Screening many results?** Pass `format: "compact"`. Each match then carries only its identity — episode and podcast slugs, segment id and bounds, segment type, the segment's one-line description, and the relevance score — with no dialogue or clips, at a fraction of the size and latency of the default. Fan out compact searches over companies, themes, or dates, decide which segments matter, then read dialogue only for those: `particle_podcast_get_episode` with `include: ["transcript"]` and `transcript_start`/`transcript_end` set to the segment's bounds, or this tool again with `episode_slug` narrowed to that episode. Use this for "find dialogue *about* a topic". For "every line *naming* a person or company" use `particle_podcast_find_mentions` instead — `person_slug` and `company_slug` here narrow ranked results, they don't drive the ranking. **Choosing your query.** At least one of `semantic_search` or `keyword_search` is required, and they do different jobs: - `semantic_search` carries the *idea*. Write it as a sentence describing what should be discussed, in the vocabulary a speaker would use. It is paraphrase-tolerant, so it finds the topic however it happens to be worded. - `keyword_search` carries words that must be *literally spoken*. Every word must occur in the same passage, so it is for one or two exact tokens — a ticker, a product name — not for a description. Putting a sentence here returns nothing. - Use both when a topic must also contain an exact term. The result is their intersection, which is narrow by design; if that comes back empty, `keyword_match: "ranked"` relaxes the keyword side to a relevance hint. **Do not put a name in `semantic_search`.** Resolve it (`particle_person_resolve`, `particle_company_resolve`, `particle_entity_resolve`) and pass the slug — searching for "Sam Altman" as text finds passages that *sound like* him, while `person_slug` finds the episodes actually featuring him. **The question's constraints go on the first call.** Who is speaking, which person, company or show, which window or language: when the question states it, pass it from the start, because a search without it answers a different question. Hold back only the filters you add on your own (a `segment_type`, a `role`, a narrower window) until a search shows the topic has coverage: every filter compounds, and each one can remove all results. If a search returns nothing because of a filter, the error names the parameter responsible and the retry to make — act on it rather than re-issuing variations of the same query, and when a constraint the question stated is what emptied it, say so before showing anything wider. **Note on `role`.** It describes how someone relates to the episode: `guest`/`host`/`panelist`/`correspondent` mean they *spoke*, `mention` means they were *talked about*. Omitting `role` covers both and is almost always what you want. **Who is speaking.** When the question restricts who speaks by occupation, profession or industry ("medical professionals", "economists", "lawyers"), pass the words themselves as `guest_occupation`, which resolves an everyday word to the occupation, field or capacity it names, or a code from `particle_expertise_resolve` as `guest_occupation`/`guest_field` (plus `guest_standing="established"` or `guest_practicing=true` when credentials matter); never stand the profession in for a filter inside `semantic_search`. On `unresolved_reference`, resolve and retry; never drop the filter. A word no occupation names may name a capacity ("founders", "politicians"): pass it as `guest_capacity`. The filters AND together, so two groups ("founders and VCs") take one call each. The filters keep segments in which such a guest speaks, so a window can also carry the host's lines: each full-format match lists its identified speakers as `**Speaker:**` rows with their occupation codes, standing and seniority — check them before attributing a line to a credential.
Navigate the topic taxonomy. Without `parent_slug`, returns the top-level roots (Politics, Business, Technology, etc.). With `parent_slug` set, returns the direct children of that topic. Topic slugs use a `parent/child` convention (e.g. `politics/elections`) and let agents browse the hierarchy to find well-named categories. To find a topic by name instead of walking the tree, pass `query` (e.g. `artificial intelligence`): exact names rank first, then prefixes, then substrings (for a word of 3+ characters), each by story coverage, and `parent_slug` narrows the search to that subtree. The same name often sits under several parents, so read the ancestry before picking a slug. Topic slugs feed the `topic_slug` filters on `particle_podcast_resolve` and `particle_podcast_list_guests`.
| Argument | Type | Description |
|---|---|---|
| limit | integer | Topics per page (1-100, default 50). |
| query | string | Find topics by name: exact names first, then names starting with it, then (when it has a word of 3 or more characters) names containing it, each ranked by story coverage. Covers topics with at least 5 story clusters; browse with parent_slug for the long tail. Pages reach the top 200 matches. |
| cursor | string | Opaque pagination cursor from a previous response. |
| parent_slug | string | Topic slug or ID. Returns the direct children of this topic. Omit for top-level roots (Politics, Business, Technology, etc.). With query, limits the search to this topic's descendants. |
| output_format |
| is_active |
| boolean |
| Whether the alert produces matches. Defaults to true. Set false to create it paused. |
| description | string | Optional longer description of what the alert is for. |
| notifications | array | Email addresses for recurring alert notifications. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. At least one recipient must be deliverable. When omitted, defaults to your account email if available; otherwise pass at least one. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| delivery_cadence | string | How often matches are emailed: REALTIME (default, one email per match), DAILY (one bundled email each morning), or WEEKLY (one bundled email Monday). |
{
"type": "object",
"required": [
"title"
],
"properties": {
"kind": {
"enum": [
"ENTITY_MENTION",
"PODCAST_SPEAKER",
"KEYWORD_MENTION"
],
"type": "string",
"description": "What signal to watch for. ENTITY_MENTION (default) fires whenever a watched entity is mentioned on a podcast episode. PODCAST_SPEAKER fires only when a watched person is themself an identified speaker: by default as guest/panelist/correspondent/audience or in an excerpted soundbite (SOUNDBITE_SPEAKER), never as host; speaker_roles replaces that set. KEYWORD_MENTION fires whenever keyword is spoken — use it when the name has no entity slug (a resolve tool finds nothing, or the right entity has no episodes). Kind is fixed at creation."
},
"title": {
"type": "string",
"description": "Human-readable title for the alert (e.g. 'OpenAI mentions')."
},
"filters": {
"type": "object",
"properties": {
"languages": {
"type": "array",
"items": {
"type": "string"
},
"description": "Primary language tags the source episode must be in: a 2-3 letter primary tag (e.g. 'en', 'de', 'sma'). A region or script subtag (e.g. 'pt-BR', 'zh-Hant') is accepted for readability but matching is on the PRIMARY tag only — 'pt-BR' surfaces every Portuguese episode regardless of region, and 'pt-BR' + 'pt-PT' collapse to one. Empty or missing means all languages are surfaced. Case-insensitive; echoed in canonical primary-tag form."
},
"relevance": {
"enum": [
"EVERYTHING",
"RELEVANT"
],
"type": "string",
"description": "EVERYTHING (default) returns both on-target and incidental matches — the watched entity is correctly identified in both, only the depth of discussion differs. RELEVANT narrows to on-target only: matches where the watched entity is the subject being discussed, dropping passing mentions. Wrong-entity matches (name collisions) are globally suppressed before any filter runs."
},
"speaker_roles": {
"type": "array",
"items": {
"enum": [
"HOST",
"GUEST",
"PANELIST",
"CORRESPONDENT",
"AUDIENCE",
"SOUNDBITE_SPEAKER"
],
"type": "string"
},
"description": "PODCAST_SPEAKER alerts only — sending this on an ENTITY_MENTION alert returns an unprocessable_entity error. REPLACES (not intersects with) the default appearance set. Default when omitted is GUEST, PANELIST, CORRESPONDENT, AUDIENCE, SOUNDBITE_SPEAKER — HOST is excluded because hosting the show isn't an appearance. Setting ['HOST'] flips that; setting ['GUEST'] alone narrows further. Input casing is not significant — 'guest' and 'GUEST' are the same value — and the filter is stored and returned in canonical uppercase form. Raw STT/LLM labels like CALLER or REPORTER are not accepted."
},
"source_popularity": {
"enum": [
"ANY",
"POPULAR"
],
"type": "string",
"description": "ANY (default) keeps matches from every source. POPULAR keeps only matches whose source podcast scores in the top 5% by chart-popularity percentile (Podcast.Popularity >= 0.95; cume_dist over current chart entries, multi-region weighted). Podcasts that aren't currently charting drop out."
}
},
"description": "Persistent narrowing applied to every surface the alert produces (matches list, realtime email, daily/weekly digest). Omit for no filters — every detected match is surfaced. See AlertFiltersInput for the four axes (languages, relevance, source_popularity, speaker_roles)."
},
"keyword": {
"type": "string",
"maxLength": 100,
"description": "KEYWORD_MENTION alerts only (and required for them): the phrase to watch, e.g. Lightfield. Matches like a double-quoted keyword_search phrase — the words adjacent and in order, ignoring case and punctuation, on whole words — in topic-discussion and interview segments, never ad reads, intros, or outros. Also set description to say what the phrase means (e.g. 'Lightfield, the AI-native CRM'); it is how same-name mentions of something else get filtered out. A phrase that matched more than 700 podcast episodes in the past week is rejected as too broad."
},
"entities": {
"type": "array",
"items": {
"type": "string"
},
"maxItems": 1,
"minItems": 1,
"description": "The entity to watch, as a single slug from the resolve tools (particle_entity_resolve, particle_person_resolve, particle_company_resolve). Person, company, and place/other (knowledge-graph) slugs are all accepted; the resolved type is echoed back in the response. Exactly one for ENTITY_MENTION and PODCAST_SPEAKER — an alert watches a single entity, so create one alert per entity. Omit for KEYWORD_MENTION."
},
"is_active": {
"type": "boolean",
"description": "Whether the alert produces matches. Defaults to true. Set false to create it paused."
},
"description": {
"type": "string",
"description": "Optional longer description of what the alert is for."
},
"notifications": {
"type": "array",
"items": {
"type": "string"
},
"description": "Email addresses for recurring alert notifications. Only recipients verified for your organization receive alert emails; pending recipients may be saved but stay silent until verified. At least one recipient must be deliverable. When omitted, defaults to your account email if available; otherwise pass at least one."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"delivery_cadence": {
"enum": [
"REALTIME",
"DAILY",
"WEEKLY"
],
"type": "string",
"description": "How often matches are emailed: REALTIME (default, one email per match), DAILY (one bundled email each morning), or WEEKLY (one bundled email Monday)."
}
}
}{
"type": "object",
"required": [
"alert_id"
],
"properties": {
"view": {
"enum": [
"summary",
"detailed"
],
"type": "string",
"description": "Detail level. 'summary' (default) returns each match's entity, episode, and counts. 'detailed' also includes the transcript excerpt windows around each mention."
},
"after": {
"type": "string",
"description": "Only matches detected on or after this ISO date (e.g. 2026-05-01)."
},
"limit": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Matches per page (1-100, default 25)."
},
"before": {
"type": "string",
"description": "Only matches detected on or before this ISO date."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response's cursor field."
},
"alert_id": {
"type": "string",
"description": "Alert id whose matches to list."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| window_days | integer | How many days back to sweep (1-30, default 7). |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"kind": {
"enum": [
"ENTITY_MENTION",
"PODCAST_SPEAKER",
"KEYWORD_MENTION"
],
"type": "string",
"description": "Signal to preview. Defaults to ENTITY_MENTION."
},
"filters": {
"type": "object",
"properties": {
"languages": {
"type": "array",
"items": {
"type": "string"
},
"description": "Primary language tags the source episode must be in: a 2-3 letter primary tag (e.g. 'en', 'de', 'sma'). A region or script subtag (e.g. 'pt-BR', 'zh-Hant') is accepted for readability but matching is on the PRIMARY tag only — 'pt-BR' surfaces every Portuguese episode regardless of region, and 'pt-BR' + 'pt-PT' collapse to one. Empty or missing means all languages are surfaced. Case-insensitive; echoed in canonical primary-tag form."
},
"relevance": {
"enum": [
"EVERYTHING",
"RELEVANT"
],
"type": "string",
"description": "EVERYTHING (default) returns both on-target and incidental matches — the watched entity is correctly identified in both, only the depth of discussion differs. RELEVANT narrows to on-target only: matches where the watched entity is the subject being discussed, dropping passing mentions. Wrong-entity matches (name collisions) are globally suppressed before any filter runs."
},
"speaker_roles": {
"type": "array",
"items": {
"enum": [
"HOST",
"GUEST",
"PANELIST",
"CORRESPONDENT",
"AUDIENCE",
"SOUNDBITE_SPEAKER"
],
"type": "string"
},
"description": "PODCAST_SPEAKER alerts only — sending this on an ENTITY_MENTION alert returns an unprocessable_entity error. REPLACES (not intersects with) the default appearance set. Default when omitted is GUEST, PANELIST, CORRESPONDENT, AUDIENCE, SOUNDBITE_SPEAKER — HOST is excluded because hosting the show isn't an appearance. Setting ['HOST'] flips that; setting ['GUEST'] alone narrows further. Input casing is not significant — 'guest' and 'GUEST' are the same value — and the filter is stored and returned in canonical uppercase form. Raw STT/LLM labels like CALLER or REPORTER are not accepted."
},
"source_popularity": {
"enum": [
"ANY",
"POPULAR"
],
"type": "string",
"description": "ANY (default) keeps matches from every source. POPULAR keeps only matches whose source podcast scores in the top 5% by chart-popularity percentile (Podcast.Popularity >= 0.95; cume_dist over current chart entries, multi-region weighted). Podcasts that aren't currently charting drop out."
}
},
"description": "Same as particle_alert_create.filters. Pass the filters you intend to save so the estimate reflects what the alert would actually surface. Only languages and speaker_roles narrow the historical sweep; relevance and source_popularity are read-time projections that don't run on historical episodes, so setting them leaves the count unchanged (the estimate is an upper bound when relevance=RELEVANT)."
},
"keyword": {
"type": "string",
"maxLength": 100,
"description": "Same as particle_alert_create.keyword — required for KEYWORD_MENTION. A phrase that matched more than 700 podcast episodes in the past week is rejected as too broad, as on create."
},
"entities": {
"type": "array",
"items": {
"type": "string"
},
"maxItems": 1,
"minItems": 1,
"description": "The entity to preview, as a single slug (from the resolve tools), same as particle_alert_create.entities — exactly one for entity kinds, omitted for KEYWORD_MENTION."
},
"window_days": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "How many days back to sweep (1-30, default 7)."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| alert_id* | string | Alert id to update. |
| entities | array | Replacement watch target as a single entity slug (from the resolve tools). When provided, replaces the entire existing watch list — exactly one entity; omit to leave entities unchanged. Not accepted on KEYWORD_MENTION alerts. |
| is_active | boolean | Pause (false) or resume (true) the alert. |
| description | string | New description. |
| notifications | array | Replacement recipients for recurring alert emails. Only recipients verified for your organization receive alert emails; pending recipients stay silent until verified. When provided, replaces the entire existing set; omit to leave them unchanged. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| delivery_cadence | string | New delivery cadence. |
{
"type": "object",
"required": [
"alert_id"
],
"properties": {
"title": {
"type": "string",
"description": "New title."
},
"filters": {
"type": "object",
"properties": {
"languages": {
"type": "array",
"items": {
"type": "string"
},
"description": "Primary language tags the source episode must be in: a 2-3 letter primary tag (e.g. 'en', 'de', 'sma'). A region or script subtag (e.g. 'pt-BR', 'zh-Hant') is accepted for readability but matching is on the PRIMARY tag only — 'pt-BR' surfaces every Portuguese episode regardless of region, and 'pt-BR' + 'pt-PT' collapse to one. Empty or missing means all languages are surfaced. Case-insensitive; echoed in canonical primary-tag form."
},
"relevance": {
"enum": [
"EVERYTHING",
"RELEVANT"
],
"type": "string",
"description": "EVERYTHING (default) returns both on-target and incidental matches — the watched entity is correctly identified in both, only the depth of discussion differs. RELEVANT narrows to on-target only: matches where the watched entity is the subject being discussed, dropping passing mentions. Wrong-entity matches (name collisions) are globally suppressed before any filter runs."
},
"speaker_roles": {
"type": "array",
"items": {
"enum": [
"HOST",
"GUEST",
"PANELIST",
"CORRESPONDENT",
"AUDIENCE",
"SOUNDBITE_SPEAKER"
],
"type": "string"
},
"description": "PODCAST_SPEAKER alerts only — sending this on an ENTITY_MENTION alert returns an unprocessable_entity error. REPLACES (not intersects with) the default appearance set. Default when omitted is GUEST, PANELIST, CORRESPONDENT, AUDIENCE, SOUNDBITE_SPEAKER — HOST is excluded because hosting the show isn't an appearance. Setting ['HOST'] flips that; setting ['GUEST'] alone narrows further. Input casing is not significant — 'guest' and 'GUEST' are the same value — and the filter is stored and returned in canonical uppercase form. Raw STT/LLM labels like CALLER or REPORTER are not accepted."
},
"source_popularity": {
"enum": [
"ANY",
"POPULAR"
],
"type": "string",
"description": "ANY (default) keeps matches from every source. POPULAR keeps only matches whose source podcast scores in the top 5% by chart-popularity percentile (Podcast.Popularity >= 0.95; cume_dist over current chart entries, multi-region weighted). Podcasts that aren't currently charting drop out."
}
},
"description": "Replace the alert's filter set wholesale. Omit to leave the existing filters unchanged; send an empty object {} to clear all filters. Same four axes as particle_alert_create.filters (languages, relevance, source_popularity, speaker_roles)."
},
"keyword": {
"type": "string",
"maxLength": 100,
"description": "Replacement phrase for a KEYWORD_MENTION alert; omit to leave it unchanged. Not accepted on other kinds. Matches already recorded keep the phrase they fired on."
},
"alert_id": {
"type": "string",
"description": "Alert id to update."
},
"entities": {
"type": "array",
"items": {
"type": "string"
},
"maxItems": 1,
"minItems": 1,
"description": "Replacement watch target as a single entity slug (from the resolve tools). When provided, replaces the entire existing watch list — exactly one entity; omit to leave entities unchanged. Not accepted on KEYWORD_MENTION alerts."
},
"is_active": {
"type": "boolean",
"description": "Pause (false) or resume (true) the alert."
},
"description": {
"type": "string",
"description": "New description."
},
"notifications": {
"type": "array",
"items": {
"type": "string"
},
"description": "Replacement recipients for recurring alert emails. Only recipients verified for your organization receive alert emails; pending recipients stay silent until verified. When provided, replaces the entire existing set; omit to leave them unchanged."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"delivery_cadence": {
"enum": [
"REALTIME",
"DAILY",
"WEEKLY"
],
"type": "string",
"description": "New delivery cadence."
}
}
}| Argument | Type | Description |
|---|---|---|
| category | string | Exposure category name (e.g. 'podcast_bias'). When set, the response includes the FULL input schema for every tool in that category — call this before invoking a tool you haven't seen advertised. When omitted, returns the categorical menu: every category with its tools and one-line summaries. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"category": {
"type": "string",
"description": "Exposure category name (e.g. 'podcast_bias'). When set, the response includes the FULL input schema for every tool in that category — call this before invoking a tool you haven't seen advertised. When omitted, returns the categorical menu: every category with its tools and one-line summaries."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}{
"type": "object",
"required": [
"company_slug"
],
"properties": {
"include": {
"type": "array",
"items": {
"enum": [
"people",
"products",
"competitors",
"podcast_recommendations",
"external_links"
],
"type": "string"
},
"description": "Optional response sections: 'people' (current leadership and notable people), 'products' (three-level product hierarchy), 'competitors' (competitor list), 'podcast_recommendations' (the ten podcasts the company could advertise on next, with the shows it already buys that led there; premium), 'external_links' (LinkedIn, social profiles, domain, Wikidata QID, SEC CIK and tickers). Default response is lean — request only what you need."
},
"company_slug": {
"type": "string",
"description": "Company identifier — accepts slug (e.g. 'nvidia'), domain (e.g. 'nvidia.com'), or canonical ID. If you already know the domain you can call this tool directly without first running particle_company_resolve."
},
"product_status": {
"type": "string",
"description": "Comma-separated lifecycle filter for include=products (e.g. 'active' or 'active,announced'). Allowed values: active, announced, discontinued, rumored. Defaults to 'active'."
}
}
}{
"type": "object",
"properties": {
"cik": {
"type": "string",
"description": "SEC Central Index Key (e.g. '0000320193'). Comma-separated for bulk."
},
"qid": {
"type": "string",
"description": "Wikidata QID (e.g. 'Q312'). Comma-separated for bulk."
},
"limit": {
"type": "integer",
"maximum": 25,
"minimum": 1,
"description": "Maximum candidates to return (1-25, default 5)."
},
"query": {
"type": "string",
"description": "Free-text company name (case-insensitive). Use for human-typed names."
},
"domain": {
"type": "string",
"description": "Company website domain (e.g. 'apple.com'). Comma-separated for bulk."
},
"ticker": {
"type": "string",
"description": "Stock ticker symbol (e.g. 'NVDA', 'AAPL'). Comma-separated for multi-ticker lookup."
}
}
}| include |
| array |
| Optional sections: 'top_guests' (the guests in the code most booked in the window, with appearances, shows and last appearance) and 'top_podcasts' (the shows that booked the code's guests most). Default is the code with its parent, children and crosswalk. |
| standing | string | Rank only guests whose standing is recognized this way (e.g. 'established' for credentialed experts). Applies to the top_ sections. |
| min_guests | integer | top_podcasts keeps shows that booked at least this many distinct guests in the code in the window (default 1). |
| occupation | string | An occupation's SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve (e.g. 'cardiologists'). Pass exactly one of occupation or field. |
| min_podcasts | integer | top_guests keeps guests seen on at least this many distinct shows in the window (default 1); raise it to favor guests booked across the medium over a show's regulars. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"field": {
"type": "string",
"description": "A field of research's ANZSRC 2020 code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). Pass exactly one of occupation or field."
},
"limit": {
"type": "integer",
"maximum": 25,
"minimum": 1,
"description": "Rows per top_ section (1-25, default 10)."
},
"since": {
"type": "string",
"description": "Window start for the top_ sections (YYYY-MM-DD). Defaults to 30 days before until; the window may span at most 90 days."
},
"until": {
"type": "string",
"description": "Window end for the top_ sections (YYYY-MM-DD, inclusive). Defaults to now."
},
"include": {
"type": "array",
"items": {
"enum": [
"top_guests",
"top_podcasts"
],
"type": "string"
},
"description": "Optional sections: 'top_guests' (the guests in the code most booked in the window, with appearances, shows and last appearance) and 'top_podcasts' (the shows that booked the code's guests most). Default is the code with its parent, children and crosswalk."
},
"standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Rank only guests whose standing is recognized this way (e.g. 'established' for credentialed experts). Applies to the top_ sections."
},
"min_guests": {
"type": "integer",
"minimum": 1,
"description": "top_podcasts keeps shows that booked at least this many distinct guests in the code in the window (default 1)."
},
"occupation": {
"type": "string",
"description": "An occupation's SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve (e.g. 'cardiologists'). Pass exactly one of occupation or field."
},
"min_podcasts": {
"type": "integer",
"minimum": 1,
"description": "top_guests keeps guests seen on at least this many distinct shows in the window (default 1); raise it to favor guests booked across the medium over a show's regulars."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| string |
| Free text naming an occupation or a field of research (e.g. 'cardiologist', 'financial analyst', 'constitutional law'). Singular or plural; words match by prefix. Omit with parent to list that code's children, or omit both to list the top level. |
| parent | string | A code, slug or title whose children to list (e.g. '29-0000' for the healthcare occupations, or '38' for economics). With query, searches only below it. |
| standard | string | Which codes to search: 'occupation' (SOC 2018, with ISCO-08 equivalents), 'field' (ANZSRC 2020 fields of research), or 'any' (default) for both. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"limit": {
"type": "integer",
"maximum": 25,
"minimum": 1,
"description": "Maximum codes to return (1-25, default 5)."
},
"query": {
"type": "string",
"description": "Free text naming an occupation or a field of research (e.g. 'cardiologist', 'financial analyst', 'constitutional law'). Singular or plural; words match by prefix. Omit with parent to list that code's children, or omit both to list the top level."
},
"parent": {
"type": "string",
"description": "A code, slug or title whose children to list (e.g. '29-0000' for the healthcare occupations, or '38' for economics). With query, searches only below it."
},
"standard": {
"enum": [
"occupation",
"field",
"any"
],
"type": "string",
"description": "Which codes to search: 'occupation' (SOC 2018, with ISCO-08 equivalents), 'field' (ANZSRC 2020 fields of research), or 'any' (default) for both."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| output_format |
| string |
| Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"required": [
"person_slug"
],
"properties": {
"include": {
"type": "array",
"items": {
"enum": [
"external_links",
"podcast_appearances",
"companies",
"sports",
"expertise"
],
"type": "string"
},
"description": "Optional response sections: 'external_links' (LinkedIn, Wikipedia, social profiles), 'podcast_appearances' (recent podcast appearances with episode and podcast slugs), 'companies' (the full role history, current role included and marked), 'sports' (the current team of an NFL, MLB or NHL player, sports played, and teams played for or coached with years and leagues), 'expertise' (what they know and how established they are: standing, seniority, experience, the occupations and fields they are listed under with codes the guest_ filters accept, organization, credential). Default response is lean — request only what you need."
},
"person_slug": {
"type": "string",
"description": "Canonical person slug from particle_person_resolve (e.g. 'sam-altman'), or the encoded person ID."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| Argument | Type | Description |
|---|---|---|
| role | string | Constrain how the entity participates: guest, host, panelist, correspondent, or mention. |
| limit | integer | Episodes per page (1-50, default 10). Summary and compact modes — detail returns one episode regardless. |
| since | string | Only episodes published on or after this ISO 8601 date (e.g. 2025-01-01). |
| until | string | Only episodes published on or before this ISO 8601 date. |
| cursor | string | Opaque pagination cursor from a previous summary or compact response's cursor field. Summary and compact modes. |
| format | string | Response shape. 'summary' (default) returns many episodes (reverse chron) with metadata plus the first few mention-only lines per episode — use this to scan and pick episodes to drill into. 'detail' requires episode_slug and returns one episode's full mention windows with surrounding dialogue context. 'compact' returns the same episodes as summary with the mention count and the segments carrying the mentions (id, title, type, first mention time) and no dialogue — the smallest shape, for screening many entities before reading any. |
| language | string | Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'. |
| entity_slug | string | Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company — places, organizations, events, products, concepts (e.g. 'germany'). Use person_slug for people and company_slug for companies. |
| guest_field | string | Only mentions spoken by a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve. |
| person_slug | string | Person slug or encoded person ID from particle_person_resolve, particle_entity_resolve, or the guest tools (e.g. 'sam-altman'). One of person_slug, company_slug, or entity_slug is required. |
| company_slug | string | Company slug, domain, or canonical ID (e.g. 'nvidia' or 'nvidia.com'). Resolves to the company's linked entity. |
| episode_slug | string | Episode slug(s) or canonical ID(s). For format='detail', required: pass one slug for a single drill-in or up to 10 comma-separated slugs (e.g. 'all-in-200,all-in-201,all-in-202') for a multi-episode drill-in in one call. For format='summary' or 'compact', optional filter to one episode. |
| podcast_slug | string | Restrict mentions to a single podcast by slug, internal ID, or numeric iTunes ID. A particle.pro or Radar show link also works. |
| context_lines | integer | Surrounding dialogue lines around each mention (1-20, default 2). Detail mode only — ignored in summary and compact. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| guest_capacity | string | Only mentions spoken by a guest who knows their field in this capacity (e.g. 'public_official' for politicians). particle_expertise_resolve names the capacity an everyday word means. |
| guest_in_field | boolean | Only mentions spoken by a guest speaking within their own field (the guest the other guest_ filters select, when given). |
| guest_standing | string | Only mentions spoken by a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'. |
| guest_seniority | string | Only mentions spoken by a guest at this seniority or above. |
| guest_occupation | string | Only mentions spoken by a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'financial-and-investment-analysts' or 'physicians'). A word with no occupation filters by the field of research or capacity it names: 'investors' is field 350208, 'politicians' is capacity public_official. |
| guest_practicing | boolean | Only mentions spoken by a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group. |
{
"type": "object",
"properties": {
"role": {
"enum": [
"guest",
"host",
"panelist",
"correspondent",
"mention"
],
"type": "string",
"description": "Constrain how the entity participates: guest, host, panelist, correspondent, or mention."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Episodes per page (1-50, default 10). Summary and compact modes — detail returns one episode regardless."
},
"since": {
"type": "string",
"description": "Only episodes published on or after this ISO 8601 date (e.g. 2025-01-01)."
},
"until": {
"type": "string",
"description": "Only episodes published on or before this ISO 8601 date."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous summary or compact response's cursor field. Summary and compact modes."
},
"format": {
"enum": [
"summary",
"detail",
"compact"
],
"type": "string",
"description": "Response shape. 'summary' (default) returns many episodes (reverse chron) with metadata plus the first few mention-only lines per episode — use this to scan and pick episodes to drill into. 'detail' requires episode_slug and returns one episode's full mention windows with surrounding dialogue context. 'compact' returns the same episodes as summary with the mention count and the segments carrying the mentions (id, title, type, first mention time) and no dialogue — the smallest shape, for screening many entities before reading any."
},
"language": {
"type": "string",
"description": "Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'."
},
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company — places, organizations, events, products, concepts (e.g. 'germany'). Use person_slug for people and company_slug for companies."
},
"guest_field": {
"type": "string",
"description": "Only mentions spoken by a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve."
},
"person_slug": {
"type": "string",
"description": "Person slug or encoded person ID from particle_person_resolve, particle_entity_resolve, or the guest tools (e.g. 'sam-altman'). One of person_slug, company_slug, or entity_slug is required."
},
"company_slug": {
"type": "string",
"description": "Company slug, domain, or canonical ID (e.g. 'nvidia' or 'nvidia.com'). Resolves to the company's linked entity."
},
"episode_slug": {
"type": "string",
"description": "Episode slug(s) or canonical ID(s). For format='detail', required: pass one slug for a single drill-in or up to 10 comma-separated slugs (e.g. 'all-in-200,all-in-201,all-in-202') for a multi-episode drill-in in one call. For format='summary' or 'compact', optional filter to one episode."
},
"podcast_slug": {
"type": "string",
"description": "Restrict mentions to a single podcast by slug, internal ID, or numeric iTunes ID. A particle.pro or Radar show link also works."
},
"context_lines": {
"type": "integer",
"maximum": 20,
"minimum": 1,
"description": "Surrounding dialogue lines around each mention (1-20, default 2). Detail mode only — ignored in summary and compact."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"guest_capacity": {
"enum": [
"researcher",
"licensed_professional",
"practitioner",
"executive_founder",
"public_official",
"journalist_analyst",
"creator_entertainer",
"athlete_coach",
"clergy",
"firsthand",
"layperson"
],
"type": "string",
"description": "Only mentions spoken by a guest who knows their field in this capacity (e.g. 'public_official' for politicians). particle_expertise_resolve names the capacity an everyday word means."
},
"guest_in_field": {
"type": "boolean",
"description": "Only mentions spoken by a guest speaking within their own field (the guest the other guest_ filters select, when given)."
},
"guest_standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Only mentions spoken by a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'."
},
"guest_seniority": {
"enum": [
"professional",
"senior",
"distinguished"
],
"type": "string",
"description": "Only mentions spoken by a guest at this seniority or above."
},
"guest_occupation": {
"type": "string",
"description": "Only mentions spoken by a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'financial-and-investment-analysts' or 'physicians'). A word with no occupation filters by the field of research or capacity it names: 'investors' is field 350208, 'politicians' is capacity public_official."
},
"guest_practicing": {
"type": "boolean",
"description": "Only mentions spoken by a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group."
}
}
}| transcript_end | number | Transcript range end in seconds. Lines that overlap the range are returned whole. |
| transcript_start | number | Transcript range start in seconds. Lines that overlap the range are returned whole. |
| transcript_format | string | Transcript format for include=transcript. Defaults to text. |
| transcript_speaker | string | Filter the transcript to one speaker: a name, a person slug or ID, or an entity slug or ID. |
{
"type": "object",
"required": [
"episode_slug"
],
"properties": {
"include": {
"type": "array",
"items": {
"enum": [
"transcript",
"segments",
"entities",
"clips",
"topics",
"related",
"guest_expertise"
],
"type": "string"
},
"description": "Optional response sections: 'transcript' (bounded dialogue transcript — large for long episodes; narrow it with the transcript_* sub-params), 'segments' (structural outline with timestamps), 'entities' (complete mentioned-entity list instead of the top 20), 'clips' (engagement-ranked highlight clips), 'topics' (topic classifications with slugs), 'related' (the five episodes from OTHER shows most related to this one — slug, show, score, band; for the full ranked list with the basis behind each match call particle_podcast_list_related_episodes), 'guest_expertise' (each guest's expertise read and how the episode used it: whether they spoke within their field, whether the appearance was promotional, how they were introduced). Default response is lean — request only what you need."
},
"episode_slug": {
"type": "string",
"description": "Episode slug or canonical ID. A particle.pro or Radar episode link also works."
},
"transcript_end": {
"type": "number",
"description": "Transcript range end in seconds. Lines that overlap the range are returned whole."
},
"transcript_start": {
"type": "number",
"description": "Transcript range start in seconds. Lines that overlap the range are returned whole."
},
"transcript_format": {
"enum": [
"dialogue",
"text",
"srt"
],
"type": "string",
"description": "Transcript format for include=transcript. Defaults to text."
},
"transcript_speaker": {
"type": "string",
"description": "Filter the transcript to one speaker: a name, a person slug or ID, or an entity slug or ID."
}
}
}| interval | string | Bucket width. Weeks start on Monday; all buckets are UTC-aligned. Defaults to week. |
| language | string | Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'. |
| entity_slug | string | Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company (e.g. 'germany'). Use person_slug for people and company_slug for companies. |
| guest_field | string | Only episodes with a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). |
| person_slug | string | Person slug or encoded person ID (e.g. 'sam-altman'). Counts episodes featuring the person as a speaker — and, when the person has a linked knowledge-graph entity, episodes that mention them. |
| company_slug | string | Company slug, domain, or ID. Resolves to the linked entity. |
| max_duration | integer | Maximum episode duration in seconds. |
| min_duration | integer | Minimum episode duration in seconds. |
| podcast_slug | string | Podcast slug, internal ID, or numeric iTunes ID. Restrict to one podcast. A particle.pro or Radar show link also works. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| guest_capacity | string | Only episodes with a guest who knows their field in this capacity (e.g. 'executive_founder' for founders). It narrows the other filters; particle_expertise_resolve names the capacity an everyday word means. |
| guest_in_field | boolean | Only episodes with a guest speaking within their own field (the guest the other guest_ filters select, when given). |
| guest_standing | string | Only episodes with a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'. |
| has_transcript | boolean | Only count episodes with a completed transcript. |
| keyword_search | string | Keyword filter over transcript content. Double-quoted substrings must appear as exact phrases; unquoted terms must all appear in one transcript segment. Adds per-bucket mention counts to the response. Cannot be combined with semantic_search. |
| guest_seniority | string | Only episodes with a guest at this seniority or above. |
| published_after | string | Inclusive range start as an ISO 8601 date or date-time. Omit to aggregate all time. |
| semantic_search | string | Vector-similarity filter by meaning over transcript content — the counting twin of particle_podcast_search_transcripts' semantic_search, using the same similarity threshold. Describe the topic the way you'd say it to a colleague; paraphrase tolerant. Adds per-bucket mention counts to the response. Requires published_after (ranges up to ~2 years). Cannot be combined with keyword_search. |
| guest_occupation | string | Only episodes with a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). A word with no occupation filters by the field of research or capacity it names: 'oncologists' is field 3211, 'founders' is capacity executive_founder. |
| guest_practicing | boolean | Only episodes with a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group (e.g. '29-1212' or 'physicians'). |
| published_before | string | Range end as an ISO 8601 date or date-time. Defaults to now. |
{
"type": "object",
"properties": {
"role": {
"enum": [
"guest",
"host",
"panelist",
"correspondent",
"mention"
],
"type": "string",
"description": "Role filter when person_slug, company_slug, or entity_slug is set."
},
"interval": {
"enum": [
"day",
"week",
"month"
],
"type": "string",
"description": "Bucket width. Weeks start on Monday; all buckets are UTC-aligned. Defaults to week."
},
"language": {
"type": "string",
"description": "Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'."
},
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company (e.g. 'germany'). Use person_slug for people and company_slug for companies."
},
"guest_field": {
"type": "string",
"description": "Only episodes with a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment')."
},
"person_slug": {
"type": "string",
"description": "Person slug or encoded person ID (e.g. 'sam-altman'). Counts episodes featuring the person as a speaker — and, when the person has a linked knowledge-graph entity, episodes that mention them."
},
"company_slug": {
"type": "string",
"description": "Company slug, domain, or ID. Resolves to the linked entity."
},
"max_duration": {
"type": "integer",
"minimum": 0,
"description": "Maximum episode duration in seconds."
},
"min_duration": {
"type": "integer",
"minimum": 0,
"description": "Minimum episode duration in seconds."
},
"podcast_slug": {
"type": "string",
"description": "Podcast slug, internal ID, or numeric iTunes ID. Restrict to one podcast. A particle.pro or Radar show link also works."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"guest_capacity": {
"enum": [
"researcher",
"licensed_professional",
"practitioner",
"executive_founder",
"public_official",
"journalist_analyst",
"creator_entertainer",
"athlete_coach",
"clergy",
"firsthand",
"layperson"
],
"type": "string",
"description": "Only episodes with a guest who knows their field in this capacity (e.g. 'executive_founder' for founders). It narrows the other filters; particle_expertise_resolve names the capacity an everyday word means."
},
"guest_in_field": {
"type": "boolean",
"description": "Only episodes with a guest speaking within their own field (the guest the other guest_ filters select, when given)."
},
"guest_standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Only episodes with a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'."
},
"has_transcript": {
"type": "boolean",
"description": "Only count episodes with a completed transcript."
},
"keyword_search": {
"type": "string",
"description": "Keyword filter over transcript content. Double-quoted substrings must appear as exact phrases; unquoted terms must all appear in one transcript segment. Adds per-bucket mention counts to the response. Cannot be combined with semantic_search."
},
"guest_seniority": {
"enum": [
"professional",
"senior",
"distinguished"
],
"type": "string",
"description": "Only episodes with a guest at this seniority or above."
},
"published_after": {
"type": "string",
"description": "Inclusive range start as an ISO 8601 date or date-time. Omit to aggregate all time."
},
"semantic_search": {
"type": "string",
"description": "Vector-similarity filter by meaning over transcript content — the counting twin of particle_podcast_search_transcripts' semantic_search, using the same similarity threshold. Describe the topic the way you'd say it to a colleague; paraphrase tolerant. Adds per-bucket mention counts to the response. Requires published_after (ranges up to ~2 years). Cannot be combined with keyword_search."
},
"guest_occupation": {
"type": "string",
"description": "Only episodes with a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). A word with no occupation filters by the field of research or capacity it names: 'oncologists' is field 3211, 'founders' is capacity executive_founder."
},
"guest_practicing": {
"type": "boolean",
"description": "Only episodes with a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group (e.g. '29-1212' or 'physicians')."
},
"published_before": {
"type": "string",
"description": "Range end as an ISO 8601 date or date-time. Defaults to now."
}
}
}| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"required": [
"guest_slug"
],
"properties": {
"include": {
"type": "array",
"items": {
"enum": [
"appearances",
"podcasts",
"suitability",
"recommended_podcasts",
"in_field_appearances"
],
"type": "string"
},
"description": "Optional response sections: 'appearances' (most recent episode appearances with episode/podcast slugs), 'podcasts' (per-podcast rollup of where they appear), 'suitability' (brand-suitability exposure across the podcasts they appear on), 'recommended_podcasts' (the five shows they could plausibly appear on next — shows related to the ones they have guested on, minus those, each with the venues that led there; the pitch list), 'in_field_appearances' (most recent appearances where they spoke within their own field of expertise). Default response is the profile + lifetime stats."
},
"guest_slug": {
"type": "string",
"description": "Person slug (e.g. 'sam-altman') from particle_podcast_list_guests, particle_person_resolve, or particle_entity_resolve."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| role | string | Constrain how the subject participates: guest, host, panelist, correspondent, or mention. |
| sort | string | compare only: 'mentions' (default, most current-window mention lines first), 'rising' or 'falling' (largest gain or loss from the previous window first), or 'popularity' (biggest shows first). |
| limit | integer | compare only: podcasts per page (1-50, default 10). |
| change | string | compare only: keep podcasts that are 'new' to the subject (current window only), 'continuing' (both windows) or 'dropped' (previous window only). |
| cursor | string | compare only: cursor from a previous response. Pass published_after and published_before as that response's window so the page lines up. |
| interval | string | Bucket width. timeseries: defaults to week. compare: adds each podcast's counts per bucket over the current window. |
| language | string | Only podcasts in this language: ISO 639-1 code (e.g. 'fr'), matched on the podcast's primary language subtag. |
| entity_slug | string | Knowledge-graph entity slug from particle_entity_resolve for anything that isn't a person or company (e.g. 'germany'). |
| guest_field | string | Only mentions spoken by a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve. |
| include_ads | boolean | Count mentions inside ad reads too. Off by default, so a brand that advertises heavily is measured by what shows say about it, not its own ads. |
| person_slug | string | Person slug from particle_person_resolve (e.g. 'sam-altman'). One of person_slug, company_slug or entity_slug is required. |
| company_slug | string | Company slug or domain from particle_company_resolve (e.g. 'nvidia'). Resolves to the company's linked entity. |
| podcast_slug | string | timeseries only: chart the mentions on one podcast (slug from particle_podcast_resolve). In compare mode the rows are the podcasts. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| guest_capacity | string | Only mentions spoken by a guest who knows their field in this capacity (e.g. 'public_official' for politicians). particle_expertise_resolve names the capacity an everyday word means. |
| guest_in_field | boolean | Only mentions spoken by a guest speaking within their own field (the guest the other guest_ filters select, when given). |
| guest_standing | string | Only mentions spoken by a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'. |
| publisher_slug | string | Only mentions on podcasts of this publisher (network), by slug. |
| guest_seniority | string | Only mentions spoken by a guest at this seniority or above. |
| published_after | string | compare: start of the current window (ISO 8601 date or date-time); defaults to 7 days before published_before, and the window may span at most 90 days. timeseries: start of the range; omit to chart all time. |
| guest_occupation | string | Only mentions spoken by a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'financial-and-investment-analysts' or 'physicians'). A word with no occupation filters by the field of research or capacity it names: 'investors' is field 350208, 'politicians' is capacity public_official. |
| guest_practicing | boolean | Only mentions spoken by a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group. |
| published_before | string | End of the current window or range: a bare date includes that whole UTC day. Defaults to now. |
{
"type": "object",
"properties": {
"mode": {
"enum": [
"compare",
"timeseries"
],
"type": "string",
"description": "'compare' (default): which podcasts mentioned the subject in the window and how each compares with the equal-length window before it, with both windows' totals. 'timeseries': mention counts per day, week or month over a range, with the podcasts carrying them per bucket."
},
"role": {
"enum": [
"guest",
"host",
"panelist",
"correspondent",
"mention"
],
"type": "string",
"description": "Constrain how the subject participates: guest, host, panelist, correspondent, or mention."
},
"sort": {
"enum": [
"mentions",
"rising",
"falling",
"popularity"
],
"type": "string",
"description": "compare only: 'mentions' (default, most current-window mention lines first), 'rising' or 'falling' (largest gain or loss from the previous window first), or 'popularity' (biggest shows first)."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "compare only: podcasts per page (1-50, default 10)."
},
"change": {
"enum": [
"new",
"continuing",
"dropped"
],
"type": "string",
"description": "compare only: keep podcasts that are 'new' to the subject (current window only), 'continuing' (both windows) or 'dropped' (previous window only)."
},
"cursor": {
"type": "string",
"description": "compare only: cursor from a previous response. Pass published_after and published_before as that response's window so the page lines up."
},
"interval": {
"enum": [
"day",
"week",
"month"
],
"type": "string",
"description": "Bucket width. timeseries: defaults to week. compare: adds each podcast's counts per bucket over the current window."
},
"language": {
"type": "string",
"description": "Only podcasts in this language: ISO 639-1 code (e.g. 'fr'), matched on the podcast's primary language subtag."
},
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug from particle_entity_resolve for anything that isn't a person or company (e.g. 'germany')."
},
"guest_field": {
"type": "string",
"description": "Only mentions spoken by a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve."
},
"include_ads": {
"type": "boolean",
"description": "Count mentions inside ad reads too. Off by default, so a brand that advertises heavily is measured by what shows say about it, not its own ads."
},
"person_slug": {
"type": "string",
"description": "Person slug from particle_person_resolve (e.g. 'sam-altman'). One of person_slug, company_slug or entity_slug is required."
},
"company_slug": {
"type": "string",
"description": "Company slug or domain from particle_company_resolve (e.g. 'nvidia'). Resolves to the company's linked entity."
},
"podcast_slug": {
"type": "string",
"description": "timeseries only: chart the mentions on one podcast (slug from particle_podcast_resolve). In compare mode the rows are the podcasts."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"guest_capacity": {
"enum": [
"researcher",
"licensed_professional",
"practitioner",
"executive_founder",
"public_official",
"journalist_analyst",
"creator_entertainer",
"athlete_coach",
"clergy",
"firsthand",
"layperson"
],
"type": "string",
"description": "Only mentions spoken by a guest who knows their field in this capacity (e.g. 'public_official' for politicians). particle_expertise_resolve names the capacity an everyday word means."
},
"guest_in_field": {
"type": "boolean",
"description": "Only mentions spoken by a guest speaking within their own field (the guest the other guest_ filters select, when given)."
},
"guest_standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Only mentions spoken by a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'."
},
"publisher_slug": {
"type": "string",
"description": "Only mentions on podcasts of this publisher (network), by slug."
},
"guest_seniority": {
"enum": [
"professional",
"senior",
"distinguished"
],
"type": "string",
"description": "Only mentions spoken by a guest at this seniority or above."
},
"published_after": {
"type": "string",
"description": "compare: start of the current window (ISO 8601 date or date-time); defaults to 7 days before published_before, and the window may span at most 90 days. timeseries: start of the range; omit to chart all time."
},
"guest_occupation": {
"type": "string",
"description": "Only mentions spoken by a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'financial-and-investment-analysts' or 'physicians'). A word with no occupation filters by the field of research or capacity it names: 'investors' is field 350208, 'politicians' is capacity public_official."
},
"guest_practicing": {
"type": "boolean",
"description": "Only mentions spoken by a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group."
},
"published_before": {
"type": "string",
"description": "End of the current window or range: a bare date includes that whole UTC day. Defaults to now."
}
}
}| Mode=history only: only snapshots captured on or before this ISO 8601 timestamp. |
| change | string | Mode=movers only: filter by change type. Defaults to all. |
| cursor | string | Opaque pagination cursor from a previous response. |
| source | string | Ranking source platform. Defaults to apple. |
| country | string | ISO 3166-1 alpha-2 country code (e.g. 'us', 'gb', 'jp'). Defaults to us. |
| window_days | integer | Mode=movers only: comparison window in days (1-30, default 1 = vs. yesterday). |
| podcast_slug | string | Podcast slug, internal ID, or numeric iTunes ID. With mode=chart: that podcast's current chart appearances across every slot. With mode=history: that podcast's chart history. A particle.pro or Radar show link also works. |
| category_slug | string | Category slug (e.g. 'comedy', 'business'). Omit for the overall chart. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"mode": {
"enum": [
"chart",
"movers",
"history",
"slots"
],
"type": "string",
"description": "What to return. 'chart' (default): the current chart — or, with podcast_slug, every chart slot the podcast currently holds. 'movers': biggest rank changes over window_days (risers, fallers, debuts, exits). 'history': past chart snapshots for a slot — or, with podcast_slug, one podcast's chart history. 'slots': the valid chart-slot values — every source, country, and category_slug with live data — for discovering filter values before a chart/movers/history call."
},
"limit": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Rows per page (1-100, default 25)."
},
"since": {
"type": "string",
"description": "Mode=history only: only snapshots captured on or after this ISO 8601 timestamp."
},
"until": {
"type": "string",
"description": "Mode=history only: only snapshots captured on or before this ISO 8601 timestamp."
},
"change": {
"enum": [
"all",
"up",
"down",
"new",
"exit"
],
"type": "string",
"description": "Mode=movers only: filter by change type. Defaults to all."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"source": {
"enum": [
"apple",
"spotify"
],
"type": "string",
"description": "Ranking source platform. Defaults to apple."
},
"country": {
"type": "string",
"description": "ISO 3166-1 alpha-2 country code (e.g. 'us', 'gb', 'jp'). Defaults to us."
},
"window_days": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "Mode=movers only: comparison window in days (1-30, default 1 = vs. yesterday)."
},
"podcast_slug": {
"type": "string",
"description": "Podcast slug, internal ID, or numeric iTunes ID. With mode=chart: that podcast's current chart appearances across every slot. With mode=history: that podcast's chart history. A particle.pro or Radar show link also works."
},
"category_slug": {
"type": "string",
"description": "Category slug (e.g. 'comedy', 'business'). Omit for the overall chart."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}| level |
| string |
| Group level: 'major' (default; SOC major groups or ANZSRC divisions) or 'detailed' (detailed occupations or ANZSRC groups). |
| limit | integer | Groups to return, most mentioned first (1-50, default 10). |
| interval | string | Add each group's mentions per day, week or month. |
| speakers | string | Whose lines count: 'all' (default, hosts included) or 'guests' (guests and panelists only). |
| entity_slug | string | Knowledge-graph entity slug from particle_entity_resolve for anything that isn't a person or company (e.g. 'germany'). |
| include_ads | boolean | Count mentions inside ad reads too. Off by default: ad copy is not a speaker's voice. |
| person_slug | string | Person slug from particle_person_resolve (e.g. 'sam-altman'). One of person_slug, company_slug, entity_slug or keyword_search is required. |
| company_slug | string | Company slug or domain from particle_company_resolve (e.g. 'nvidia'). Resolves to the company's linked entity. |
| podcast_slug | string | Only mentions inside this podcast (slug from particle_podcast_resolve). |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| keyword_search | string | Split the lines that say these words instead of an entity's mentions: every word in one line, case-insensitive; wrap words in double quotes to require them adjacent and in order. Words count as spoken, so a word with two meanings counts both. Window at most 90 days. |
| publisher_slug | string | Only mentions on podcasts of this publisher (network), by slug. |
| published_after | string | Only episodes published on or after this date (YYYY-MM-DD). Defaults to 30 days before published_before; the window may span at most 365 days for an entity and 90 for a keyword. |
| published_before | string | Only episodes published on or before this date (YYYY-MM-DD). Defaults to now. |
{
"type": "object",
"properties": {
"by": {
"enum": [
"occupation",
"field"
],
"type": "string",
"description": "Group the speakers by 'occupation' (SOC 2018, default) or 'field' (ANZSRC 2020 fields of research)."
},
"level": {
"enum": [
"major",
"detailed"
],
"type": "string",
"description": "Group level: 'major' (default; SOC major groups or ANZSRC divisions) or 'detailed' (detailed occupations or ANZSRC groups)."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Groups to return, most mentioned first (1-50, default 10)."
},
"interval": {
"enum": [
"day",
"week",
"month"
],
"type": "string",
"description": "Add each group's mentions per day, week or month."
},
"speakers": {
"enum": [
"all",
"guests"
],
"type": "string",
"description": "Whose lines count: 'all' (default, hosts included) or 'guests' (guests and panelists only)."
},
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug from particle_entity_resolve for anything that isn't a person or company (e.g. 'germany')."
},
"include_ads": {
"type": "boolean",
"description": "Count mentions inside ad reads too. Off by default: ad copy is not a speaker's voice."
},
"person_slug": {
"type": "string",
"description": "Person slug from particle_person_resolve (e.g. 'sam-altman'). One of person_slug, company_slug, entity_slug or keyword_search is required."
},
"company_slug": {
"type": "string",
"description": "Company slug or domain from particle_company_resolve (e.g. 'nvidia'). Resolves to the company's linked entity."
},
"podcast_slug": {
"type": "string",
"description": "Only mentions inside this podcast (slug from particle_podcast_resolve)."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"keyword_search": {
"type": "string",
"maxLength": 500,
"description": "Split the lines that say these words instead of an entity's mentions: every word in one line, case-insensitive; wrap words in double quotes to require them adjacent and in order. Words count as spoken, so a word with two meanings counts both. Window at most 90 days."
},
"publisher_slug": {
"type": "string",
"description": "Only mentions on podcasts of this publisher (network), by slug."
},
"published_after": {
"type": "string",
"description": "Only episodes published on or after this date (YYYY-MM-DD). Defaults to 30 days before published_before; the window may span at most 365 days for an entity and 90 for a keyword."
},
"published_before": {
"type": "string",
"description": "Only episodes published on or before this date (YYYY-MM-DD). Defaults to now."
}
}
}| episode_slug | string | Restrict the listing to one episode (slug or ID). A particle.pro or Radar episode link also works. |
| podcast_slug | string | Restrict the listing to one podcast (slug, internal ID, or numeric iTunes ID). A particle.pro or Radar show link also works. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| min_engagement | integer | Minimum engagement potential score (0-100). Above 70 is typical for a strong clip. |
{
"type": "object",
"properties": {
"type": {
"enum": [
"SPICY",
"CONTROVERSIAL",
"EMOTIONAL",
"FUNNY",
"SHOCKING",
"INSIGHTFUL",
"INFORMATIVE",
"EDUCATIONAL",
"PHILOSOPHICAL",
"AHA_MOMENT",
"NOTABLE_LINE",
"BEST_STORY",
"DEBATE_DISAGREEMENT"
],
"type": "string",
"description": "Clip type filter."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Clips per page (1-50, default 10)."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"clip_id": {
"type": "string",
"description": "Return one clip's full detail instead of a listing. Clip IDs come from this tool, particle_podcast_get_episode with include=clips, and search-result overlapping clips."
},
"include": {
"type": "array",
"items": {
"enum": [
"transcript"
],
"type": "string"
},
"description": "With clip_id only: 'transcript' attaches the clip's dialogue transcript."
},
"speaker": {
"type": "string",
"description": "Restrict the listing to clips whose primary speaker is this person — a person slug (e.g. 'sam-altman' from particle_person_resolve), a knowledge-graph entity slug for the same person, or an ID."
},
"episode_slug": {
"type": "string",
"description": "Restrict the listing to one episode (slug or ID). A particle.pro or Radar episode link also works."
},
"podcast_slug": {
"type": "string",
"description": "Restrict the listing to one podcast (slug, internal ID, or numeric iTunes ID). A particle.pro or Radar show link also works."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"min_engagement": {
"type": "integer",
"maximum": 100,
"minimum": 0,
"description": "Minimum engagement potential score (0-100). Above 70 is typical for a strong clip."
}
}
}| string |
| Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company — places, organizations, events, products, concepts (e.g. 'germany'). Use person_slug for people and company_slug for companies. |
| guest_field | string | Only episodes with a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). |
| person_slug | string | Person slug or encoded person ID from particle_person_resolve, particle_entity_resolve, or the guest tools (e.g. 'sam-altman'). Episodes featuring or mentioning the person. |
| company_slug | string | Company slug, domain, or ID. Resolves to the linked entity. |
| max_duration | integer | Maximum episode duration in seconds. |
| min_duration | integer | Minimum episode duration in seconds. |
| podcast_slug | string | Podcast slug, internal ID, or numeric iTunes ID. Restrict to one podcast. A particle.pro or Radar show link also works. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| guest_capacity | string | Only episodes with a guest who knows their field in this capacity (e.g. 'executive_founder' for founders). It narrows the other filters; particle_expertise_resolve names the capacity an everyday word means. |
| guest_in_field | boolean | Only episodes with a guest speaking within their own field (the guest the other guest_ filters select, when given). |
| guest_standing | string | Only episodes with a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'. |
| has_transcript | boolean | Only include episodes with a completed transcript. Superseded by transcript_status=transcribed; do not pass both. |
| guest_seniority | string | Only episodes with a guest at this seniority or above. |
| published_after | string | ISO 8601 date or date-time. |
| guest_occupation | string | Only episodes with a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). A word with no occupation filters by the field of research or capacity it names: 'oncologists' is field 3211, 'founders' is capacity executive_founder. |
| guest_practicing | boolean | Only episodes with a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group (e.g. '29-1212' or 'physicians'). |
| published_before | string | ISO 8601 date or date-time. |
| transcript_status | string | Filter by where episodes stand on the way to a transcript. Omitted lists the episodes we have ingested. any, untranscribed and requestable also list the podcast's back catalogue — episodes discovered in its feed but not transcribed — and require podcast_slug: any lists every discovered episode, untranscribed those without a transcript, requestable back-catalogue episodes whose transcript can be requested. transcribed lists episodes with a transcript. |
{
"type": "object",
"properties": {
"role": {
"enum": [
"guest",
"host",
"panelist",
"correspondent",
"mention"
],
"type": "string",
"description": "Role filter when person_slug or company_slug is set."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Episodes per page (1-50, default 10)."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"language": {
"type": "string",
"description": "Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'."
},
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company — places, organizations, events, products, concepts (e.g. 'germany'). Use person_slug for people and company_slug for companies."
},
"guest_field": {
"type": "string",
"description": "Only episodes with a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment')."
},
"person_slug": {
"type": "string",
"description": "Person slug or encoded person ID from particle_person_resolve, particle_entity_resolve, or the guest tools (e.g. 'sam-altman'). Episodes featuring or mentioning the person."
},
"company_slug": {
"type": "string",
"description": "Company slug, domain, or ID. Resolves to the linked entity."
},
"max_duration": {
"type": "integer",
"minimum": 0,
"description": "Maximum episode duration in seconds."
},
"min_duration": {
"type": "integer",
"minimum": 0,
"description": "Minimum episode duration in seconds."
},
"podcast_slug": {
"type": "string",
"description": "Podcast slug, internal ID, or numeric iTunes ID. Restrict to one podcast. A particle.pro or Radar show link also works."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"guest_capacity": {
"enum": [
"researcher",
"licensed_professional",
"practitioner",
"executive_founder",
"public_official",
"journalist_analyst",
"creator_entertainer",
"athlete_coach",
"clergy",
"firsthand",
"layperson"
],
"type": "string",
"description": "Only episodes with a guest who knows their field in this capacity (e.g. 'executive_founder' for founders). It narrows the other filters; particle_expertise_resolve names the capacity an everyday word means."
},
"guest_in_field": {
"type": "boolean",
"description": "Only episodes with a guest speaking within their own field (the guest the other guest_ filters select, when given)."
},
"guest_standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Only episodes with a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'."
},
"has_transcript": {
"type": "boolean",
"description": "Only include episodes with a completed transcript. Superseded by transcript_status=transcribed; do not pass both."
},
"guest_seniority": {
"enum": [
"professional",
"senior",
"distinguished"
],
"type": "string",
"description": "Only episodes with a guest at this seniority or above."
},
"published_after": {
"type": "string",
"description": "ISO 8601 date or date-time."
},
"guest_occupation": {
"type": "string",
"description": "Only episodes with a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). A word with no occupation filters by the field of research or capacity it names: 'oncologists' is field 3211, 'founders' is capacity executive_founder."
},
"guest_practicing": {
"type": "boolean",
"description": "Only episodes with a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group (e.g. '29-1212' or 'physicians')."
},
"published_before": {
"type": "string",
"description": "ISO 8601 date or date-time."
},
"transcript_status": {
"enum": [
"any",
"transcribed",
"untranscribed",
"requestable"
],
"type": "string",
"description": "Filter by where episodes stand on the way to a transcript. Omitted lists the episodes we have ingested. any, untranscribed and requestable also list the podcast's back catalogue — episodes discovered in its feed but not transcribed — and require podcast_slug: any lists every discovered episode, untranscribed those without a transcript, requestable back-catalogue episodes whose transcript can be requested. transcribed lists episodes with a transcript."
}
}
}| limit | integer | Guests per page (1-50, default 20). |
| cursor | string | Opaque pagination cursor from a previous response. |
| include | array | Optional per-guest sections: 'expertise' (widens the occupation codes, standing and seniority every row carries to the fuller one-line read with the organization). Directory mode only. |
| capacity | string | Only guests who know their field in this capacity. Directory mode only. |
| employer | string | Only guests whose organization is this company (slug from particle_company_resolve, or a domain). Directory mode only. |
| standing | string | Only guests whose standing is recognized this way: 'established' (conferred by others: a credential, a position, recognition in the field), 'self_described', or 'unverified'. Directory mode only. |
| seniority | string | Only guests at this seniority or above. Directory mode only. |
| occupation | string | Only guests listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). Directory mode only. |
| practicing | boolean | Only guests who still work in the occupation. Needs a SOC 2018 occupation or group (e.g. '29-1212' Cardiologists or 'physicians'). Directory mode only. |
| topic_slug | string | Restrict to guests with appearances on episodes classified under this topic (slug from particle_topic_browse, e.g. 'technology/artificial-intelligence'). Ignored when podcast_slug is set. |
| podcast_slug | string | Return one show's guest roster instead of the corpus directory: every guest who has appeared on this podcast, ranked by appearances on the show (no lifetime-appearance floor). Slug from particle_podcast_resolve. Only valid with the default directory mode. A particle.pro or Radar show link also works. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| appeared_since | string | Only guests with an appearance on or after this date (YYYY-MM-DD or ISO 8601). Directory mode only. |
{
"type": "object",
"properties": {
"mode": {
"enum": [
"directory",
"trends"
],
"type": "string",
"description": "What to return. 'directory' (default): the guest directory ranked by lifetime appearances. 'trends': guests trending right now — appearances on 2+ distinct podcasts in the last 30 days (cross-show press tours, not regulars)."
},
"field": {
"type": "string",
"description": "Only guests listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). Directory mode only."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Guests per page (1-50, default 20)."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"include": {
"type": "array",
"items": {
"enum": [
"expertise"
],
"type": "string"
},
"description": "Optional per-guest sections: 'expertise' (widens the occupation codes, standing and seniority every row carries to the fuller one-line read with the organization). Directory mode only."
},
"capacity": {
"enum": [
"researcher",
"licensed_professional",
"practitioner",
"executive_founder",
"public_official",
"journalist_analyst",
"creator_entertainer",
"athlete_coach",
"clergy",
"firsthand",
"layperson"
],
"type": "string",
"description": "Only guests who know their field in this capacity. Directory mode only."
},
"employer": {
"type": "string",
"description": "Only guests whose organization is this company (slug from particle_company_resolve, or a domain). Directory mode only."
},
"standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Only guests whose standing is recognized this way: 'established' (conferred by others: a credential, a position, recognition in the field), 'self_described', or 'unverified'. Directory mode only."
},
"seniority": {
"enum": [
"professional",
"senior",
"distinguished"
],
"type": "string",
"description": "Only guests at this seniority or above. Directory mode only."
},
"occupation": {
"type": "string",
"description": "Only guests listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). Directory mode only."
},
"practicing": {
"type": "boolean",
"description": "Only guests who still work in the occupation. Needs a SOC 2018 occupation or group (e.g. '29-1212' Cardiologists or 'physicians'). Directory mode only."
},
"topic_slug": {
"type": "string",
"description": "Restrict to guests with appearances on episodes classified under this topic (slug from particle_topic_browse, e.g. 'technology/artificial-intelligence'). Ignored when podcast_slug is set."
},
"podcast_slug": {
"type": "string",
"description": "Return one show's guest roster instead of the corpus directory: every guest who has appeared on this podcast, ranked by appearances on the show (no lifetime-appearance floor). Slug from particle_podcast_resolve. Only valid with the default directory mode. A particle.pro or Radar show link also works."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"appeared_since": {
"type": "string",
"description": "Only guests with an appearance on or after this date (YYYY-MM-DD or ISO 8601). Directory mode only."
}
}
}| Opaque pagination cursor from a previous response. |
| include | array | Optional response sections. 'basis' attaches, per result, the signals that make the two shows related: content similarity of recent episodes, shared topics, shared guests (named), same publisher, shared sponsors. Off by default; opt in when you need to explain or filter by the reason. |
| language | string | Only shows in this language: an ISO 639-1 code such as 'en' or 'es'. |
| min_score | number | Drop results below this fused score (0-1]. Prefer branching on each result's band (strong / moderate / weak); score thresholds may be recalibrated as the ranker improves. |
| podcast_slug | string | The source podcast — slug (e.g. 'all-in' from particle_podcast_resolve), internal ID, or numeric iTunes ID. A particle.pro or Radar show link also works. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| min_popularity | number | Only shows at or above this popularity percentile (0-1]. A floor above 0 excludes non-charting shows; 0 applies no floor. |
| suitability_tier | string | Only shows whose latest brand-suitability tier is this value; never-assessed shows are excluded. |
| publishing_status | string | Only shows that released an episode in the last 90 days ('active') or did not ('dormant'); shows with no known episode date match neither. |
| exclude_same_publisher | boolean | Drop shows from the source show's own publisher. |
{
"type": "object",
"properties": {
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Results per page (1-50, default 10)."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"include": {
"type": "array",
"items": {
"enum": [
"basis"
],
"type": "string"
},
"description": "Optional response sections. 'basis' attaches, per result, the signals that make the two shows related: content similarity of recent episodes, shared topics, shared guests (named), same publisher, shared sponsors. Off by default; opt in when you need to explain or filter by the reason."
},
"language": {
"type": "string",
"description": "Only shows in this language: an ISO 639-1 code such as 'en' or 'es'."
},
"min_score": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Drop results below this fused score (0-1]. Prefer branching on each result's band (strong / moderate / weak); score thresholds may be recalibrated as the ranker improves."
},
"podcast_slug": {
"type": "string",
"description": "The source podcast — slug (e.g. 'all-in' from particle_podcast_resolve), internal ID, or numeric iTunes ID. A particle.pro or Radar show link also works."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"min_popularity": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Only shows at or above this popularity percentile (0-1]. A floor above 0 excludes non-charting shows; 0 applies no floor."
},
"suitability_tier": {
"enum": [
"SAFE",
"LIMITED",
"SENSITIVE",
"UNSAFE"
],
"type": "string",
"description": "Only shows whose latest brand-suitability tier is this value; never-assessed shows are excluded."
},
"publishing_status": {
"enum": [
"active",
"dormant"
],
"type": "string",
"description": "Only shows that released an episode in the last 90 days ('active') or did not ('dormant'); shows with no known episode date match neither."
},
"exclude_same_publisher": {
"type": "boolean",
"description": "Drop shows from the source show's own publisher."
}
}
}| same_podcast | boolean | Admit episodes of the same show. Off by default — a show's own episodes are its episode list (particle_podcast_list_episodes), not its related content. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| published_within_days | integer | Only episodes published within this many days of the query episode, on either side. Omit for no window. Use 7–30 for 'who else covered this story'. |
{
"type": "object",
"required": [
"episode_slug"
],
"properties": {
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Results per page (1-50, default 10)."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"include": {
"type": "array",
"items": {
"enum": [
"basis"
],
"type": "string"
},
"description": "'basis' attaches, per result, the signals behind the match: content similarity, shared entities with names, shared topics, a shared news story, shared guests, days apart."
},
"episode_slug": {
"type": "string",
"description": "Episode slug or ID (from particle_podcast_list_episodes, particle_podcast_get_episode, or a search result). A particle.pro or Radar episode link also works."
},
"same_podcast": {
"type": "boolean",
"description": "Admit episodes of the same show. Off by default — a show's own episodes are its episode list (particle_podcast_list_episodes), not its related content."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"published_within_days": {
"type": "integer",
"maximum": 3650,
"minimum": 0,
"description": "Only episodes published within this many days of the query episode, on either side. Omit for no window. Use 7–30 for 'who else covered this story'."
}
}
}| Argument | Type | Description |
|---|---|---|
| slug | string | Exact slug match for a known handle (e.g. 'all-in'). |
| limit | integer | Maximum candidates to return (1-25, default 5). |
| query | string | Free-text search across podcast titles and descriptions (case-insensitive partial match). Omit to fall back to the most recently updated podcasts. |
| include | array | Optional non-parameterized hydrations to attach to each result. 'external_links' adds third-party platform presences (directories, social profiles, video channels, publisher websites). 'suitability' adds the per-category brand-suitability breakdown (premium-grade data — requires a plan with premium endpoints). 'ratings_summary' adds the listener-review aggregate. 'bias' adds the full political-bias analysis. 'rankings' adds current chart positions (premium-grade data — requires a plan with premium endpoints). 'format' adds the format profile (guest frequency, interview/panel/call-in/solo formats, ads, video, episode length, cadence, publish days). 'related' adds the five most related shows (slug, score, band) — for the full ranked list with the basis behind each pair call particle_podcast_list_related. 'recommended_guests' adds the five guests the show could book next — people who have guested on its related shows but never on it (person slug, score, band, and the related shows that booked them); the booking pipeline. 'recommended_sponsors' adds the five advertisers the show could pitch — sponsors that run on its related shows but not on it (sponsor, linked company, score, band, ads and most recent ad across those shows, and which shows); the prospecting list (premium-grade data — requires a plan with premium endpoints). 'coverage' adds how much of the show's history we know of and have transcribed: discovered episodes by transcript status and by year, and whether its back catalogue (older episodes discovered in its feed but not transcribed) has been imported and is complete. 'guest_expertise' adds the show's guest mix: the shares of its analyzed guest appearances by established, senior or in-field guests and promotional appearances, and the occupations and fields it books most (codes the guest_ filters accept). The high-level suitability_tier and bias enums are always rendered without opt-in. Off by default; opt in only when needed. |
| rss_url | string | Canonical RSS feed URL. Resolves directly to the matching podcast. |
| itunes_id | string | Numeric Apple Podcasts / iTunes ID (e.g. '1502871393'). Resolves directly to the matching podcast. |
| topic_slug | string | Filter candidates by topic (slug from particle_topic_browse, e.g. 'technology/artificial-intelligence'). Matches podcasts where the topic — or any of its descendants — accounts for a meaningful share of episodes, ranked by concentration. |
| guest_field | string | Only shows whose analyzed guests include someone listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve. |
| min_popularity | number | Restrict candidates to podcasts whose global popularity percentile is at least this value (0-1]. Popularity is a cume_dist ranking over currently-charting podcasts; non-charting podcasts are excluded when set. Omit or 0 to disable. |
| recent_episodes | integer | Inline this many of each result's most recent episodes (slug, title, published_at, duration). 0 (default) means none — call particle_podcast_list_episodes if you need more than the inline tail. Capped at 25. |
| guest_occupation | string | Only shows whose analyzed guests include someone listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve. |
| suitability_tier | string | Filter candidates by brand-suitability tier. Podcasts without a suitability analysis are excluded when set. |
| min_in_field_guest_share | number | Only shows where at least this share (0-1) of analyzed guest appearances are guests speaking within their own field. |
| max_promotional_guest_share | number | Only shows where at most this share (0-1) of analyzed guest appearances are promotional; 0 keeps only shows with none. |
| min_established_guest_share | number | Only shows where at least this share (0-1) of analyzed guest appearances are by guests of established standing. |
{
"type": "object",
"properties": {
"slug": {
"type": "string",
"description": "Exact slug match for a known handle (e.g. 'all-in')."
},
"limit": {
"type": "integer",
"maximum": 25,
"minimum": 1,
"description": "Maximum candidates to return (1-25, default 5)."
},
"query": {
"type": "string",
"description": "Free-text search across podcast titles and descriptions (case-insensitive partial match). Omit to fall back to the most recently updated podcasts."
},
"include": {
"type": "array",
"items": {
"enum": [
"external_links",
"suitability",
"ratings_summary",
"bias",
"rankings",
"format",
"related",
"recommended_guests",
"recommended_sponsors",
"coverage",
"guest_expertise"
],
"type": "string"
},
"description": "Optional non-parameterized hydrations to attach to each result. 'external_links' adds third-party platform presences (directories, social profiles, video channels, publisher websites). 'suitability' adds the per-category brand-suitability breakdown (premium-grade data — requires a plan with premium endpoints). 'ratings_summary' adds the listener-review aggregate. 'bias' adds the full political-bias analysis. 'rankings' adds current chart positions (premium-grade data — requires a plan with premium endpoints). 'format' adds the format profile (guest frequency, interview/panel/call-in/solo formats, ads, video, episode length, cadence, publish days). 'related' adds the five most related shows (slug, score, band) — for the full ranked list with the basis behind each pair call particle_podcast_list_related. 'recommended_guests' adds the five guests the show could book next — people who have guested on its related shows but never on it (person slug, score, band, and the related shows that booked them); the booking pipeline. 'recommended_sponsors' adds the five advertisers the show could pitch — sponsors that run on its related shows but not on it (sponsor, linked company, score, band, ads and most recent ad across those shows, and which shows); the prospecting list (premium-grade data — requires a plan with premium endpoints). 'coverage' adds how much of the show's history we know of and have transcribed: discovered episodes by transcript status and by year, and whether its back catalogue (older episodes discovered in its feed but not transcribed) has been imported and is complete. 'guest_expertise' adds the show's guest mix: the shares of its analyzed guest appearances by established, senior or in-field guests and promotional appearances, and the occupations and fields it books most (codes the guest_ filters accept). The high-level suitability_tier and bias enums are always rendered without opt-in. Off by default; opt in only when needed."
},
"rss_url": {
"type": "string",
"description": "Canonical RSS feed URL. Resolves directly to the matching podcast."
},
"itunes_id": {
"type": "string",
"description": "Numeric Apple Podcasts / iTunes ID (e.g. '1502871393'). Resolves directly to the matching podcast."
},
"topic_slug": {
"type": "string",
"description": "Filter candidates by topic (slug from particle_topic_browse, e.g. 'technology/artificial-intelligence'). Matches podcasts where the topic — or any of its descendants — accounts for a meaningful share of episodes, ranked by concentration."
},
"guest_field": {
"type": "string",
"description": "Only shows whose analyzed guests include someone listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve."
},
"min_popularity": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Restrict candidates to podcasts whose global popularity percentile is at least this value (0-1]. Popularity is a cume_dist ranking over currently-charting podcasts; non-charting podcasts are excluded when set. Omit or 0 to disable."
},
"recent_episodes": {
"type": "integer",
"maximum": 25,
"minimum": 0,
"description": "Inline this many of each result's most recent episodes (slug, title, published_at, duration). 0 (default) means none — call particle_podcast_list_episodes if you need more than the inline tail. Capped at 25."
},
"guest_occupation": {
"type": "string",
"description": "Only shows whose analyzed guests include someone listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve."
},
"suitability_tier": {
"enum": [
"SAFE",
"LIMITED",
"SENSITIVE",
"UNSAFE"
],
"type": "string",
"description": "Filter candidates by brand-suitability tier. Podcasts without a suitability analysis are excluded when set."
},
"min_in_field_guest_share": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Only shows where at least this share (0-1) of analyzed guest appearances are guests speaking within their own field."
},
"max_promotional_guest_share": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Only shows where at most this share (0-1) of analyzed guest appearances are promotional; 0 keeps only shows with none."
},
"min_established_guest_share": {
"type": "number",
"maximum": 1,
"minimum": 0,
"description": "Only shows where at least this share (0-1) of analyzed guest appearances are by guests of established standing."
}
}
}| Argument | Type | Description |
|---|---|---|
| role | string | How the entity must relate to the episode. Speaking roles: 'guest', 'host', 'panelist', 'correspondent', or 'speaker' for any of them. 'mention' means the entity is talked about rather than speaking. Omit to match both — usually what you want. |
| sort | string | Sort order. Defaults to relevance. |
| limit | integer | Results per page (1-50, default 10). |
| since | string | Only segments from episodes published on or after this ISO 8601 date. |
| until | string | Only segments from episodes published on or before this ISO 8601 date. |
| cursor | string | Opaque pagination cursor from a previous response. |
| format | string | Response shape. 'full' (default) carries each match's bounded dialogue windows and overlapping clips. 'compact' returns the same ranked matches with no dialogue — episode and podcast slugs, segment id and bounds, segment type, the segment's one-line description, and the relevance score — at a fraction of the size and latency, because the transcript load and line scoring are skipped. Use it to screen many results (a fan-out over companies, themes, or dates) and read dialogue only for the survivors. |
| context | integer | Lines of surrounding dialogue around each matched line (1-15, default 1). Widens each match window in place — use a larger value instead of fetching the full transcript when a match needs more context. Ignored when format is compact. |
| speaker | string | Person slug or ID from particle_person_resolve (e.g. 'sam-altman'). Keeps only passages in which this person speaks a line, and only their lines can match: 'did X say Y', where person_slug is 'Y came up in an episode with X'. With keyword_search their own lines must carry every quoted phrase (and every unquoted word under keyword_match=required). A clip of them played on another show does not count, so this finds the original rather than its replays. An empty result does not prove they never said it: narrow with podcast_slug, episode_slug or dates, or try semantic_search. Cannot be combined with the guest_ filters. |
| language | string | Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'. |
| entity_slug | string | Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company — places, organizations, events, products, concepts (e.g. 'germany'). Use person_slug for people and company_slug for companies. |
| entity_type | string | Narrow to dialogue in episodes that mention any entity of this category — e.g. 'book', 'company', 'movie', 'school'. Use for 'discussions of X that reference some book'. Ignored when person_slug/company_slug/entity_slug names a specific entity, which is strictly narrower. Categories come from particle_catalog. |
| guest_field | string | Only episodes with a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment'). |
| person_slug | string | Person slug or encoded person ID from particle_person_resolve, particle_entity_resolve, or the guest tools (e.g. 'sam-altman'). Filters results to dialogue featuring this person. For 'every line about X' use particle_podcast_find_mentions instead. |
| company_slug | string | Company slug, domain, or ID. Resolves to the company's linked entity and applies as a filter. |
| episode_slug | string | Filter to a specific episode by slug or ID. A particle.pro or Radar episode link also works. |
| podcast_slug | string | Podcast slug, internal ID, or numeric iTunes ID. A particle.pro or Radar show link also works. |
| segment_type | string | Segment type filter. |
| keyword_match | string | How UNQUOTED keyword_search words are applied. 'required' (default) excludes any passage missing one of them, which also makes a hybrid call an intersection with semantic_search. Switch to 'ranked' when keyword_search is a loose bag of related words that will not co-occur — then those words only steer relevance. Quoted phrases still filter in both modes: to relax a phrase, remove its quotes rather than switching mode. |
| output_format | string | Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
| guest_capacity | string | Only episodes with a guest who knows their field in this capacity (e.g. 'executive_founder' for founders). It narrows the other filters; particle_expertise_resolve names the capacity an everyday word means. |
| guest_in_field | boolean | Only episodes with a guest speaking within their own field (the guest the other guest_ filters select, when given). |
| guest_standing | string | Only episodes with a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'. |
| keyword_search | string | Words that must literally be spoken. Use for exact tokens a paraphrase would miss — tickers, product names, drug names, model numbers. Every word must appear in the same passage (see keyword_match), so keep it to the one or two words that must be said and put the rest of the idea in semantic_search. Wrap words in double quotes to also require them adjacent and in order in the segment's spoken dialogue — only for short exact strings, never for a sentence. A quoted name matches segments where the name appears in the dialogue, not segments that person speaks in; use person_slug or particle_podcast_find_mentions for a person's appearances. There is no boolean OR: 'a OR b' requires the literal word 'OR', so issue one call per alternative. |
| guest_seniority | string | Only episodes with a guest at this seniority or above. |
| semantic_search | string | Vector-similarity search by meaning. Express the query the way you'd describe the topic to a colleague — paraphrase tolerant. Combine with keyword_search for hybrid ranking. Describe a topic, not a name: to find a specific person/company/entity, filter with person_slug / company_slug / entity_slug (or use particle_podcast_find_mentions for every line about them) — and for an exact token like a ticker, use keyword_search. |
| guest_occupation | string | Only episodes with a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). A word with no occupation filters by the field of research or capacity it names: 'oncologists' is field 3211, 'founders' is capacity executive_founder. |
| guest_practicing | boolean | Only episodes with a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group (e.g. '29-1212' or 'physicians'). |
{
"type": "object",
"properties": {
"role": {
"enum": [
"guest",
"host",
"panelist",
"correspondent",
"speaker",
"mention"
],
"type": "string",
"description": "How the entity must relate to the episode. Speaking roles: 'guest', 'host', 'panelist', 'correspondent', or 'speaker' for any of them. 'mention' means the entity is talked about rather than speaking. Omit to match both — usually what you want."
},
"sort": {
"enum": [
"relevance",
"recency"
],
"type": "string",
"description": "Sort order. Defaults to relevance."
},
"limit": {
"type": "integer",
"maximum": 50,
"minimum": 1,
"description": "Results per page (1-50, default 10)."
},
"since": {
"type": "string",
"description": "Only segments from episodes published on or after this ISO 8601 date."
},
"until": {
"type": "string",
"description": "Only segments from episodes published on or before this ISO 8601 date."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"format": {
"enum": [
"full",
"compact"
],
"type": "string",
"description": "Response shape. 'full' (default) carries each match's bounded dialogue windows and overlapping clips. 'compact' returns the same ranked matches with no dialogue — episode and podcast slugs, segment id and bounds, segment type, the segment's one-line description, and the relevance score — at a fraction of the size and latency, because the transcript load and line scoring are skipped. Use it to screen many results (a fan-out over companies, themes, or dates) and read dialogue only for the survivors."
},
"context": {
"type": "integer",
"maximum": 15,
"minimum": 1,
"description": "Lines of surrounding dialogue around each matched line (1-15, default 1). Widens each match window in place — use a larger value instead of fetching the full transcript when a match needs more context. Ignored when format is compact."
},
"speaker": {
"type": "string",
"description": "Person slug or ID from particle_person_resolve (e.g. 'sam-altman'). Keeps only passages in which this person speaks a line, and only their lines can match: 'did X say Y', where person_slug is 'Y came up in an episode with X'. With keyword_search their own lines must carry every quoted phrase (and every unquoted word under keyword_match=required). A clip of them played on another show does not count, so this finds the original rather than its replays. An empty result does not prove they never said it: narrow with podcast_slug, episode_slug or dates, or try semantic_search. Cannot be combined with the guest_ filters."
},
"language": {
"type": "string",
"description": "Restrict to episodes of podcasts in this language — ISO 639-1 code (e.g. 'fr'). Matches the podcast's primary language subtag, so 'fr' covers 'fr-FR'."
},
"entity_slug": {
"type": "string",
"description": "Knowledge-graph entity slug from particle_entity_resolve for the long tail that isn't a person or company — places, organizations, events, products, concepts (e.g. 'germany'). Use person_slug for people and company_slug for companies."
},
"entity_type": {
"type": "string",
"description": "Narrow to dialogue in episodes that mention any entity of this category — e.g. 'book', 'company', 'movie', 'school'. Use for 'discussions of X that reference some book'. Ignored when person_slug/company_slug/entity_slug names a specific entity, which is strictly narrower. Categories come from particle_catalog."
},
"guest_field": {
"type": "string",
"description": "Only episodes with a guest listed under this ANZSRC 2020 field of research: a code, slug or title from particle_expertise_resolve (e.g. 'banking-finance-and-investment')."
},
"person_slug": {
"type": "string",
"description": "Person slug or encoded person ID from particle_person_resolve, particle_entity_resolve, or the guest tools (e.g. 'sam-altman'). Filters results to dialogue featuring this person. For 'every line about X' use particle_podcast_find_mentions instead."
},
"company_slug": {
"type": "string",
"description": "Company slug, domain, or ID. Resolves to the company's linked entity and applies as a filter."
},
"episode_slug": {
"type": "string",
"description": "Filter to a specific episode by slug or ID. A particle.pro or Radar episode link also works."
},
"podcast_slug": {
"type": "string",
"description": "Podcast slug, internal ID, or numeric iTunes ID. A particle.pro or Radar show link also works."
},
"segment_type": {
"enum": [
"INTRO",
"PERSONAL_BANTER",
"TOPIC_DISCUSSION",
"INTERVIEW",
"TRANSITION",
"AD",
"OUTRO"
],
"type": "string",
"description": "Segment type filter."
},
"keyword_match": {
"enum": [
"required",
"ranked"
],
"type": "string",
"description": "How UNQUOTED keyword_search words are applied. 'required' (default) excludes any passage missing one of them, which also makes a hybrid call an intersection with semantic_search. Switch to 'ranked' when keyword_search is a loose bag of related words that will not co-occur — then those words only steer relevance. Quoted phrases still filter in both modes: to relax a phrase, remove its quotes rather than switching mode."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
},
"guest_capacity": {
"enum": [
"researcher",
"licensed_professional",
"practitioner",
"executive_founder",
"public_official",
"journalist_analyst",
"creator_entertainer",
"athlete_coach",
"clergy",
"firsthand",
"layperson"
],
"type": "string",
"description": "Only episodes with a guest who knows their field in this capacity (e.g. 'executive_founder' for founders). It narrows the other filters; particle_expertise_resolve names the capacity an everyday word means."
},
"guest_in_field": {
"type": "boolean",
"description": "Only episodes with a guest speaking within their own field (the guest the other guest_ filters select, when given)."
},
"guest_standing": {
"enum": [
"established",
"self_described",
"unverified"
],
"type": "string",
"description": "Only episodes with a guest whose standing is recognized this way: 'established' (conferred by others), 'self_described', or 'unverified'."
},
"keyword_search": {
"type": "string",
"maxLength": 500,
"description": "Words that must literally be spoken. Use for exact tokens a paraphrase would miss — tickers, product names, drug names, model numbers. Every word must appear in the same passage (see keyword_match), so keep it to the one or two words that must be said and put the rest of the idea in semantic_search. Wrap words in double quotes to also require them adjacent and in order in the segment's spoken dialogue — only for short exact strings, never for a sentence. A quoted name matches segments where the name appears in the dialogue, not segments that person speaks in; use person_slug or particle_podcast_find_mentions for a person's appearances. There is no boolean OR: 'a OR b' requires the literal word 'OR', so issue one call per alternative."
},
"guest_seniority": {
"enum": [
"professional",
"senior",
"distinguished"
],
"type": "string",
"description": "Only episodes with a guest at this seniority or above."
},
"semantic_search": {
"type": "string",
"maxLength": 500,
"description": "Vector-similarity search by meaning. Express the query the way you'd describe the topic to a colleague — paraphrase tolerant. Combine with keyword_search for hybrid ranking. Describe a topic, not a name: to find a specific person/company/entity, filter with person_slug / company_slug / entity_slug (or use particle_podcast_find_mentions for every line about them) — and for an exact token like a ticker, use keyword_search."
},
"guest_occupation": {
"type": "string",
"description": "Only episodes with a guest listed under this occupation: a SOC 2018 or ISCO-08 code, slug or title from particle_expertise_resolve, or a SOC group or everyday name (e.g. 'cardiologists', '29-1212', 'physicians' or 'doctors'). A word with no occupation filters by the field of research or capacity it names: 'oncologists' is field 3211, 'founders' is capacity executive_founder."
},
"guest_practicing": {
"type": "boolean",
"description": "Only episodes with a guest who still works in guest_occupation, which must be a SOC 2018 occupation or group (e.g. '29-1212' or 'physicians')."
}
}
}| string |
| Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read. |
{
"type": "object",
"properties": {
"limit": {
"type": "integer",
"maximum": 100,
"minimum": 1,
"description": "Topics per page (1-100, default 50)."
},
"query": {
"type": "string",
"maxLength": 100,
"minLength": 2,
"description": "Find topics by name: exact names first, then names starting with it, then (when it has a word of 3 or more characters) names containing it, each ranked by story coverage. Covers topics with at least 5 story clusters; browse with parent_slug for the long tail. Pages reach the top 200 matches."
},
"cursor": {
"type": "string",
"description": "Opaque pagination cursor from a previous response."
},
"parent_slug": {
"type": "string",
"description": "Topic slug or ID. Returns the direct children of this topic. Omit for top-level roots (Politics, Business, Technology, etc.). With query, limits the search to this topic's descendants."
},
"output_format": {
"enum": [
"markdown",
"json"
],
"type": "string",
"description": "Output serialization. 'markdown' (default) returns the LLM-facing rendering. 'json' returns the structured payload as JSON text — use only for programmatic chaining where exact field extraction matters; the JSON shape is larger and noisier for an LLM to read."
}
}
}