Transcribing and summarizing meetings with n8n: Whisper, GPT and an automatic recap

A one-hour meeting reliably produces three things: a decision someone will ask about again by email two weeks later, two action items nobody is quite sure they own, and a recording sitting untouched in a shared folder. Meeting-recap tools exist (Otter, Fireflies, Fathom…), but they add a per-seat subscription and route your conversations — sometimes confidential ones — through yet another vendor's infrastructure. With n8n and the OpenAI Audio node, you can build the same pipeline in an afternoon, with a single API call and data that stays under your control. Here's how.

The architecture in one paragraph

The pipeline has four steps. The meeting audio (manual upload, a Zoom/Google Meet recording export, or a file dropped into a Drive folder) goes to the OpenAI node in transcription mode (the whisper-1 model), which returns raw text. That text then runs through a Basic LLM Chain paired with a Structured Output Parser that produces structured JSON — summary, decisions, action items with an owner and a deadline. That JSON drives the final step: a Slack message for the team, a Notion page for the archive, and optionally a row in a searchable knowledge base. If you're new to n8n's AI nodes, our guide to the AI Agent node and chains covers the fundamentals you'll need below.

Step 1 — Get the audio

Three common sources, from simplest to most automated:

• Manual upload: an n8n Form Trigger with a file field, useful for testing the pipeline without any external integration.
• Shared folder: a Google Drive "new file" trigger watching a folder where Zoom or Google Meet recording exports land.
• Meeting bot: some tools (Zoom Cloud Recording, Google Meet with Gemini) expose the recording via API or webhook once the meeting ends — the file then arrives directly as workflow input.

One thing to watch from the start: OpenAI's transcription API caps files at 25 MB, roughly 1.5 hours of MP3-compressed audio. Beyond that, you need to split or recompress the audio before sending it — more on that below.

Step 2 — Transcribe with the OpenAI node

Add an OpenAI node, set Resource to Audio and Operation to Transcribe a Recording. Two parameters matter:

• Input Data Field Name: the binary property holding the file received from the previous step (data by default).
• Language: optional but recommended — set it explicitly (ISO-639-1 code, e.g. fr or en) rather than relying on auto-detection. It cuts latency and noticeably improves accuracy, especially with domain-specific vocabulary or regional accents.

The node accepts .flac, .mp3, .mp4, .mpeg, .mpga, .m4a, .ogg, .wav and .webm, and runs on the whisper-1 model. As of writing, OpenAI prices this at roughly $0.006 per minute transcribed — a one-hour meeting costs about $0.35, regardless of how many people were in the room.

Long files (> 25 MB): two options. The simplest is to recompress the audio to mono MP3 at a low bitrate before upload — 64 kbps is plenty for voice, and the 3-5x size reduction solves the problem in most cases. If the file is still too large, an Execute Command node calling ffmpeg to slice the audio into 20-minute chunks does the job; that node is self-hosted only, one more data point for the trade-off covered in our n8n self-hosted vs. cloud comparison.

Step 3 — Summarize with a fixed output format

A free-text summary is hard to consume programmatically downstream. The right pattern is to constrain the model to JSON with a Basic LLM Chain wired to a Structured Output Parser — the pairing covered in our n8n AI nodes guide. Example output schema:

{
  "title": "Weekly product sync",
  "summary": "3-4 sentence synthesis of what was discussed",
  "decisions": ["Decision made #1", "Decision made #2"],
  "actions": [
    { "task": "Send the revised quote", "owner": "Claire", "due": "Friday" }
  ],
  "open_items": ["Unresolved point, to revisit next meeting"]
}

The system message is what separates a generic summary from an actually usable recap:

You summarize a professional meeting transcript.
Extract only what was explicitly said: do not invent any decision,
owner, or deadline that isn't in the text.
If an action item has no clearly assigned owner, mark it
"unassigned" rather than guessing.
Respond strictly according to the provided JSON schema.

For this kind of task — structured extraction, no multi-step reasoning or tool calls — an economical model like GPT-4.1 mini or Claude Haiku is plenty; our guide on connecting Claude or GPT to n8n covers the cost/quality trade-off between models.

Step 4 — Deliver the recap automatically

Once you have the JSON, a Split Out node on the actions array followed by a Slack node (formatted block message) covers the most common case: every participant gets the summary and sees their own action items highlighted. For archiving, a Notion node creates a page in a "Meeting notes" database, with the summary as body text and the actions as properties (status, owner, due date) — usable afterward as a tracking table. This is the same delivery pattern used by the daily email digest workflow in the Inbox AI Pack, applied here to meetings instead of emails.

Step 5 — Archive it so it's actually searchable

A recap nobody can find again has limited value. Two options depending on your needs:

• Simple archive: one row per meeting (date, participants, summary, full transcript, Notion link) in a Supabase table — good enough for basic keyword search or export.
• Semantic search: if your team regularly asks things like "what did we decide about X last month?", vectorize the transcripts using the same architecture as our RAG guide with Supabase pgvector — you get an assistant that can answer while citing the exact meeting and date.

If your meetings touch regulated topics (HR committees, quality reviews, financial decisions), that same table doubles as an audit trail: our guide on logging automations for GDPR compliance shows how to make it tamper-evident — a need natively covered by the workflows in the Compliance & Audit Pack.

Handling failures cleanly

A transcription pipeline rarely fails at random: a corrupted file, the 25 MB limit hit despite compression, an API quota reached. Three nodes cover most of it — Retry On Fail on the transcription call (a side-effect-free request, safe to replay), a Continue Using Error Output branch to notify instead of blocking the whole workflow, and a dedicated Error Workflow that alerts on Slack with a direct link to the failed execution. Our guide on handling errors in n8n walks through setting up all three.

What this actually changes

The gain isn't just the time saved writing the recap — it's reliability: an action item extracted automatically from a transcript doesn't get lost in the handwritten notes of someone who had to leave ten minutes early. For a team running five to ten meetings a week, that's easily one to two hours of write-up time recovered, for an API cost of a few dollars a month.

If you already have AI-powered email triage in place, this pipeline plugs into it naturally: the Inbox AI Pack ships the Slack/Telegram digest building block ready-made — just wire it to the meeting summary output instead of the email-triage output. Same message format, same recipients, one delivery channel for the whole team to manage.