How to Build a Claude-Powered Meeting Notes App

Building a Claude-powered meeting notes app means combining a transcription source (live audio, a recording, or a text transcript) with Claude's language understanding to produce structured summaries, decisions, and action items automatically. The core pipeline is simple: capture or receive a transcript, send it to Claude with a well-designed prompt, and parse the structured output into your app's UI or database.

This guide walks through the architecture, prompt design, and code you need to go from raw transcript to a usable meeting notes feature — whether you're building a standalone product or adding this to an existing tool.

Architecture Overview

A meeting notes app has three main stages:

1. Capture — audio recording, a transcription API (Whisper, AssemblyAI, Deepgram, etc.), or an existing text transcript from a video call tool.
2. Process — send the transcript to Claude with instructions to extract summary, decisions, and action items.
3. Deliver — store the structured output and surface it in a dashboard, Slack message, or email.

Claude only handles stage 2, but it's the stage that determines whether your output is actually useful or just a wall of text. The quality of your prompt and the structure you request matters more than which model tier you pick.

Step 1: Get a Clean Transcript

Claude doesn't do speech-to-text, so you need a transcription layer first. Options include:

• A third-party transcription API that returns timestamped text
• Native transcripts from video platforms (Zoom, Google Meet, Teams often expose these via their APIs)
• Manual upload of a .txt or .vtt file

Strip speaker labels into a consistent format if you have them (e.g. Alex: ..., Priya: ...) — this helps Claude attribute action items correctly later.

Step 2: Design the Extraction Prompt

The key to good meeting notes is forcing structured output instead of a freeform summary. A system prompt like this works well:

You are a meeting notes assistant. Given a raw meeting transcript,
produce output in this exact structure:

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

## Key Decisions
- Bullet list of decisions made, with who made them if known.

## Action Items
- [Owner] Task description — due date if mentioned, otherwise "unspecified"

## Open Questions
- Anything left unresolved or needing follow-up.

Do not invent information not present in the transcript. If a section
has nothing to report, write "None noted."

This structure matters for two reasons: it's easy to parse programmatically (you can split on ## headers), and it forces Claude to separate facts from inference, which reduces hallucinated action items — a real risk if you just ask for "a summary."

Step 3: Call Claude with the Transcript

If you're using Claude directly through Anthropic, you manage API keys, rate limits, and billing yourself. If you want a simpler path — especially for a side project or an internal tool where you don't want to manage separate Anthropic billing per teammate — SubToAPI turns your existing Claude access into a standard HTTPS API with application keys, so you can issue a sub_live_... key per environment or team member without juggling raw Anthropic credentials.

Here's a request using SubToAPI's Messages endpoint:

curl https://api.subtoapi.app/v1/messages \
  -H "Authorization: Bearer $SUBTOAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-3-5-sonnet-20241022",
    "max_tokens": 1024,
    "system": "You are a meeting notes assistant...",
    "messages": [
      {
        "role": "user",
        "content": "Transcript:\n\nAlex: Let'\''s finalize the Q3 roadmap.\nPriya: I'\''ll own the pricing page redesign, done by Friday.\n..."
      }
    ]
  }'

For longer meetings, you'll likely exceed a single request's comfortable size. Long transcripts (over ~6,000 words) benefit from chunking: summarize in 20-minute segments, then run a second Claude call to merge the segment summaries into one final document. This two-pass approach also keeps quality consistent regardless of meeting length.

Step 4: Stream Output for a Better UX

If your app shows notes being generated live (useful for a "processing..." screen right after a call ends), stream the response instead of waiting for the full completion:

const response = 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-3-5-sonnet-20241022",
    max_tokens: 1024,
    stream: true,
    system: systemPrompt,
    messages: [{ role: "user", content: transcriptText }]
  })
});

const reader = response.body.getReader();
// read chunks and append to the UI as they arrive

See /docs/streaming for the full event format and handling partial JSON when you're parsing structured sections mid-stream.

Step 5: Add Action Item Extraction as a Tool Call

If you want action items as clean JSON (owner, task, due date) rather than parsed markdown bullets, use tool use instead of free text. Define a tool schema like:

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

Claude will return a structured tool call instead of prose, which you can insert directly into a database or task tracker. Full examples are in /docs/tools.

Step 6: Handle Teams and Usage

If multiple people on your team are generating meeting notes — sales calls, standups, client reviews — you'll want per-user or per-project API keys rather than one shared credential, plus visibility into how much each is costing. SubToAPI's dashboard gives you team seats and per-key usage metadata so you can see which integration or teammate is driving spend without building your own metering layer. Check /pricing for Solo, Team, and Scale tiers, or start with a free trial at /signup.

Getting Started Quickly

If you want to skip the setup and test the full pipeline end to end, follow /docs/quickstart to get an API key, then reference /docs/messages for the full request/response schema used in the examples above.

Questions

Do I need a separate transcription service, or can Claude transcribe audio directly? Claude works with text, not raw audio, so you need a transcription step first (Whisper, Deepgram, AssemblyAI, or a platform's built-in transcript export) before sending content to Claude for summarization.

How do I stop Claude from inventing action items that weren't actually discussed? Explicitly instruct the model not to infer information absent from the transcript, and use "None noted" as a fallback for empty sections — this reduces hallucination significantly compared to open-ended summary prompts.

What's the best way to handle very long meetings (over an hour)? Chunk the transcript into smaller segments, summarize each independently, then run a second Claude pass that merges the segment summaries into one coherent final document.