Skip to content

Build a podcast summarizer in 20 lines of code

Fetch any episode as Markdown, drop it into an LLM, get a summary back. The whole project is two API calls and a prompt.

Last updated June 2026

The hard part of building a podcast summarizer used to be getting a clean transcript with speaker names. With Spoken, that step is one API call. You search by topic or paste a URL, fetch the transcript as Markdown, and pass it to your LLM of choice with a summary prompt. A typical one-hour episode fits in one context window, so there is nothing to chunk.

The complete summarizer

import requests
from anthropic import Anthropic

API_KEY = "YOUR_SPOKEN_KEY"
client = Anthropic()

def summarize_podcast(query):
    # 1. Find the episode
    r = requests.get(f"https://spoken.md/search?q={query}",
                     headers={"x-api-key": API_KEY})
    results = r.json()["results"]
    if not results:
        return "No matching episodes found."
    episode = results[0]

    # 2. Fetch the transcript
    transcript = requests.get(
        f"https://spoken.md/transcripts/{episode['id']}",
        headers={"x-api-key": API_KEY},
    ).text

    # 3. Summarize
    msg = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"Summarize this podcast episode in 5 bullet points, "
                       f"attributing key points to specific speakers:\n\n{transcript}"
        }],
    )
    return f"# {episode['title']}\n{episode['podcast']}\n\n{msg.content[0].text}"

print(summarize_podcast("huberman sleep"))

Real speaker names land in the prompt as **Andrew Huberman** (0:00), so the LLM can attribute claims without any prompting tricks.

What you'd otherwise be building

The same summarizer without Spoken needs:

  • A podcast search index (or a separate API for episode metadata)
  • An audio download step (locate .mp3, fetch 50–100 MB)
  • A transcription service (Whisper API or self-hosted)
  • A diarization step (Pyannote, or use a service like AssemblyAI that bundles it)
  • A speaker-naming pass (the diarization output is anonymous)
  • Storage and caching so you don't re-transcribe the same episode twice

For a side project, that's a weekend of plumbing. For a production product, it's ongoing infrastructure to maintain.

Output examples

Bullet-point summary

Prompt: "Summarize this podcast in 5 bullets, attributing claims to speakers."

Output:
• **Andrew Huberman** opens by framing the episode around the
  neuroscience of sleep architecture and its impact on next-day cognition.
• **Matt Walker** explains that REM and deep sleep play distinct roles —
  deep sleep consolidates declarative memory; REM consolidates procedural.
• They discuss the 90-minute ultradian cycle and why waking inside a
  cycle (vs at the end of one) produces worse subjective grogginess.
• Walker recommends consistency of sleep timing over total hours as
  the single most impactful intervention for most adults.
• Closing segment covers caffeine's 5–6 hour half-life and Walker's
  suggestion to cut off intake by 2 PM.

Other useful prompts on top of the same Markdown

  • Show notes: "Extract a list of books, papers, and people mentioned, with timestamps."
  • Quote extraction: "Pull 5 quotable lines suitable for social media, attributed to each speaker."
  • Disagreement detection: "Identify points where the speakers disagreed and what each argued."
  • Topical chapters: "Break the episode into chapters with timestamp ranges and one-line descriptions."
  • Q&A extraction: "List every question one speaker asked the other, and the substance of the answer."

Cost per summary

A one-hour podcast is roughly 8,000–15,000 tokens. With Spoken at the 500-pack rate and Claude Haiku as the summarizer:

  • Transcript fetch: $0.10 (Spoken)
  • Summary generation: ~$0.01–$0.02 (Claude Haiku, depending on output length)
  • Total per episode: ~$0.11–$0.12

At the 2,000-pack rate the transcript fetch drops to $0.08, so the all-in cost is around $0.09–$0.10 per episode summarized.

FAQ

Does the transcript fit in one LLM context window?

A Spoken transcript fits in one LLM context window for almost every episode. A one-hour podcast is 8,000–15,000 tokens, and current models from Anthropic, OpenAI and Google all have context windows of 128K tokens or more, so a full episode fits comfortably with room for prompt and output.

Which LLM should I use?

For straight summarization of a Spoken transcript, a small model such as Claude Haiku 5.5 produces strong results at low cost. For nuanced extraction or multi-step reasoning, step up to a larger one such as Claude Sonnet 5.5.

Can I summarize a whole podcast back-catalogue?

Yes. Spoken's /podcasts/{podcastId}/episodes lists every episode of a show that has a transcript, free; loop through and fetch each. Repeat fetches are free, so re-running with a different prompt later doesn't cost more.

What format are the timestamps in?

Spoken's timestamps are per speaker turn, in (H:MM) or (H:MM:SS) form. The LLM can quote them directly when citing specific moments.

Is there a free way to try this?

Yes. Spoken's demo key pt_demo works with any endpoint, no signup needed, and returns a full transcript for the demo episode so you can run the summarizer end-to-end before purchasing credits.

TL;DR: A podcast summarizer is two API calls and a prompt. Spoken returns Markdown with real speaker names; pass it to any LLM. About $0.10 per episode end to end.

"I used Spoken to add every My First Million episode to my knowledge base, with a cron to pull new ones. Now I can enjoy the podcast on a run, then chat with Claude about it later — every episode saved and accessible in my Claude sessions."
Marcus Taylor

Thousands of transcripts fetched by developers building summarizers, RAG pipelines, and podcast tools

No signup needed: the key pt_demo works on any endpoint.

Price my show's archive

$0.10 per transcript. Credits never expire.

Read next