Build a Claude API Meeting Notes Summarizer Tool

What this tool actually needs to do

A meeting notes summarizer tool built on the Claude API takes a raw transcript (or rough notes) and turns it into something a team will actually read: a short summary, a list of decisions made, action items with owners, and open questions. The search for "claude api meeting notes summarizer tool" usually means one of two things: you want to build this yourself with a few API calls, or you want a ready-made integration that already handles auth, formatting, and delivery to Slack or email.

This article covers both paths — the prompt and code you need to build a working summarizer today, and where a hosted layer like SubToAPI removes the operational parts (key management, usage tracking, team access) so you're not reinventing infrastructure around a single prompt.

Why Claude works well for this

Meeting transcripts are messy: filler words, interruptions, people talking over each other, unclear antecedents ("he said he'd handle it"). Claude's long context window handles hour-long transcripts in a single call without chunking, and it's reliably good at structured extraction — turning unstructured dialogue into a consistent JSON or markdown format you can pipe into other tools.

The core pattern is simple: one API call, one well-designed prompt, structured output. No fine-tuning, no vector database, no agent loop required.

The core prompt

The quality of your summarizer depends almost entirely on prompt structure, not model cleverness. Be explicit about the output format and give Claude permission to say "none found" rather than inventing action items that weren't discussed.

You are summarizing a meeting transcript. Extract only what was
actually said — do not infer action items that weren't explicitly
discussed.

Return the following sections in markdown:

## Summary
2-4 sentences covering the purpose and outcome of the meeting.

## Decisions
Bullet list of concrete decisions made. If none, write "No decisions recorded."

## Action Items
For each action item: task, owner (name if mentioned, otherwise "unassigned"), due date if mentioned.

## Open Questions
Unresolved topics that need follow-up.

Transcript:
{transcript}

This structure maps directly onto what people do with meeting notes afterward: scan the summary, check who owns what, follow up on open questions.

Building it with the API directly

If you're calling Claude's API directly, a basic Node implementation looks like this:

async function summarizeMeeting(transcript) {
  const response = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": process.env.ANTHROPIC_API_KEY,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model: "claude-sonnet-4-5",
      max_tokens: 1200,
      messages: [
        {
          role: "user",
          content: `Summarize this meeting transcript into Summary, Decisions, Action Items, and Open Questions sections:\n\n${transcript}`,
        },
      ],
    }),
  });

  const data = await response.json();
  return data.content[0].text;
}

This works fine for a prototype. The problems show up once this moves from "script I run locally" to "tool my team uses": you need a stable API key that isn't tied to one developer's personal Claude account, you need to see how much usage each team member is generating, and you need streaming if you're piping the summary into a live UI rather than waiting for the full response.

Using structured output for action items

If you're feeding action items into a task tracker (Linear, Asana, a database), markdown bullets aren't enough — you need JSON. Claude's tool use feature lets you define a schema and get back structured data instead of parsing text.

const tools = [
  {
    name: "record_action_items",
    description: "Record action items extracted from a meeting transcript",
    input_schema: {
      type: "object",
      properties: {
        action_items: {
          type: "array",
          items: {
            type: "object",
            properties: {
              task: { type: "string" },
              owner: { type: "string" },
              due_date: { type: "string" },
            },
            required: ["task", "owner"],
          },
        },
      },
      required: ["action_items"],
    },
  },
];

This gives you reliable, parseable output you can insert straight into a database or push to a task management API, instead of regex-matching bullet points. See /docs/tools for the full tool-use reference.

Running this on SubToAPI instead of raw API keys

If you're building this as a feature your team or customers will use regularly, SubToAPI gives you an application-level API layer on top of your existing Claude access. Instead of sharing one Anthropic key across scripts and services, you generate scoped sub_live_... keys per app or per environment, and every request routes through a single dashboard where you can see usage per key.

A request from your meeting summarizer service looks like this:

curl https://api.subtoapi.app/v1/messages \
  -H "Authorization: Bearer $SUBTOAPI_KEY" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1200,
    "messages": [
      {"role": "user", "content": "Summarize this meeting transcript: ..."}
    ]
  }'

For longer transcripts where you want to show the summary building up in real time rather than waiting on a long request, streaming is documented at /docs/streaming. Setup takes a few minutes — see /docs/quickstart — and if you're building for a team rather than solo, seat-based plans starting at Solo €9 or Team €19/seat (details at /pricing) mean everyone gets their own key without everyone needing their own Claude subscription.

Handling long transcripts and speaker labels

Two practical details matter more than prompt wording:

• Speaker labels improve accuracy. If your transcription source (Zoom, Otter, Whisper) outputs speaker names or numbers, keep them in the transcript you send to Claude. "Sarah: I'll have the draft by Friday" produces far more reliable owner attribution than unlabeled text.
• Don't truncate transcripts to save tokens unless you have to. Claude's context window comfortably handles full hour-long meetings. Truncating risks cutting off the part where a decision was actually finalized.

questions

Can Claude summarize a 90-minute meeting transcript in one request? Yes. Claude's context window handles transcripts well beyond typical meeting lengths in a single call — no chunking needed for most meetings.

How do I get action items as structured data instead of plain text? Use Claude's tool use feature with a JSON schema defining task, owner, and due date fields. See /docs/tools for implementation details.

Do I need my own Anthropic account to use SubToAPI for this? You connect your existing Claude access and SubToAPI issues application-level API keys on top of it, so you get usage tracking and team seats without managing raw provider keys across your codebase.