# Podcast Summary: AI Show Notes, Chapters & Transcript (`spokentext/podcast-summary`) Actor

Paste a Spotify, Apple Podcasts or RSS link and get an AI summary of the episode: key points, timestamped chapters, quotes, people and brands named, ready-to-paste show notes, plus the full transcript.

- **URL**: https://apify.com/spokentext/podcast-summary.md
- **Developed by:** [clement](https://apify.com/spokentext) (community)
- **Categories:** AI, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 audio minutes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What is Podcast Summary?

**Podcast Summary** turns any podcast episode into a **ready-to-use summary**. Paste a Spotify, Apple Podcasts or Deezer link, an RSS feed or an audio file, and get:

- a clear **title** and a one-paragraph **summary**
- the **key points**, one sentence each
- **timestamped chapters**
- **quotes** copied word for word from the episode, with their time
- the **people, companies and brands** named
- **show notes** in Markdown, ready to paste into Spotify, Apple Podcasts, YouTube or a blog
- the **full transcript**

It is built for podcasters and their editors, content and social media teams, researchers, PR and marketing teams who follow what podcasts say.

### Why use it?

- **One link, everything you need.** Transcript, summary, chapters and show notes in one run.
- **Checked, not invented.** Chapters start at times that exist in the transcript, and a quote is kept only if its words really appear in the episode.
- **Fast.** A 56-minute episode was transcribed and summarised in 42 seconds.
- **Any language.** 99+ languages for the audio; write the summary in the episode's language or another one.
- **Whole shows.** Give a show link and choose how many of its latest episodes to summarise.
- **Pay per use.** Per audio minute, plus one price per summary. No subscription.

Because it runs on Apify, you also get scheduling (summarise every new episode of a show each week), API access, integrations (Make, Zapier, n8n, Google Sheets, Notion via integrations) and exports to JSON, CSV or Excel.

### What data do you get?

| Field | What it is |
|---|---|
| `title` | A clear title for the episode |
| `summary` | What the episode covers and concludes |
| `keyPoints` | The main takeaways |
| `chapters` | Timestamped chapters (`start`, `startSeconds`, `title`) |
| `quotes` | Striking sentences from the episode, with their time |
| `topics` | Keywords |
| `people`, `organizations` | People, companies, brands and products named |
| `showNotes` | Show notes in Markdown with the chapter list |
| `text` | The full transcript |
| `showName`, `episodeTitle`, `publishedAt`, `durationSeconds` | Episode details |

### How to use it

1. Paste one or more links: **Spotify**, **Apple Podcasts** or **Deezer** (episode or show), an **RSS feed**, or a direct **audio or video file**.
2. For a show, set **Episodes per show** to summarise its latest episodes.
3. Optionally choose the **summary language**.
4. Click **Start**. The **Output** tab shows each episode's summary, chapters and transcript.

On the free Apify plan, each run transcribes and summarises up to 10 minutes of audio in total. Paid Apify plans have no such limit.

### How much does it cost?

| | Price (Bronze) |
|---|---|
| Per audio minute transcribed | $0.0027 |
| Per summary (one per episode) | $0.05 |

Silver and Gold tiers pay less. Examples at the Bronze price:

| Episode | Cost |
|---|---|
| 10 minutes | $0.08 |
| 1 hour | $0.21 |
| 4 weekly episodes of 1 hour | $0.85 |

Summaries that fail are not charged, and the transcript is still delivered.

### Input example

```json
{
    "urls": ["https://feeds.simplecast.com/EmVW7VGp"],
    "maxEpisodesPerShow": 1,
    "summaryLanguage": "English"
}
```

### Output example

Real result for a 56-minute Radiolab episode, captured on 2026-11-04 (transcript and some fields shortened):

```json
{
    "showName": "Radiolab",
    "episodeTitle": "The Buried Bodies Case",
    "durationSeconds": 3352,
    "transcribedMinutes": 56,
    "title": "The Buried Bodies Case: A Lawyer’s Duty and a Family’s Pain",
    "summary": "In 1973, after Robert Garrow is captured for a murder, his attorneys Frank Armani and Francis Belge learn from him where two missing young women’s bodies are buried. They face a conflict between protecting client confidences and telling grieving families and investigators what they know [...]",
    "keyPoints": [
        "A plea-bargain attempt to exchange information for a mental-hospital sentence fails.",
        "The complaints against Armani and Belge are ultimately dismissed, and the case becomes a widely taught legal-ethics example."
    ],
    "chapters": [
        { "startSeconds": 0, "start": "0:00", "title": "Introducing the case and its moral questions" },
        { "startSeconds": 137, "start": "2:17", "title": "The Adirondacks killings and the manhunt" },
        { "startSeconds": 493, "start": "8:13", "title": "Frank Armani takes on Garrow’s defense" },
        { "startSeconds": 1893, "start": "31:33", "title": "The plea bargain fails" }
    ],
    "quotes": [
        { "startSeconds": 1635, "start": "27:15", "text": "You're caught between the two moralities." },
        { "startSeconds": 2610, "start": "43:30", "text": "I don't think I was a hero. I just was a lawyer that did his job." }
    ],
    "people": ["Frank Armani", "Robert Garrow", "Hillary LeBlanc"],
    "organizations": ["Radiolab", "WNYC"],
    "showNotes": "Radiolab revisits a case that tests the limits of attorney-client confidentiality. [...]\n\n- 00:00 — Introducing the case and its moral questions\n- 02:17 — The Adirondacks killings and the manhunt\n...",
    "summaryModel": "gpt-6-luna",
    "summaryIsAiGenerated": true,
    "text": "..."
}
```

### Use cases

- **Podcasters:** publish show notes and chapters minutes after recording.
- **Content teams:** turn episodes into blog posts, newsletters and social posts from the key points and quotes.
- **Research and PR:** follow what podcasts in your market say, and which people and brands they name.
- **Learning:** get the essentials of long interviews without listening to all of them.

### FAQ

#### Which podcasts work?

Any public podcast: Spotify, Apple Podcasts and Deezer links are matched to the show's public RSS feed, and RSS feeds, audio files, Overcast and iHeart pages work directly. Video podcasts on YouTube work too, read by Google's Gemini model. Spotify-exclusive and paid episodes have no public audio and cannot be read.

#### How accurate is the summary?

The transcript comes from a Whisper speech recognition model, and the summary from OpenAI's `gpt-6-luna`. Chapter times are snapped to the transcript and quotes are checked against it, so neither can point to something that was not said. The summary and labels are AI-generated, which `summaryIsAiGenerated` states on every result; read them before publishing.

#### Can I get the summary in another language?

Yes. Set **Summary language**, for example to French for an English episode.

#### Can I summarise every new episode automatically?

Yes. Save a run with the show's link as a task, set **Episodes per show** to 1 to 5, turn on **New episodes only**, and schedule it weekly. Each run summarises and charges only the episodes it has not done for you before. To summarise a whole period of a show, set **Published on or after**; you can also pick the dataset of a podcast scraper's run instead of pasting links.

### Limits

- Free Apify plan: 10 minutes of audio per run in total.
- The transcription service is shared; when it is busy, an episode can fail with a message saying when to try again. It is then not charged.
- Music-only episodes have no transcript and no summary, and are not charged.

### Other Actors you may find useful

| Actor | What it does |
|---|---|
| [Spotify Podcast Transcript](https://apify.com/spokentext/spotify-podcast-transcript) | The transcript only, with timestamps and SRT |
| [Audio & Video to Text](https://apify.com/spokentext/audio-video-to-text) | Transcripts of any audio or video file |
| [Subtitle Generator](https://apify.com/spokentext/subtitle-generator) | SRT and VTT subtitles for videos |

### Run it from the API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("spokentext/podcast-summary").call(run_input={
    "urls": ["https://feeds.simplecast.com/EmVW7VGp"],
})
for episode in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(episode["title"])
    for chapter in episode["chapters"]:
        print(chapter["start"], chapter["title"])
```

This Actor is an independent tool. It is not affiliated with or endorsed by Spotify, Apple, Deezer, OpenAI or the podcasts it reads; their names only describe the sources it works with. Summaries are for your own use: the episodes remain their creators' work.

### Feedback

Something failed or gave a wrong result? Open an issue in the **Issues** tab of this page, with the error message from your results: every report is read and fixed. If the Actor saved you time, a rating helps others find it.

# Actor input Schema

## `urls` (type: `array`):

Spotify, Apple Podcasts or Deezer links (episode or show), podcast RSS feed URLs, or direct audio/video file URLs (mp3, m4a, wav, mp4...). Public YouTube videos and Shorts work too.

## `datasetId` (type: `string`):

Pick the dataset of a run of a podcast or Spotify scraper, or any dataset of episode, show, RSS or audio links: every link in it is processed, as if pasted above. Useful to chain this Actor after a scraper.

## `datasetUrlField` (type: `string`):

The field that holds the links. Leave empty to detect it: url, link, episodeUrl, feedUrl, audioUrl, enclosureUrl...

## `datasetMaxItems` (type: `integer`):

Each link read is processed and charged as usual.

## `maxEpisodesPerShow` (type: `integer`):

For show links and RSS feeds: how many of the most recent episodes to transcribe, up to 500. Ignored for single-episode links.

## `onlyNewEpisodes` (type: `boolean`):

Skip episodes this Actor already transcribed for your account in an earlier run: they are not charged again. Turn it on when you schedule a show link, so each run only pays for new episodes. The list is kept in a key-value store of your account.

## `publishedAfter` (type: `string`):

For show links and RSS feeds: only episodes published on or after this date. Combine it with "Episodes per show" to take a whole period of a show.

## `language` (type: `string`):

Two-letter language code of the audio (en, fr, es, de...). Leave empty to detect it automatically. Setting it improves accuracy on short or noisy audio.

## `summaryLanguage` (type: `string`):

The language of the summary, chapters and show notes, such as English or French. Leave empty to use the episode's language.

## `includeSegments` (type: `boolean`):

Add a list of timestamped segments (start, end, text) to each result.

## `includeSrt` (type: `boolean`):

Add the transcript as an SRT subtitle file string.

## `includeVtt` (type: `boolean`):

Add the transcript as a WebVTT subtitle file string, the format web video players use.

## `maxMinutesPerEpisode` (type: `integer`):

Longer episodes are cut at this length, so a single run can never cost more than you expect.

## Actor input object example

```json
{
  "urls": [
    "https://video-api.wsj.com/podcast/rss/wsj/minute-briefing"
  ],
  "datasetMaxItems": 100,
  "maxEpisodesPerShow": 1,
  "onlyNewEpisodes": false,
  "includeSegments": false,
  "includeSrt": false,
  "includeVtt": false,
  "maxMinutesPerEpisode": 300
}
```

# Actor output Schema

## `summaries` (type: `string`):

No description

# 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 = {
    "urls": [
        "https://video-api.wsj.com/podcast/rss/wsj/minute-briefing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("spokentext/podcast-summary").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 = { "urls": ["https://video-api.wsj.com/podcast/rss/wsj/minute-briefing"] }

# Run the Actor and wait for it to finish
run = client.actor("spokentext/podcast-summary").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 '{
  "urls": [
    "https://video-api.wsj.com/podcast/rss/wsj/minute-briefing"
  ]
}' |
apify call spokentext/podcast-summary --silent --output-dataset

```

## MCP server setup

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

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/Nvg9Jhhbpiz7XaEDJ/builds/lXc6yxPPEcrAuKhET/openapi.json
