How to Build a Claude-Powered Podcast Summarizer

A podcast summarizer takes a raw audio transcript and turns it into something people actually want to read: a short synopsis, key takeaways, timestamps for notable moments, and maybe quotes worth sharing. Building one with Claude means solving two separate problems — getting a clean transcript, and feeding that transcript to Claude in a way that produces consistent, structured summaries even for two-hour episodes.

This guide walks through the full pipeline: transcription, chunking long audio, prompt design for summarization, and turning the output into structured JSON you can store or display. By the end you'll have a working architecture you can adapt to any podcast feed.

Step 1: Get a transcript

Claude doesn't process raw audio directly, so the first step is transcription. Common options:

• Whisper (OpenAI) or a hosted equivalent — cheap, accurate, widely used
• Deepgram / AssemblyAI — good for speaker diarization and timestamps
• Podcast host APIs — some platforms expose transcripts directly

Whatever you pick, you want timestamped segments, not just a wall of text. Timestamps let you later generate "jump to this moment" links in your summary, which is one of the most useful features a listener-facing summarizer can offer.

A typical transcript segment looks like:

{
  "start": 142.5,
  "end": 148.2,
  "speaker": "Host",
  "text": "So the real question is whether this approach scales past a few thousand users."
}

Step 2: Chunk long transcripts

A one-hour podcast easily produces 8,000–12,000 words of transcript. That's well within Claude's context window, but if you're summarizing multi-hour episodes or batch-processing a whole back catalog, chunking still matters for cost and latency control.

A practical approach:

1. Group transcript segments into ~15-minute blocks
2. Summarize each block independently with Claude
3. Feed the block summaries back into Claude for a final "summary of summaries"

This two-pass approach also makes chapter/timestamp extraction more reliable, since each block summary can retain its own time range.

async function summarizeChunk(chunkText, startTime, endTime) {
  const res = await fetch("https://api.subtoapi.app/v1/messages", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.SUBTOAPI_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "claude-sonnet-4",
      max_tokens: 500,
      messages: [{
        role: "user",
        content: `Summarize this podcast segment (${startTime}s–${endTime}s) in 2-3 sentences. Note any key claims, names, or decisions mentioned.\n\n${chunkText}`
      }]
    })
  });
  return res.json();
}

Step 3: Design the summarization prompt

The quality of a podcast summarizer lives or dies in prompt design. A vague "summarize this" prompt produces generic output. You want a prompt that specifies structure explicitly, because that's what makes the output usable in a UI or a newsletter.

A solid prompt template:

You are summarizing a podcast transcript for listeners deciding whether to tune in.

Produce:
1. A one-paragraph synopsis (max 60 words)
2. 4-6 key takeaways as bullet points
3. Any notable quotes, attributed to the speaker
4. Topics discussed, as a flat list of tags

Return this as JSON matching this schema:
{
  "synopsis": string,
  "takeaways": string[],
  "quotes": [{"speaker": string, "quote": string}],
  "tags": string[]
}

Transcript:
{{transcript}}

Asking Claude to return JSON directly saves you a parsing step later and makes the output easy to store in a database or render in a frontend component.

Step 4: Combine chunk summaries into a full episode summary

Once you have per-chunk JSON summaries, run a final pass that merges them:

async function mergeSummaries(chunkSummaries) {
  const res = await fetch("https://api.subtoapi.app/v1/messages", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.SUBTOAPI_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "claude-sonnet-4",
      max_tokens: 800,
      messages: [{
        role: "user",
        content: `Merge these chunk summaries into a single episode summary, deduplicating overlapping points. Keep the same JSON schema.\n\n${JSON.stringify(chunkSummaries)}`
      }]
    })
  });
  return res.json();
}

This two-pass structure keeps individual Claude calls short and focused, which improves both consistency and cost predictability compared to dumping an entire 90-minute transcript into one prompt.

Step 5: Add timestamp links for key moments

If your transcript segments carry timestamps, ask Claude to reference approximate times for each takeaway or quote. You won't get frame-perfect accuracy, but asking for "the closest timestamp from the provided segments" against segment-tagged input works well enough for jump-to-moment links in a player UI.

Step 6: Stream for long-running jobs

If you're summarizing episodes on demand (a user pastes an RSS link and waits), streaming the final merge step improves perceived speed. SubToAPI supports streaming responses, so the synopsis and takeaways can render progressively instead of the user staring at a spinner for 20 seconds. See the streaming docs for implementation details.

Why run this through SubToAPI instead of raw API access

If you already have Claude access through a Pro or Team seat but want a proper backend integration, SubToAPI turns that into an HTTPS API with sub_live_... application keys, usage metadata per request, and team seat management — useful once you move from a prototype script to a product with multiple contributors hitting the same summarization pipeline. Plans start at €9/month on Solo, with Team and Scale tiers for shared usage. Check pricing or start with the quickstart and the messages endpoint docs to wire this up in under an hour.

Putting it together

A full pipeline looks like: audio → transcription service → chunked transcript → Claude chunk summaries → Claude merge pass → structured JSON stored alongside the episode. From there you can render it in a web app, push it to a newsletter template, or expose it as a public API for other podcast tools to consume.

questions

Do I need Claude to transcribe audio too? No. Claude works with text, so you need a separate transcription step (Whisper, Deepgram, AssemblyAI, or a podcast host's own transcript export) before any summarization happens.

How long can a transcript be before I need to chunk it? Claude's context window can handle most single-episode transcripts whole, but chunking into ~15-minute blocks improves cost control, latency, and timestamp accuracy for episodes over an hour.

Can the summarizer output timestamps for key moments? Yes, if your transcript segments include timestamps. Ask Claude to reference the closest provided timestamp for each takeaway or quote rather than inferring exact times.