particle-pro
Server Details
Podcast intelligence for agents: transcripts, clips, speaker diarization, mention tracking.
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 44 tools
Most tools are cleanly partitioned by resource and action: alerts and reports have clear CRUD sets, and profile tools for people, companies, entities, guests, episodes, and podcasts are distinct. The main risk is the cluster of podcast analytics/search tools (find_mentions, search_transcripts, get_share_of_voice, compare_share_of_voice, get_mention_trends, get_episode_timeseries), which conceptually overlap, though the descriptions provide extensive 'use X instead' routing.
All names use a consistent particle_ prefix, snake_case, and a category-plus-verb-plus-object pattern (e.g. particle_alert_create, particle_podcast_list_episodes, particle_company_get_statement_characteristics). Verbs such as resolve, get, list, search, create, update, delete, and request are used predictably throughout the set.
At 44 advertised tools, the surface is far beyond the well-scoped 3-15 range and past the 16-25 borderline band. Many tools are individually justified by the broad podcast-intelligence domain, but the overall count is too large for an agent to navigate comfortably, and the presence of catalog/call meta-tools signals that the exposed set is already sprawling.
Core coverage is strong: resolution and retrieval for podcasts, episodes, people, companies, entities, guests, topics, transcriptions, rankings, trends, alerts, and reports, including full alert/report lifecycles. The main gaps are referenced opt-in tools (e.g. ad presence, sponsors, publishers, ratings, bias, suitability) not advertised in this list, though they are reachable through particle_catalog and particle_call.
Available Tools
44 toolsparticle_alert_createParticle Alert CreateADestructiveInspect
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). ENTITY_MENTION alerts also take speaker_statement_characteristics, which fires only on mentions said a certain way: {"sentiment": ["negative"]} for negative mentions of a company, {"specificity": ["specific"], "temporal_orientation": ["future"]} for predictions about it, {"certainty": ["confident"]} for confident claims. Each mention line in the alert's matches carries its labels.
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.
Inputs: title (required), kind, filters, keyword, +6 more.
particle_alert_deleteParticle Alert DeleteADestructiveInspect
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.
Inputs: alert_id (required).
particle_alert_getParticle Alert GetARead-onlyInspect
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.
Inputs: alert_id (required), include, match_limit, output_format.
particle_alert_listParticle Alert ListARead-onlyInspect
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.
Inputs: limit, cursor, output_format.
particle_alert_list_matchesParticle Alert List MatchesARead-onlyInspect
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.
Inputs: alert_id (required), view, after, limit, +3 more.
particle_alert_previewParticle Alert PreviewAInspect
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.
Inputs: kind, filters, keyword, entities, +2 more.
particle_alert_updateParticle Alert UpdateADestructiveInspect
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 axes as particle_alert_create.filters: languages, relevance (EVERYTHING/RELEVANT), source_popularity (ANY/POPULAR), speaker_roles (PODCAST_SPEAKER alerts only — sending it on an ENTITY_MENTION alert returns unprocessable_entity), and speaker_statement_characteristics (ENTITY_MENTION alerts only; it applies to matches detected after the update).
Alerts are not covered by zero data retention: the alert's definition and its matched results are stored as part of the alerts feature.
Inputs: alert_id (required), title, filters, keyword, +6 more.
particle_callParticle CallADestructiveInspect
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.
Inputs: tool (required), arguments.
particle_catalogParticle CatalogARead-onlyInspect
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
includearray (e.g. a company's people, products, and competitors; a person's roles and podcast appearances) or change behavior via amode/formatswitch. 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_trends(default): Trending entities on podcasts: daily entity charts with movement and the quote behind it.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.reports(default): Create and manage saved Radar reports that compare one to four people, companies, topics or keywords, each with a link to the report's page on Radar.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.
Inputs: category, output_format.
particle_company_getParticle Company GetARead-onlyInspect
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.
Inputs: company_slug (required), include, product_status.
particle_company_get_statement_characteristicsParticle Company Get Statement CharacteristicsARead-onlyInspect
How a company's people speak on podcasts, together, and how that moves over time: the share of their lines that are negative, neutral or positive; hedged, neutral or confident; vague, neutral or specific; and about the past, present or future, overall and per week or month (the last year by default), with how many of the people said them. Use it for 'how confident do OpenAI's people sound lately' or 'are Microsoft's executives talking more about the future'. Pass include=['examples'] for each bucket's strongest line per outer label, with who said it (a person_slug for particle_person_get_statement_characteristics), the episode and a link that plays the moment.
The people are the ones particle_company_get lists with include=['people']: current roles by default, past ones too with include_past_roles. Shares are of their scored lines (lines too short to read carry no characteristics); low_sample marks fewer than 20 behind a share. For one person, use particle_person_get_statement_characteristics. Resolve the company first with particle_company_resolve.
Inputs: company_slug (required), include, interval, output_format, +3 more.
particle_company_list_peopleParticle Company List PeopleARead-onlyInspect
List the people at one company, leadership first, a page at a time: the chief executive, then founders, chairs and presidents, the rest of the C-suite, board members, EVPs, SVPs, VPs, directors, managers, and everyone else, the longest-serving first within a level. Each entry gives the person slug and their title at this company, with the total across all pages.
Use it to go past the 25-person preview particle_company_get include=people returns, or to narrow a large company with role (e.g. executive), title (e.g. 'chief', 'investor relations') or name (e.g. 'huang'). For one company's profile and its leadership at a glance, call particle_company_get instead. To find a person by name, use particle_person_resolve.
Person slugs feed particle_person_get, particle_person_get_statement_characteristics, and the person_slug filter of particle_podcast_find_mentions, particle_podcast_search_transcripts and particle_podcast_list_episodes. For how the company's people speak on podcasts together, use particle_company_get_statement_characteristics.
Inputs: company_slug (required), name, role, sort, +5 more.
particle_company_resolveParticle Company ResolveARead-onlyInspect
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.
Inputs: cik, qid, limit, query, +2 more.
particle_entity_getParticle Entity GetARead-onlyInspect
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.
Inputs: entity_slug (required), output_format.
particle_entity_resolveParticle Entity ResolveARead-onlyInspect
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 intoparticle_person_get, everyperson_slugparameter (particle_podcast_find_mentions,particle_podcast_search_transcripts,particle_podcast_list_episodes), orparticle_podcast_get_guest'sguest_slug.company: the canonical company slug. Feed it intoparticle_company_getand everycompany_slugparameter.place/other: a bare entity slug. Feed it into theentity_slugparameter onparticle_podcast_find_mentions,particle_podcast_search_transcripts, andparticle_podcast_list_episodesto 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.
Inputs: query (required), limit.
particle_expertise_getParticle Expertise GetARead-onlyInspect
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"].
Inputs: field, limit, since, until, +6 more.
particle_expertise_resolveParticle Expertise ResolveARead-onlyInspect
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.
Inputs: limit, query, parent, standard, +1 more.
particle_person_getParticle Person GetARead-onlyInspect
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.
Inputs: person_slug (required), include, output_format.
particle_person_get_statement_characteristicsParticle Person Get Statement CharacteristicsARead-onlyInspect
How a person speaks on podcasts, and how that moves over time: the share of their lines that are negative, neutral or positive; hedged, neutral or confident; vague, neutral or specific; and about the past, present or future, overall and per week or month (the last year by default). Use it for 'is Sam Altman more cautious than he used to be', 'how often does she make predictions', or 'how positive has he been lately'. Pass include=['examples'] for each bucket's strongest line per outer label, with episode slugs for particle_podcast_get_episode and a link that plays the moment.
Shares are of the person's scored lines (lines too short to read carry no characteristics); low_sample marks fewer than 20 behind a share. To find their lines said a certain way about a topic, use particle_podcast_search_transcripts with person_slug and speaker_statement_characteristics. Resolve the person first with particle_person_resolve.
Inputs: person_slug (required), include, interval, output_format, +2 more.
particle_person_resolveParticle Person ResolveARead-onlyInspect
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.
Inputs: query (required), limit, output_format.
particle_podcast_find_mentionsParticle Podcast Find MentionsARead-onlyInspect
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 callformat="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_episodeorparticle_podcast_search_transcripts): skip summary entirely and callformat="detail"withepisode_slugdirectly.
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.
Strongest first
With speaker_statement_characteristics, sort="strength" puts the episodes whose mentions carry the labels most clearly first: the most clearly negative takes on a company, the most confident predictions about a drug. This is the tool for the strongest lines about a subject; particle_podcast_search_transcripts refuses a subject without a topic and sends you here.
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.
How each line is said. Lines in topic and interview segments end with their speaker statement characteristics, pole labels only, e.g. _[positive · confident · future]_: sentiment (negative/positive), certainty (hedged/confident), specificity (vague/specific) and temporal orientation (past/future). A pole label means the line clearly reads that way; _[neutral]_ means it leans clearly on no axis; no brackets means the line was not read (short lines, intros, ad breaks). With output_format=json they are each line's speaker_statement_characteristics object, middle labels included.
Filtering by how a line is said. Pass speaker_statement_characteristics to keep only lines said a certain way: {"sentiment": ["negative"]} for criticism, {"specificity": ["specific"], "temporal_orientation": ["future"]} for concrete predictions, {"certainty": ["confident"], "sentiment": ["positive"], "temporal_orientation": ["future"]} for a high-conviction outlook. Put the topic, never the tone, in semantic_search. Every matched or mention line then carries labels the filter accepts.
Without a topic. On particle_podcast_search_transcripts, the filter alone with episode_slug, speaker or a guest_ filter (no semantic_search or keyword_search) returns the strongest lines said that way, at most 50, strongest first: an episode's boldest predictions, or a person's most confident claims. Their Match row reads characteristics. For the strongest lines naming a person, company or entity, pass the filter with sort: "strength" on particle_podcast_find_mentions instead.
Inputs: role, sort, limit, since, +19 more.
particle_podcast_get_entity_chartParticle Podcast Get Entity ChartARead-onlyInspect
What is trending on podcasts: Particle's daily Trends charts, which rank the entities (people, shows, films, games, books, brands, athletes, teams) that the most podcasts are talking about, with each entry's movement since the previous edition and, when the editors explained it, why it moved, backed by a verbatim podcast quote and a link that plays it.
Call with no arguments for the cross-category all chart. Pick a narrower chart with chart (its schema lists every chart and the windows it publishes): entertainment (tv-series, movies, video-games), sports leagues (nfl, nba, ...), books (fiction, nonfiction, comics-manga), and guests, which ranks people by the distinct shows they appeared on. sort=acceleration surfaces the fastest risers anywhere in the chart.
Rank does not follow the podcast count: every chart except guests ranks by how far an entry's coverage sits above its own normal level, so a lower count can rank higher.
Each entry returns a slug. Pass an entity slug to particle_entity_get, or to particle_podcast_get_mention_trends (entity_slug) for which podcasts drive it; pass a person slug to particle_person_get or particle_podcast_get_guest; pass a quote's episode id to particle_podcast_get_episode.
Not for podcast shows' own chart positions on Apple or Spotify: use particle_podcast_get_rankings. Not for one subject you already know: use particle_podcast_get_mention_trends.
Inputs: sort, chart, limit, window, +2 more.
particle_podcast_get_episodeParticle Podcast Get EpisodeARead-onlyInspect
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, 'speaker_statement_characteristics' for how the episode's lines were said (label shares overall and per speaker, who is most hedged or forward-looking, and a few of its strongest predictions, confident claims, criticism and optimism lines), 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).
Inputs: episode_slug (required), include, transcript_end, transcript_start, +2 more.
particle_podcast_get_episode_timeseriesParticle Podcast Get Episode TimeseriesARead-onlyInspect
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.
Inputs: role, interval, language, entity_slug, +18 more.
particle_podcast_get_guestParticle Podcast Get GuestARead-onlyInspect
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, with the venues behind each pick and each show's suitability tier, latest episode and chart breadth (the pitch list; branch on each row's band). It already leaves out every show they have appeared on, other feeds of those shows with the same host, shows that stopped publishing and UNSAFE shows, and ranks shows far smaller than their usual venues lower, so there is no need to check each pick's episodes, '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.
Inputs: guest_slug (required), include, output_format.
particle_podcast_get_mention_trendsParticle Podcast Get Mention TrendsARead-onlyInspect
How a person's, company's or entity's podcast mentions are moving, for tracking it week over week. To find what is rising across all podcasts rather than track a subject you already know, use particle_podcast_get_entity_chart. 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 a label. A show in both windows iscontinuing; one only in the previous isdropped. A show only in the current window is judged against the lookback before it (lookback_days, default 90):newwhen it never mentioned the subject there, published at least four episodes there, and has two or more mention lines now;returningwhen it mentioned the subject earlier in the lookback;passingfor a single line;newly_trackedwhen it published too little in the lookback to tell. Totals for both windows count every podcast. Filter withchange, order withsort(risingandfallingfor the biggest movers), and page withcursor. Answers "which shows talked about Nike this week versus last?" in one call, and, withchange="new"(sorted by popularity unlesssortis set), "which podcasts started talking about Nike this month?" or "which mentioned Nike for the first time?": read what the leading shows said withparticle_podcast_find_mentions. Since 2026-10-23,newno longer means every show absent from the previous window; that set is nownew,returning,passingandnewly_trackedtogether.timeseries: mention counts per day, week or month over a range (omitpublished_afterfor all time), each bucket with its episodes, mention lines and distinct podcasts. Answers "is it rising?".podcast_slugcharts one show.breakdownsplits each bucket by a speaker statement characteristics label (breakdown="sentiment": is it spoken of more negatively this quarter?), andspeaker_statement_characteristicscounts only the mentions said that way ({"temporal_orientation": ["future"]}: are predictions about it rising?); both needpublished_after, at most 365 days back.
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.
Inputs: mode, role, sort, limit, +23 more.
particle_podcast_get_rankingsParticle Podcast Get RankingsARead-onlyInspect
Podcast chart rankings from Apple Podcasts and Spotify, in four modes:
chart(default): the current chart for a source/country/category slot, or — withpodcast_slug— every chart slot that podcast currently holds.movers: the biggest rank changes overwindow_days(risers, fallers, entries, exits). Mostchange=newentries are established shows returning to the chart; for new podcasts, launches, or debuts usechange=debut— shows on that chart slot for the first time since tracking began (May 2026). A debut is per slot: a show can debut on the overall chart after months in a category, so read its episode count and, when shown, its first-episode date before calling it brand-new.history: past snapshots for a chart slot, or — withpodcast_slug— one podcast's chart history over time, newest first. Per-podcast history defaults tocountry=us; passcountryfor other markets. For one chart's trajectory passsource,country, andcategory_slugtoo (omitcategory_slugfor the overall chart plus every category): 90 days of one slot fits in one page of 100, where the unfiltered history of a popular show runs to hundreds of rows. History begins in May 2026.slots: the valid slot values — every source, country, and category_slug with live chart data — so filter values are discovered, not guessed.sourcenarrows 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.
Inputs: mode, limit, since, until, +8 more.
particle_podcast_get_transcription_requestParticle Podcast Get Transcription RequestARead-onlyInspect
Read where your organization's transcription request stands, by request_id or by the episode's episode_slug. Free: this is how to wait for a transcription that particle_podcast_request_transcription queued, so poll it every minute or so (a transcription usually takes 5 to 10 minutes) rather than requesting again.
state is queued (waiting its turn), admitted (being transcribed), transcribed (the episode tools now serve its transcript: particle_podcast_get_episode, particle_podcast_find_mentions, particle_podcast_search_transcripts), or failed (failure_reason says why, and the charge is refunded). By episode_slug, your organization's request answers even once the episode is transcribed; for an episode we hold that it never requested, there is no request, and state says where its transcript stands.
Inputs: request_id, episode_slug.
particle_podcast_list_clipsParticle Podcast List ClipsARead-onlyInspect
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.
Inputs: type, limit, cursor, clip_id, +6 more.
particle_podcast_list_episodesParticle Podcast List EpisodesARead-onlyInspect
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.
Inputs: role, limit, cursor, language, +18 more.
particle_podcast_list_guestsParticle Podcast List GuestsARead-onlyInspect
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. For the daily ranked guests chart, with movement since the previous edition and each guest's top clip, useparticle_podcast_get_entity_chartwithchart="guests".
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.
Inputs: mode, field, limit, cursor, +11 more.
particle_podcast_request_transcriptionParticle Podcast Request TranscriptionAIdempotentInspect
Request the transcription of a back-catalogue episode: one discovered in its podcast's feed but not yet transcribed, which particle_podcast_list_episodes (transcript_status=requestable, with podcast_slug) and particle_podcast_get_episode mark requestable. Its transcript, segments, speakers, entities and mentions do not exist until it is transcribed.
Billing: the request that queues the episode costs $0.05 per episode on every plan, charged in USD and never drawn from the included requests, and needs overage billing turned on (overage_required otherwise). Confirm the charge with the user before requesting. Every other outcome is billed as an ordinary lookup: an episode your organization already requested (the existing request is returned), one another organization's request already queued, or one we already hold.
It returns at once with the request's state: queued, admitted (being transcribed), transcribed, or failed (failure_reason says why; the charge is refunded). Transcription usually takes 5 to 10 minutes. Poll with particle_podcast_get_transcription_request, which is free; never call this tool again to poll. Once transcribed, the episode keeps its slug and every episode tool serves it: particle_podcast_get_episode, particle_podcast_find_mentions with episode_slug, and particle_podcast_search_transcripts.
Inputs: episode_slug (required).
particle_podcast_resolveParticle Podcast ResolveARead-onlyInspect
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-levelsuitability_tierenum (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 useparticle_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-upparticle_podcast_list_episodescall 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"].
Inputs: slug, limit, query, include, +11 more.
particle_podcast_search_transcriptsParticle Podcast Search TranscriptsARead-onlyInspect
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_searchcarries 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_searchcarries 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.
How each line is said. Lines in topic and interview segments end with their speaker statement characteristics, pole labels only, e.g. _[positive · confident · future]_: sentiment (negative/positive), certainty (hedged/confident), specificity (vague/specific) and temporal orientation (past/future). A pole label means the line clearly reads that way; _[neutral]_ means it leans clearly on no axis; no brackets means the line was not read (short lines, intros, ad breaks). With output_format=json they are each line's speaker_statement_characteristics object, middle labels included.
Filtering by how a line is said. Pass speaker_statement_characteristics to keep only lines said a certain way: {"sentiment": ["negative"]} for criticism, {"specificity": ["specific"], "temporal_orientation": ["future"]} for concrete predictions, {"certainty": ["confident"], "sentiment": ["positive"], "temporal_orientation": ["future"]} for a high-conviction outlook. Put the topic, never the tone, in semantic_search. Every matched or mention line then carries labels the filter accepts.
Without a topic. On particle_podcast_search_transcripts, the filter alone with episode_slug, speaker or a guest_ filter (no semantic_search or keyword_search) returns the strongest lines said that way, at most 50, strongest first: an episode's boldest predictions, or a person's most confident claims. Their Match row reads characteristics. For the strongest lines naming a person, company or entity, pass the filter with sort: "strength" on particle_podcast_find_mentions instead.
Inputs: role, sort, limit, since, +26 more.
particle_report_createParticle Report CreateAInspect
Save a Radar report in your project: a page comparing one to four people, companies, topics or keywords side by side, with their podcast mentions over time, every mention linked to the minute, and their news coverage. Returns the report's id and its Radar link; give the user the link, since the page is where the report is read (and downloaded as a PDF). Every member of the project's organization can open and edit it.
Resolve each person, company or topic first with particle_entity_resolve, particle_person_resolve or particle_company_resolve and pass the slug as entity; use keyword for a name with no slug. The period defaults to the last three months and the sources to podcasts and news.
Use it when the user asks for a report, or to compare or share coverage. To answer a question about coverage now, use the podcast tools instead: a report is a page to open, not data returned to you. The id feeds particle_report_get, particle_report_update and particle_report_delete.
Inputs: subjects (required), to, from, name, +7 more.
particle_report_deleteParticle Report DeleteADestructiveInspect
Delete a saved Radar report for everyone in the project. Any member of the project's organization may delete one. Its Radar link stops opening it, so do this only when the user asks.
Inputs: report_id (required), output_format.
particle_report_getParticle Report GetARead-onlyInspect
Get one saved Radar report: its name, subjects, period, sources and presentation settings, and its Radar link. The report's mentions and news are read on its Radar page, not returned here; to answer from the data, use the podcast tools on the same subjects.
Inputs: report_id (required), output_format.
particle_report_listParticle Report ListARead-onlyInspect
List the saved Radar reports in your project, most recently edited first, each with its id, subjects and Radar link. Feed an id into particle_report_get for its full settings, particle_report_update to change it, or particle_report_delete. Check here before creating a report the project may already have.
Inputs: limit, cursor, output_format.
particle_report_updateParticle Report UpdateADestructiveInspect
Change a saved Radar report: rename it, replace its subjects, or change its period, sources, sort, episode cap, omitted sections or hidden episodes. Only the fields you pass change. subjects replaces the whole list, so pass every subject the report should keep. Setting period clears an explicit from/to range, and setting from/to clears the period.
Every member of the project's organization sees the change. Returns the updated report and its Radar link.
Inputs: report_id (required), to, from, name, +8 more.
particle_topic_browseParticle Topic BrowseARead-onlyInspect
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.
Inputs: limit, query, cursor, parent_slug, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
Podcast knowledge for AI agents: search episodes, pull transcripts and ask questions.
Podcast search, metadata, chapters, and transcripts for AI agents — from $15/mo
Search speech in podcasts, government meetings, and your own audio: speakers, entities, timestamps.
Meeting transcripts for AI agents: search calls, read who said what, transcribe files and links.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables AI agents to search millions of podcasts, read and search episode transcripts with timestamps and speakers, and access chapters, soundbites, Podcasting 2.0 tags, value-for-value data, feed health, and index statistics through 36 tools.3626 npm1MIT
- AlicenseNot gradedqualityDmaintenanceExtract product mentions, sponsors, and trends from podcast transcripts to generate affiliate revenue, with F1=100% on eval suite and a free tier of 200 calls/day.MIT
- AlicenseNot gradedqualityDmaintenanceHosted Claude connector that turns the podcasts you already follow into a searchable, askable knowledge source. Ask what a guest said and get the answer back with the exact quote and timestamp.MIT

Podwiseofficial
AlicenseNot gradedqualityCmaintenanceSearch podcast episodes, pull transcripts, ask questions about an episode and export summaries as Markdown.418MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.