Particle Pro
activePodcast API for transcripts, mentions and sponsorship data. 140,000+ podcasts transcribed, diarized and speaker-identified within minutes of airing, about 28,000 episodes a day. Search transcripts by keyword or meaning, track brand and company mentions with alerts, pull sponsor and ad-read data and rankings. REST API plus an MCP server for AI agents. Also company, people and topic intelligence.
Settled via Coinbase.
- Transactions · 30d
- 40
- Volume · 30d
- $0.58
- Unique buyers · 30d
- 16
- Uptime · 30d
- 94.2%
- Latency p50
- 74ms
- Reported calls · 30d
- 151
Endpoints (247 live)
GET/v1/podcasts/episodes/search— Search podcast episode content. To find podcasts (shows) by name or topic, use /v1/podcasts/search?q=…. (0.03 USDC on Base)GET/v1/podcasts/episodes/timeseries— Get episode timeseries. Returns time-bucketed counts of episodes matching the same filters as GET /v1/podcasts/episodes, plus range totals. (0.01 USDC on Base)GET/v1/podcasts/rankings/sources— List ranking sources. Returns each (source, chart_type) pair available on this API together with row counts and freshness for the live snapshot. (0.01 USDC on Base)GET/v1/podcasts/lookup— Look up podcasts by external platform identifier. Resolves one or more external platform identifiers (Apple Podcasts collection IDs, Spotify show IDs, YouTube channel IDs, …) or show links — or RSS feed URLs via platform=rss — to Particle (0.01 USDC on Base)GET/v1/entities— List entities. List knowledge graph entities (people, organizations, places) across all podcast content. (0.01 USDC on Base)GET/v1/podcasts/:id/ratings— List ratings for a podcast. Returns user-generated ratings (1-5 stars plus optional review text) captured from third-party platforms. (0.01 USDC on Base)GET/v1/podcasts/episodes— List episodes. Returns a paginated list of podcast episodes across all podcasts. (0.01 USDC on Base)GET/v1/podcasts/search— Search podcasts. Searches the podcast catalog by show name — the canonical podcast search. (0.01 USDC on Base)GET/v1/companies/1/statement-characteristics— Get how a company's people speak. Breaks the podcast lines of a company's people down by speaker statement characteristic, together, per week or month bucket and over the window (the last year by default): how many of their scored lines are (0.03 USDC on Base)GET/v1/people/1/statement-characteristics— Get how a Person speaks. Breaks the Person's podcast lines down by speaker statement characteristic, per week or month bucket and over the window (the last year by default): how many of their scored lines are negative, neutral or positive; hedged (0.03 USDC on Base)GET/v1/podcasts/1/guests/expertise/1— List a podcast's guests in an occupation or field. Ranks the guests and panelists a show booked who are listed under one occupation or field of research, by their appearances on the show, all time unless since or until narrows it: the people (0.03 USDC on Base)GET/v1/people/fields/1/guests— Rank a field of research's guests. Ranks the people listed under an ANZSRC 2020 field of research by their podcast guest and panelist appearances in a window of publication dates (the last 30 days by default), then by the distinct shows they (0.04 USDC on Base)GET/v1/people/1/expertise— Get a Person's expertise. Returns what the Person's records say about their expertise, in words: the SOC 2018 and ISCO-08 occupations and ANZSRC 2020 fields of research they are listed under (each usable as a filter by code, slug, or title) (0.03 USDC on Base)GET/v1/people/occupations/1/guests— Rank an occupation's guests. Ranks the people listed under an occupation by their podcast guest and panelist appearances in a window of publication dates (the last 30 days by default), then by the distinct shows they appeared on. (0.04 USDC on Base)GET/v1/people/fields/1— Get a field of research. Returns one ANZSRC 2020 field of research with its parent and children. (0.01 USDC on Base)GET/v1/people/occupations/1/podcasts— Rank the podcasts that book an occupation. Ranks the shows by their guest and panelist appearances of people listed under an occupation in a window of publication dates (the last 30 days by default), then by how many distinct such people they (0.04 USDC on Base)GET/v1/podcasts/episodes/1/expertise— List an episode's guest expertise. Returns each guest on the episode with how the episode used their expertise (whether it is within their field, whether they are there mainly to promote something, and how the episode introduced them) and what (0.03 USDC on Base)GET/v1/podcasts/1/guests/expertise— Get the expertise of a podcast's guests. Returns the show's guest-expertise profile over every guest and panelist appearance analyzed for expertise, all time: how many there were, the share whose standing others conferred, who spoke within their (0.03 USDC on Base)GET/v1/people/occupations/1— Get an occupation. Returns one SOC 2018 or ISCO-08 occupation with its parent, its children, and the same occupation in the other standard per the official BLS crosswalk. (0.01 USDC on Base)GET/v1/people/fields/1/podcasts— Rank the podcasts that book a field of research. Ranks the shows by their guest and panelist appearances of people listed under an ANZSRC 2020 field of research in a window of publication dates (the last 30 days by default), then by how many (0.04 USDC on Base)
+227 more endpoints.
MCP tools (44)
particle-pro https://api.particle.pro/mcp
particle_alert_create— 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 matparticle_alert_delete— 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.particle_alert_get— 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.particle_alert_list— 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.particle_alert_list_matches— 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.particle_alert_preview— 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.particle_alert_update— 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.filterparticle_call— 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.particle_catalog— 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)particle_company_get— 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.particle_company_get_statement_characteristics— 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_chparticle_company_list_people— 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 speparticle_company_resolve— 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.particle_entity_get— 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.particle_entity_resolve— 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, orparticle_expertise_get— 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 uparticle_expertise_resolve— 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_pparticle_person_get— 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 `paparticle_person_get_statement_characteristics— 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`.particle_person_resolve— 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`.particle_podcast_compare_share_of_voice— Compare how two to five companies, people or entities are spoken of on podcasts, side by side: "how is NVIDIA spoken of vs AMD vs Intel?" in one call. Each subject's mention lines over the same window (default the last 30 days, at most 365) are grouped by their label on one speaker statement characteristics axis — `by="sentiment"` (default), certainty, specificity or temporal_orientation — and each label's share is of that subject's scored mentions, the lines that carry labels. A subject with fewer than 20 is marked low sample: read its shares as examples. By default it counts guests' and panelists' lines; `speakers="all"` adds hosts. Each subject is exactly what `particle_podcast_get_share_of_voice` returns for it with the same arguments and `by` set to the axis, so the numbers agree. `breakdown` splits each label group by a second axis (how sure each subject's predictions are is by="temporal_orientation", breakdown="certainty"); `speaker_statement_characteristics` counts only linesparticle_podcast_find_mentions— 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 menparticle_podcast_get_entity_chart— 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. Passparticle_podcast_get_episode— 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" usparticle_podcast_get_episode_timeseries— 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 compparticle_podcast_get_guest— 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, soparticle_podcast_get_mention_trends— 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 is `continuing`; one only in the previous is `dropped`. A show only in the current window is judged against the lookback before it (`lookback_days`, default 90): `new` when it never mentioned the subject there, published at least four episodes there, and has two or more mention lines now; `returning` when it mentioned the subject earlier in the lookback; `passing` for a single line; `newly_tracked` when it published too little in the lookback to tell. Totals for both windows count every podcast. Filterparticle_podcast_get_rankings— 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, entries, exits). Most `change=new` entries are established shows returning to the chart; for new podcasts, launches, or debuts use `change=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 — with `podcast_slug` — one podcast's chart history over time, newest first. Per-podcast history defaults to `country=us`; pass `country` for other markets. For one chart's trajectory pass `source`, `country`, and `category_slug` too (omit `catparticle_podcast_get_share_of_voice— 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. By default it counts guests' and panelists' lines at the detailed level (Chief Executives, Financial Analysts, Dietitians), each with the top-level group it sits under. `speakers="all"` adds hosts, who speak most mention lines and mostly code to media; `level="major"` gives SOC major groups or ANZSRC divisions only; `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 windoparticle_podcast_get_transcription_request— 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.particle_podcast_list_clips— 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`.particle_podcast_list_episodes— 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 guestparticle_podcast_list_guests— 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, use `particle_podcast_get_entity_chart` with `chart="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 toparticle_podcast_list_related— 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 cparticle_podcast_list_related_episodes— 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`.particle_podcast_request_transcription— 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 usuparticle_podcast_resolve— 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: - `inparticle_podcast_search_transcripts— 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 sharparticle_report_create— 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.particle_report_delete— 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.particle_report_get— 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.particle_report_list— 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.particle_report_update— 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.particle_topic_browse— 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`.
First seen · last seen · last active