Podcast Episode Summarizer (AI) — Transcript to Summary

What it does

Podcast Episode Summarizer turns podcast episodes into structured summaries. Give it RSS/Atom feed URLs, Apple Podcasts show links or plain search terms (search:the daily), and for each episode it fetches the published transcript (the Podcasting 2.0 <podcast:transcript> file in text, WebVTT, SRT, JSON or HTML), falls back to the show notes when there is none, and writes one dataset item with the episode's metadata (show, title, publish date, duration, audio URL, link) plus a summary block: an abstract, key topics, chapters with timestamps where the transcript has them, notable quotes with speaker and timestamp, named guests and action items.

It has three summarizers, chosen with the summarizer input and recorded on every item as summaryMethod. AI summaries are the default: when summarizer is left empty the Actor uses the hosted Claude model; set summarizer=extractive for a free, model-free run, or summarizer=byok to use your own key.

• hosted (default): Claude on the Actor's own key, tokens included, from $0.02 per episode. Nothing to set up. Pick a model tier: fast (Claude Haiku 5.5, $0.02), balanced (Claude Sonnet 5.5, $0.25) or best (Claude Opus 5.5, $0.50). If the model cannot be reached, the episode gets the extractive summary instead, marked summaryMethod: "extractive-fallback" with a summaryWarning, and is charged the extractive price; a run never fails because of the model.
• byok (bring your own key): Claude writes the summary using the anthropicApiKey you supply (stored as a secret, sent only to api.anthropic.com), on the same three tiers. You pay Anthropic for the tokens and $0.005 per episode here; each item records tokensIn, tokensOut and modelCostUsdEstimate.
• extractive: a deterministic TextRank-style summary with keyword topics. No language model, no key, runs in milliseconds, costs $0.002 per episode. Good for search indexes, monitoring and bulk back-catalog processing.

Built for podcast discovery and search products, newsletters and show-notes writers, media monitoring (what was said about a brand, by whom, at what minute), research teams, and AI agents that need a summary of an episode on demand. Results are available as JSON, CSV, Excel, through the API, webhooks and the Apify MCP server.

How to use

1. Enter your Feeds (one per line): feed URLs, Apple Podcasts URLs, bare Apple IDs or search:<show name>. Optionally list Specific episodes (GUIDs or episode URLs) to summarize only those.
2. Leave Summarizer empty for hosted AI summaries and pick a Model tier (fast is the default); or choose byok and paste your Anthropic API key; or choose extractive for a free, model-free run.
3. Click Start. One item per episode appears in the dataset as each summary is ready; download them or connect via API/MCP. Schedule the run to keep a summary of every new episode.

Quick start input

The same input the Store runs in its daily automated test, so it is cheap and always available; paste it into the JSON tab of the input form or send it as the body of an API or MCP call:

{
  "feeds": [
    "https://podnews.net/rss"
  ],
  "maxEpisodesPerFeed": 2,
  "summarizer": "extractive"
}

Input

Field	Type	Required	Description
feeds	string[]	yes	Feed URLs, Apple Podcasts URLs, Apple IDs or search:<term> entries, one per line. A show web page with an RSS autodiscovery link also works
maxEpisodesPerFeed	integer	no	Newest-first cap on episodes summarized per feed (default 10, max 1,000)
episodes	string[]	no	Episode GUIDs, episode page URLs or audio URLs; when set, only matching episodes are summarized
summarizer	string	no	hosted, byok or extractive. Empty = hosted when the Actor's model key is configured, else extractive
anthropicApiKey	string (secret)	for byok	Your Anthropic API key; used only in byok mode
modelTier	string	no	fast (default, Claude Haiku 5.5), balanced (Claude Sonnet 5.5) or best (Claude Opus 5.5); applies to hosted and byok
maxInputTokens	integer	no	Per-episode input cap for model modes, 2,000–40,000 (default 40,000). Longer transcripts are cut and the item marked inputTruncated: true
maxConcurrency	integer	no	Episodes processed in parallel per feed, 1–5 (default 3)
webhookUrl	string	no	POST target for the run summary (counts, token totals)

Output example

An item produced in extractive mode from a Podnews Daily episode with a WebVTT transcript:

{
  "recordType": "episode",
  "feedUrl": "https://podnews.net/rss",
  "showTitle": "Podnews Daily - podcast industry and podcasting news",
  "episodeGuid": "https://podnews.net/update/pave-disney-hulu-clues",
  "title": "PAVE Studios shows head to Disney+ and Hulu",
  "pubDate": "2026-10-16T10:09:41.000Z",
  "durationSeconds": 291,
  "audioUrl": "https://op3.dev/e,pg=9b024349-ccf0-5f69-a609-6b82873eab3c/podnews.net/audio/podnews261016.mp3",
  "link": "https://podnews.net/update/pave-disney-hulu-clues",
  "imageUrl": "https://podnews.net/audio/podnews261016.jpeg",
  "episode": 2450,
  "transcriptSource": "transcript",
  "transcriptUrl": "https://podnews.net/audio/podnews261016.mp3.vtt",
  "transcriptFormat": "vtt",
  "transcriptWords": 724,
  "transcriptHasTimestamps": true,
  "summaryMethod": "extractive",
  "summary": {
    "abstract": "Meanwhile, in Australia, podcast publisher Mammamia is to make it to Samsung TV Plus as a streaming TV channel. YouTube leads in almost every territory, with 32% market share globally, and added 27 million users in 2025, suggests the research. Adam Curry is also a guest in the Podnews Weekly Review today. …",
    "keyTopics": ["adam curry", "youtube short", "samsung tv", "tv plus", "james cridland", "pave studios", "apple", "research"],
    "chapters": [
      { "title": "Adam Curry & Youtube Short", "summary": "YouTube leads in almost every territory, with 32% market share globally, and added 27 million users in 2025, suggests the research.", "startTime": 0, "startTimestamp": "0:00" },
      { "title": "Apple & Norway", "summary": "And in podcast news, the Vardø Witch Trials, an independent English-language documentary about Norway's deadliest witch hunt, is number one in both history and top series on Apple Podcasts in Norway.", "startTime": 157, "startTimestamp": "2:37" }
    ],
    "notableQuotes": [
      { "quote": "Adam Curry is to step back from No Agenda, with the show on October the 29th being his last.", "speaker": "James Cridland", "timestamp": "1:29" },
      { "quote": "YouTube is readying an AI-powered tool that'll take a clip of audio and make it into a YouTube short, according to YouTube's Emma Sweet.", "speaker": "James Cridland", "timestamp": "2:01" }
    ],
    "namedGuests": ["Adam Curry"],
    "actionItems": ["You can find out more with a link in our show notes."]
  },
  "fetchedAt": "2026-10-16T15:33:45.237Z"
}

Items written in byok or hosted mode have the same summary shape (the model writes the abstract and chapter titles in prose rather than quoting sentences) and additionally carry modelTier, model, tokensIn, tokensOut, modelCostUsdEstimate (USD at Anthropic list prices) and inputTruncated (with inputKeptRatio and inputTruncationNote when the transcript was cut to the cap). When there is no transcript, transcriptSource is "description" and the summary is built from the show notes; chapters and quote timestamps are then empty. A transcript tag that could not be downloaded leaves transcriptError on the item and the show notes are used instead. If a model call fails (rate limit, API error, timeout, refusal, invalid JSON) or the hosted model is not configured, the item falls back to the extractive summary with summaryMethod: "extractive-fallback", records the reason in summaryWarning, and is charged the extractive price.

Error items look like { "recordType": "error", "input": "…", "error": "FEED_FAILED", "errorMessage": "HTTP 404 for …" } (feed level: FEED_FAILED, APPLE_ID_NOT_FOUND, APPLE_NO_FEED_URL, APPLE_LOOKUP_FAILED, SEARCH_NO_RESULTS, ITUNES_SEARCH_FAILED, GUID_RESOLUTION_UNAVAILABLE, INVALID_INPUT; episode level: NO_TEXT when an episode has neither a usable transcript nor show notes) and are charged at the extractive price, because the work to discover the problem was done. A byok run without a key, or with a key Anthropic rejects, fails with a clear message before any further summary is charged.

If the output saves you time, a review on the Store page helps other buyers find this Actor; the Store invites you to leave one after you have run it a few times.

Pricing

Pay per event. You only pay for what the Actor produces; set a maximum cost per run in the run options to cap spend.

Event	Price	Notes
Episode summarized (extractive, no model)	$0.002	Per episode item in extractive mode or on an extractive-fallback; error items are charged at this price too
Episode summarized (your Anthropic key)	$0.005	Per episode summarized by Claude in byok mode, any tier; your tokens are billed by Anthropic, not here
Episode summarized (hosted, fast tier)	$0.02	Claude Haiku 5.5 on the Actor's key, tokens included, up to 40,000 input tokens per episode
Episode summarized (hosted, balanced tier)	$0.25	Claude Sonnet 5.5, same caps
Episode summarized (hosted, best tier)	$0.50	Claude Opus 5.5, same caps
Actor start	$0.00005	Apify platform event

Worked examples. Hosted fast (the default): 100 one-hour episodes ≈ $2.00, nothing else to pay; balanced ≈ $25.00; best ≈ $50.00. Bring your own key: 100 one-hour episodes ≈ $0.50 here plus roughly $0.21 of Claude Haiku 5.5 tokens on your Anthropic bill (about 13,000 input and 1,500 output tokens per hour of speech at $0.10 and $0.50 per million); about $4.10 on Sonnet 5.5 ($2 and $10 per million) or $8.20 on Opus 5.5 ($4 and $20 per million). Extractive: a back catalog of 1,000 episodes ≈ $2.00.

Spending limit and model tiers. The hosted model is called before its per-episode event is charged, so before every model call the Actor checks that your run's maximum total charge still covers that event. When it does not, the model is not called: the episode gets the extractive summary instead, charged at the extractive price, with a summaryWarning that names the tier and the limit to set (the run's SUMMARY counts these as modelSkippedForSpendingLimit). When not even an extractive item fits, the run stops cleanly with a log line and nothing more is charged. A run with no limit set behaves as before. In practice: set the maximum total charge to at least the tier price times the number of episodes you want summarized by the model.

How the hosted prices are set. Against the worst case, not the average. The transcript is capped at 40,000 input tokens (about three hours of speech), every call carries about 1,700 fixed tokens of instructions and schema on top, and output is capped at 4,000 tokens per episode, so the most one episode can cost in tokens is: fast 41,700 × $0.10/M + 4,000 × $0.50/M ≈ $0.0062; balanced 41,700 × $2/M + 4,000 × $10/M ≈ $0.12; best 41,700 × $4/M + 4,000 × $20/M ≈ $0.25. Apify pays developers 80% of the event price ($0.016, $0.20 and $0.40 respectively), so every tier clears its worst-case token cost even at the cap, by about 2.6×, 1.6× and 1.6×; a typical one-hour episode costs a fraction of that. Reasoning tokens are kept out of the output cap (thinking is turned off on Haiku and Sonnet; Opus runs at low effort). A model failure is never charged at the hosted price: the item falls back to the extractive summary at $0.002.

Limits and fair use

• Feeds are fetched with plain HTTP from Apify datacenter IPs (up to 30 MB each, 20 s timeout, at most ~2 requests per second per host). Transcript files are capped at 2 MB. The Actor does not download audio and does not transcribe; it uses only the transcript file the podcast publishes, or the show notes.
• Each feed has a time budget (maxSecondsPerFeed, default 1,800 s) and an idle limit of 60 s without a finished summary (a transcript host that keeps timing out does not count as progress). When either runs out, the feed's remaining episodes are not summarized; summaries already made are kept and charged, and if nothing was produced you get one TIME_BUDGET error item, charged like any other error item. A feed with no episodes, or none matching episodes, also returns one charged error item (the whole feed was still downloaded). After 3 model failures in a row the rest of the run uses the extractive summary. Default run memory is 512 MB. Each model call has a 60 s deadline and is not retried; a call that times out falls back to the extractive summary, charged at the extractive price, and after three failures in a row the model is skipped for the rest of the run.
• Model modes cut the transcript to maxInputTokens (at most 40,000 tokens, about three hours of speech) before the call and say so on the item; the summary then covers only the kept part. Output is capped at 4,000 tokens per episode. The model is set by modelTier in both hosted and byok modes.
• The extractive summarizer picks sentences and keywords from the text itself; it is deterministic and language-agnostic but reads best on conversational English transcripts. Chapters are produced only for texts of 300+ words, roughly one chapter per 800 words (about 5 minutes of speech), up to 8.
• Named guests come from <podcast:person role="guest"> tags and from speaker labels in the transcript; the show's author and the first voice of an episode are treated as hosts and left out.
• Apple Podcasts URLs and search: terms are resolved through Apple's public iTunes Lookup/Search API (no key needed, rate-limited to about 20 requests per minute). Podcast Index GUIDs cannot be resolved without an API key and produce GUID_RESOLUTION_UNAVAILABLE.
• Only public data is accessed: feeds, the transcript files they link, Apple's public catalogue and, in model modes, the Anthropic API. Your anthropicApiKey is stored encrypted by Apify and is never logged or written to the dataset.

Related Actors

• Podcast RSS Feed Scraper — Episodes & Transcripts (same account): the raw show, episode and transcript records without summaries, from $0.0005 per episode.
• Link 1–2 more sibling Actors from this account once published.

Use from AI agents (MCP)

Pin this Actor in the Apify MCP server with one link: https://mcp.apify.com?tools=owlabee/podcast-episode-summarizer, or let the agent find it with the search-actors tool. It is pay-per-event with limited permissions, so agents can discover it, inspect the input schema with fetch-actor-details and pay per run through agentic payments. Prompts that map directly onto the input:

1. "Summarize the latest three episodes of Podnews Daily (https://podnews.net/rss) with chapters, timestamps and notable quotes."
2. "Give me the key topics and named guests of the last 10 episodes of this Apple Podcasts show: https://podcasts.apple.com/us/podcast/…/id1200361736."
3. "Summarize this episode (GUID or URL) from its transcript using my Anthropic key, and tell me how many tokens it used."

The agent receives the same dataset records shown in the output example above.

FAQ

Which mode should I use? The default, hosted on the fast tier, gives you a written abstract, chapter titles in prose, quotes and action items for a flat $0.02 per episode with nothing to set up; move to balanced or best when abstracts of long, nuanced conversations matter more than price. Use byok when you already have an Anthropic key and want to control the model and the token spend yourself. Use extractive for bulk back catalogs, indexing and monitoring: it is free of model costs, needs no key, and its topics, timestamped chapters and quotes are verbatim from the transcript.

Does this need proxies or an API key? No proxies. Feeds, transcript files and the iTunes API are public endpoints read over plain HTTP from Apify's standard infrastructure. An API key is needed only for byok mode; hosted and extractive need nothing.

How is cost controlled? Cost = episodes × the price of the mode and tier you chose. Limit episodes with maxEpisodesPerFeed or list exact episodes, lower maxInputTokens in byok mode to cut your own token bill, and set the run's maximum total charge; the Actor stops cleanly when it is reached. Every model-mode item records tokensIn, tokensOut and modelCostUsdEstimate, and the run's SUMMARY record in the key-value store totals them.

What if an episode has no transcript? The show notes (episode description) are summarized instead and the item says transcriptSource: "description". Chapters and quote timestamps are empty in that case, because there is nothing to anchor them to. An episode with neither produces a NO_TEXT error item.

Can I pass an Apple Podcasts link or just the show name? Yes. https://podcasts.apple.com/…/id123456789 (or the bare ID) is resolved with the iTunes Lookup API; search:show name uses the iTunes Search API and takes the top match with a public feed.

Can an AI agent use this? Yes; see "Use from AI agents (MCP)" above for the pin link and example prompts. Schedules and webhooks work the same way from the Console or the API.

What happens on errors? A feed that cannot be resolved, fetched or parsed produces an error item with a clear code instead of failing the whole run; other feeds are unaffected. A transcript that cannot be downloaded falls back to the show notes. A model call that fails falls back to the extractive summary (summaryMethod: "extractive-fallback", reason in summaryWarning) and is charged the extractive price, so a hosted run never fails because of the model. Only a byok run with a missing or rejected key stops, with a clear message.

Can I try it for free? Yes. The Apify free plan comes with monthly platform credit, and the quick-start input above costs a few cents per run, so you can test it on your own inputs before paying anything.

How do I find this Actor again? Bookmark it on the Store page (the bookmark icon next to the title); bookmarked Actors are listed in your Console, and the Store page shows new versions as they ship.

Legal

Use the data in compliance with each publisher's terms and applicable law. The Actor reads only publicly published podcast feeds, the transcript files linked from them (used only as the podcast itself published them; no audio is downloaded or transcribed) and Apple's public catalogue API, keeps request rates polite, and in model modes sends the transcript text to the Anthropic API solely to produce the summary. Summaries are machine-generated and may contain errors; verify quotes against the source before publishing them. The Actor is not a consumer reporting agency and its output must not be used for employment, credit, insurance, or tenant screening decisions.