# Podcast Episode Summarizer (AI) — Transcript to Summary (`owlabee/podcast-episode-summarizer`) Actor

Summarize podcast episodes from RSS feeds or Apple Podcasts links: abstract, key topics, timestamped chapters, quotes, guests and action items from each Podcasting 2.0 transcript (show notes fallback). Free extractive mode, or Claude with your key or ours. Pay per episode.

- **URL**: https://apify.com/owlabee/podcast-episode-summarizer.md
- **Developed by:** [Owlabee](https://apify.com/owlabee) (community)
- **Categories:** AI, For creators
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 episode summarized (hosted, fast tier)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 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:

```json
{
  "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:

```json
{
  "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 |
|---|---|---|
| Extractively summarized episode | $0.002 | Per episode item in `extractive` mode or on an `extractive-fallback`; error items are charged at this price too |
| BYOK summarized episode | $0.005 | Per episode summarized by Claude in `byok` mode, any tier; your tokens are billed by Anthropic, not here |
| Hosted fast-tier summarized episode | $0.02 | Claude Haiku 5.5 on the Actor's key, tokens included, up to 40,000 input tokens per episode |
| Hosted balanced-tier summarized episode | $0.25 | Claude Sonnet 5.5, same caps |
| Hosted best-tier summarized episode | $0.50 | Claude Opus 5.5, same caps |
| Fetched feed | $0.01 | Per feed the run attempts, resolved or not (unresolvable input, failed download, no matching episodes, time budget); charged once per feed, before its episodes |
| Actor start | $0.00005 | Apify platform event |

**Worked examples.** Hosted `fast` (the default): 100 one-hour episodes from one feed ≈ $2.00 + $0.01 for the feed ≈ **$2.01**, nothing else to pay; `balanced` ≈ **$25.01**; `best` ≈ **$50.01**. 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 from one feed ≈ **$2.01**.

**Store pricing discounts:** users on the Scale plan (Silver) pay 10% less per event, Business (Gold) 15–20% less.

**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.

# Actor input Schema

## `feeds` (type: `array`):

One entry per line. Podcast RSS/Atom feed URLs, Apple Podcasts show URLs (https://podcasts.apple.com/…/id123456789, resolved through the public iTunes Lookup API), bare Apple IDs, or search terms written as `search:the daily`. A show's web page works too when it carries an RSS autodiscovery link. The prefilled feed is the cheap, always-available example used by Apify's daily automated test.

## `maxEpisodesPerFeed` (type: `integer`):

Newest-first cap on episodes summarized per feed. Each summarized episode is one charged item.

## `episodes` (type: `array`):

Episode GUIDs, episode page URLs or audio URLs, one per line. When set, only matching episodes from the feeds above are summarized (still capped by Max episodes per feed). Leave empty for the newest episodes.

## `summarizer` (type: `string`):

Leave empty for the default (the Console prefills `extractive` so Apify's daily automated test never calls a model; clear it or pick a mode): AI summaries by the hosted Claude model (`hosted`) when the Actor has its model key configured, otherwise the free extractive summarizer. Set `extractive` for a free, model-free run (deterministic text-rank summary with keyword topics, no key), or `byok` to use your own Anthropic API key (tokens billed by Anthropic to you). In hosted mode a model problem never fails the run: the episode gets the extractive summary, `summaryMethod: "extractive-fallback"` and is charged the extractive price.

## `anthropicApiKey` (type: `string`):

Your Anthropic API key, used only when Summarizer is `byok`. Stored encrypted as a secret and sent only to api.anthropic.com. Get one at console.anthropic.com.

## `modelTier` (type: `string`):

`fast` (default): Claude Haiku 5.5, cheapest and quick. `balanced`: Claude Sonnet 5.5, better abstracts and chapter titles. `best`: Claude Opus 5.5 for the most nuanced summaries. In hosted mode the tier sets the per-episode price ($0.02 / $0.25 / $0.50); in byok mode the tier only changes what Anthropic bills you.

## `maxInputTokens` (type: `integer`):

Transcripts longer than this (estimated) are cut to the cap before the model call and the item is marked `inputTruncated: true`. 40,000 tokens is roughly 3 hours of speech. Lower it to cut your own token cost in byok mode.

## `maxConcurrency` (type: `integer`):

Episodes processed in parallel per feed (transcript downloads and model calls). Requests to the same host are spaced at least 500 ms apart.

## `maxSecondsPerFeed` (type: `integer`):

Time budget for one feed (download, transcripts and summaries). When it runs out, or when no summary was produced for 60 seconds because transcript downloads keep timing out, the remaining episodes of that feed are skipped; summaries already made are kept and charged. If nothing was produced, one error item with `error: "TIME_BUDGET"` is saved.

## `webhookUrl` (type: `string`):

If set, the Actor POSTs a JSON summary of the run (per-feed counts, model token totals) to this URL — 10 s timeout, 2 retries. Failures are logged, never fatal.

## Actor input object example

```json
{
  "feeds": [
    "https://podnews.net/rss"
  ],
  "maxEpisodesPerFeed": 2,
  "summarizer": "extractive",
  "modelTier": "fast",
  "maxInputTokens": 40000,
  "maxConcurrency": 3,
  "maxSecondsPerFeed": 1800
}
```

# Actor output Schema

## `results` (type: `string`):

One item per episode in the default dataset (showTitle, title, pubDate, durationSeconds, summaryMethod, modelTier, transcriptSource, summary.abstract, summary.keyTopics, summary.chapters, modelCostUsdEstimate; error items carry error and errorMessage). Fields are described in dataset_schema.json.

## `summary` (type: `string`):

SUMMARY record in the run's default key-value store: episodes summarized, summary methods used, model cost estimate, charges and webhook delivery status, written when the run finishes.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "feeds": [
        "https://podnews.net/rss"
    ],
    "maxEpisodesPerFeed": 2,
    "summarizer": "extractive"
};

// Run the Actor and wait for it to finish
const run = await client.actor("owlabee/podcast-episode-summarizer").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "feeds": ["https://podnews.net/rss"],
    "maxEpisodesPerFeed": 2,
    "summarizer": "extractive",
}

# Run the Actor and wait for it to finish
run = client.actor("owlabee/podcast-episode-summarizer").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "feeds": [
    "https://podnews.net/rss"
  ],
  "maxEpisodesPerFeed": 2,
  "summarizer": "extractive"
}' |
apify call owlabee/podcast-episode-summarizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,owlabee/podcast-episode-summarizer"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2nVdSjjavYz4rEdeg/builds/gfFRapNyANaRBPaOg/openapi.json