How to Build a Claude-Powered Podcast Transcript Summarizer

What this guide covers

If you're searching for how to build a Claude-powered podcast transcript summarizer, you're probably sitting on hours of raw transcript text (from Whisper, Otter, Descript, or a podcast host's auto-captioning) and need clean show notes, chapter markers, or key takeaways out of it — without manually re-listening to every episode.

The short answer: feed the transcript to Claude in manageable chunks, use a prompt that asks for structured output (summary, quotes, timestamps, action items), and if the transcript is long, run a map-reduce pass where you summarize chunks first and then summarize the summaries. Below is a full build walkthrough, including code.

Why Claude works well for this

Podcast transcripts are messy: filler words, cross-talk, no punctuation discipline, and speaker labels that may or may not be accurate. Claude handles this kind of noisy, long-form text well because it:

• Understands conversational structure even without clean formatting
• Can follow detailed output instructions (bullet summaries, timestamped chapters, pull quotes)
• Handles large context windows, so a 45–60 minute episode often fits in one call
• Can be instructed to preserve speaker attribution even when transcript formatting is inconsistent

Architecture overview

A podcast summarizer pipeline typically looks like this:

1. Transcription — audio to text (Whisper, AssemblyAI, your podcast host's built-in captions)
2. Preprocessing — strip timestamps/noise, or keep them if you want chapter markers
3. Chunking — split long transcripts if they exceed a comfortable context size
4. Summarization — send chunks to Claude with a structured prompt
5. Merge — if chunked, combine chunk summaries into one final episode summary
6. Output — store as show notes, feed into your CMS, or email to subscribers

The summarization step is where most of the engineering effort goes, so that's the focus here.

Step 1: Get a usable transcript

Most transcription tools output either plain text or a timestamped JSON/SRT format. If you want chapter markers in the final summary, keep timestamps attached to each line:

[00:01:12] Host: Today we're talking about...
[00:02:45] Guest: Right, so the way I think about it is...

If you don't need timestamps, strip them before sending to Claude to save tokens.

Step 2: Chunk long transcripts

A one-hour episode can run 8,000–12,000 words. That usually fits in a single request, but for two-hour-plus episodes or multi-guest roundtables, split by natural breaks — ad reads, topic shifts, or every ~15 minutes of audio — rather than by a fixed character count. This keeps each chunk coherent.

function chunkTranscript(lines, maxWordsPerChunk = 3000) {
  const chunks = [];
  let current = [];
  let wordCount = 0;

  for (const line of lines) {
    const words = line.split(" ").length;
    if (wordCount + words > maxWordsPerChunk) {
      chunks.push(current.join("\n"));
      current = [];
      wordCount = 0;
    }
    current.push(line);
    wordCount += words;
  }
  if (current.length) chunks.push(current.join("\n"));
  return chunks;
}

Step 3: Write a summarization prompt that actually works

Vague prompts ("summarize this podcast") produce vague output. Be explicit about structure:

You are summarizing a podcast transcript chunk. Produce:
1. A 2-3 sentence summary of what was discussed in this section
2. 3-5 key points as bullets
3. Any direct quotes worth highlighting, with speaker name
4. Topics mentioned that might need a timestamp/chapter marker

Keep it factual. Do not add opinions or information not in the transcript.

For the final merge step (combining chunk summaries into one episode summary), use a second prompt:

You will receive several section summaries from one podcast episode, in order.
Combine them into:
- A one-paragraph episode summary
- A bulleted list of key takeaways
- A "Quotable Moments" section
- Suggested chapter titles with approximate timestamps if available

Step 4: Call Claude via SubToAPI

Once you have the prompt structure, calling Claude is a single HTTPS request. SubToAPI wraps Claude access behind a standard API key (sub_live_...) so you don't need to manage separate credentials per environment — useful if your summarizer runs in a cron job, a CMS webhook, and a local dev script.

curl https://api.subtoapi.app/v1/messages \
  -H "Authorization: Bearer $SUBTOAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Summarize this podcast transcript chunk:\n\n[00:01:12] Host: ..."
      }
    ]
  }'

For the merge step, send the collected chunk summaries as a single message:

async function summarizeEpisode(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: 1200,
      messages: [
        {
          role: "user",
          content: `Combine these section summaries into one episode summary:\n\n${chunkSummaries.join("\n\n---\n\n")}`,
        },
      ],
    }),
  });
  return res.json();
}

See /docs/quickstart for setup and /docs/messages for the full request/response reference.

Step 5: Stream for long transcripts, or batch for cron jobs

If you're summarizing episodes in a UI where someone is watching progress (a dashboard, an admin panel), use streaming so the summary renders as it's generated instead of after a long wait — see /docs/streaming. If this runs as a background job after publishing, a plain blocking request is simpler and fine.

Step 6: Automate the output

Once summarization works for one episode, wire it into your publishing flow:

• Trigger on new transcript upload (webhook from your transcription tool)
• Chunk → summarize → merge → write to your CMS draft or database
• Optionally generate SEO-friendly show notes and a short social caption in the same pass by adding those as extra output fields in your merge prompt

Scaling it across a team or multiple shows

If more than one person (editor, host, VA) needs to trigger summaries, or you're running this across several podcast feeds, a shared API setup avoids everyone holding separate credentials. SubToAPI's Team plan gives each person their own key under one billing account with usage visibility per key, which matters once you're troubleshooting which job burned through tokens on a 3-hour interview episode. Check /pricing for plan details, or /signup to get a key and test the quickstart flow directly against the prompts above.

Questions

Does Claude need the full transcript in one request? No. For most single-episode transcripts under roughly an hour, one request is enough. Longer or multi-guest episodes benefit from chunking by topic or time segment, then merging summaries in a second pass.

How do I keep speaker names accurate in the summary? Preserve speaker labels in the transcript before summarizing, and explicitly instruct Claude to attribute quotes and points to the correct speaker rather than inferring from context.

Can I get timestamped chapter markers automatically? Yes, if your transcript includes timestamps. Keep them in the chunked text and ask Claude to suggest chapter titles tied to approximate timestamps in the merge-step prompt.