Zoom MCP Server Meeting Summary (2026)
Meeting documentation consumes significant developer time Recording decisions, tracking action items, and distributing summaries often become manual processes that interrupt deep work. Combining Zoom’s meeting capabilities with Claude Code through the Model Context Protocol creates a powerful automation pipeline that transforms raw meeting data into actionable documentation.
This guide walks through building a complete Zoom meeting summary automation workflow using MCP servers, with practical code examples you can adapt for your team.
The Real Cost of Manual Meeting Documentation
Before diving into the technical setup, it is worth understanding the problem clearly, because the solution only makes sense if you have the right motivation for building it.
For a typical engineering team running five to eight meetings per week. standups, planning sessions, retrospectives, design reviews. the manual documentation overhead adds up quickly. Someone needs to take notes in real time, which means that person is not fully engaged in the discussion. After the meeting, those notes need to be cleaned up, formatted, and distributed. Action items need to be extracted and entered into a project management system. If the meeting was recorded, the transcript needs to be reviewed to catch anything the note-taker missed.
Conservatively, this costs thirty to sixty minutes per meeting in combined time across all participants when you account for the follow-up distribution and action item tracking. For a team of eight running seven meetings per week, that is somewhere between three and seven person-hours per week spent on documentation rather than on work.
The Zoom MCP server integration eliminates most of this. With the right setup, a meeting ends and within minutes a structured summary. with decisions, action items, follow-up owners, and deadlines. is automatically available in whatever system your team uses.
How Zoom MCP Server Integration Works
The Zoom MCP server connects Claude Code directly to your Zoom account through the Zoom API. This connection enables Claude to:
- Fetch meeting recordings and transcripts
- Retrieve meeting participant lists
- Access chat messages from meetings
- Create and update meeting records
The key insight is that Claude Code can process these meeting artifacts intelligently, extracting key decisions, action items, and summaries without manual intervention.
The architecture is straightforward: your Claude Code instance runs locally (or on a server), the MCP server acts as a translation layer between Claude’s tool calls and the Zoom API, and Zoom’s cloud infrastructure handles recording storage and transcription. Claude never touches the audio. it only reads the text transcript that Zoom’s own transcription service generates, then applies reasoning and summarization on top.
This means the quality of the output depends partly on Zoom’s transcription accuracy. For most modern meetings with good audio, Zoom’s automatic transcription is accurate enough to serve as the raw material for Claude’s summarization. Meetings with heavy technical jargon, multiple simultaneous speakers, or poor audio will produce noisier transcripts, and Claude’s summaries will reflect that noise. For high-stakes meetings, it is always worth doing a quick scan of the raw transcript before distributing a Claude-generated summary.
Setting Up Your Zoom MCP Server
First, you’ll need to create a Zoom OAuth app to authenticate the MCP server:
- Go to the Zoom Marketplace
- Navigate to “Build App” and select “OAuth”
- Choose “User-managed app” for personal use or “Account-level app” for team deployment
- Set the redirect URL to
http://localhost:8080/callback - Note your Client ID and Client Secret
Install the Zoom MCP server package:
npm install -g @modelcontextprotocol/server-zoom
Configure Claude Code to use the server by adding it to your configuration:
{
"mcpServers": {
"zoom": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-zoom"],
"env": {
"ZOOM_CLIENT_ID": "your_client_id",
"ZOOM_CLIENT_SECRET": "your_client_secret",
"ZOOM_ACCOUNT_ID": "your_account_id"
}
}
}
}
Restart Claude Code to load the new server configuration.
Verifying the Connection
Once the server is configured, verify the connection before building your automation. Run a simple test that lists your recent meetings:
In your Claude Code session, ask Claude to list recent meetings
Claude will call the Zoom MCP server and return results like:
- Meeting ID: 123456789
- Topic: Weekly Team Sync
- Start Time: 2026-03-18 10:00 AM
- Duration: 47 minutes
- Recording Available: Yes
If this returns data, your OAuth credentials are working and the MCP server can reach the Zoom API. If you get authentication errors, double-check that your OAuth app has the meeting:read and recording:read scopes enabled in the Zoom Marketplace configuration.
Building the Meeting Summary Automation
With the Zoom MCP server connected, you can now build automation workflows. Here’s a practical example that fetches recent meetings and generates summaries:
// meeting-summarizer.js
// Claude Code skill for automated meeting summaries
const ZOOM_API_BASE = "https://api.zoom.us/v2";
async function getRecentMeetings(daysBack = 7) {
const since = new Date();
since.setDate(since.getDate() - daysBack);
return await claude.mcpCall("zoom", "list_meetings", {
from: since.toISOString().split('T')[0],
type: "past"
});
}
async function getMeetingTranscript(meetingId) {
return await claude.mcpCall("zoom", "get_recording", {
meetingId: meetingId
});
}
async function generateSummary(transcript) {
const prompt = `
Analyze this meeting transcript and create a structured summary with:
1. Key Decisions: List specific decisions made
2. Action Items: Who committed to what
3. Discussion Topics: Main points covered
4. Next Steps: Planned follow-up actions
Transcript:
${transcript}
`;
return await claude.messages.create({
model: "claude-sonnet-4-20250514",
max_tokens: 2000,
messages: [{ role: "user", content: prompt }]
});
}
The generateSummary function prompt above is intentionally simple for readability. In production, you will get better results by tailoring the prompt to the specific meeting type. A planning meeting needs different extraction than a retrospective, and a client call needs different framing than an internal sync.
Here is a more complete prompt template that adapts based on meeting type:
function buildSummaryPrompt(transcript, meetingType = "general") {
const baseInstructions = `
You are a technical meeting documenter. Your summaries are read by engineers,
not executives. be specific, not fluffy. Avoid phrases like "the team discussed"
in favor of actual content: what was decided and by whom.
`;
const typeSpecificInstructions = {
standup: `
Format output as:
- Yesterday: [list of completed items per person]
- Today: [list of planned items per person]
- Blockers: [list of blockers with owner]
`,
retrospective: `
Format output as:
- What went well: [list]
- What didn't go well: [list]
- Action items with owners: [list]
- Experiments to try next sprint: [list]
`,
planning: `
Format output as:
- Sprint goal: [one sentence]
- Committed stories: [list with story points]
- Deferred: [what was discussed but not committed]
- Open questions: [anything unresolved]
`,
general: `
Format output as:
- Key decisions: [list]
- Action items: [owner: task by deadline]
- Topics covered: [list]
- Follow-up needed: [list]
`
};
return `${baseInstructions}\n\n${typeSpecificInstructions[meetingType]}\n\nTranscript:\n${transcript}`;
}
Practical Workflow Examples
Daily Standup Summary Automation
For teams running daily standups over Zoom, automate the documentation process:
Standup-automation-skill.md
name: daily-standup-summarizer
description: Automatically summarize daily standup meetings
A practical standup automation runs immediately after the meeting ends. Use a cron job or webhook trigger:
// standup-trigger.js
// Called by cron 15 minutes after standup end time
const STANDUP_MEETING_ID_PATTERN = /standup|daily|sync/i;
async function processTodayStandup() {
const today = new Date().toISOString().split('T')[0];
const meetings = await getRecentMeetings(1);
const standup = meetings.find(m =>
STANDUP_MEETING_ID_PATTERN.test(m.topic) &&
m.start_time.startsWith(today)
);
if (!standup) {
console.log("No standup found for today");
return;
}
const transcript = await getMeetingTranscript(standup.id);
const prompt = buildSummaryPrompt(transcript, "standup");
const summary = await generateSummary(prompt);
// Post to Slack channel
await postToSlack("#daily-updates", summary);
console.log(`Standup summary posted for ${today}`);
}
Sprint Retrospective Processing
After sprint retrospectives, extract action items automatically using the tdd skill for test creation or the supermemory skill for persistent storage:
// Process retrospective meeting
const retrospective = await getMeetingTranscript(retroMeetingId);
// Extract action items using Claude's analysis
const actionItems = await claude.analyze(retrospective, {
extraction: {
type: "action_items",
fields: ["owner", "deadline", "description", "priority"]
}
});
// Store in supermemory for tracking
await claude.mcpCall("supermemory", "store", {
collection: "sprint-actions",
items: actionItems
});
What makes retrospective processing particularly valuable is the longitudinal tracking. When action items from retrospectives are stored consistently in a structured format, you can run queries across multiple sprints to identify patterns: which types of issues keep recurring, which team members tend to own the most action items, which categories of improvement (process, tooling, communication) are generating the most discussion.
After six sprints of collected data, that analysis can inform quarterly planning in ways that are impossible when retrospective notes live in scattered documents.
Design Review Documentation
Design review meetings generate specific artifacts that differ from standard meeting summaries. you need decisions tied to specific design choices, not just a general list of what was discussed:
async function processDesignReview(meetingId, designDocUrl) {
const transcript = await getMeetingTranscript(meetingId);
const prompt = `
This transcript is from a design review meeting for: ${designDocUrl}
Extract:
1. Design decisions approved (with rationale if stated)
2. Design changes requested (specific, actionable)
3. Open questions that need answers before proceeding
4. Who approved/requested each item
Be specific about design elements. mention component names, API endpoints,
data models, or UI elements by name if they were referenced in the meeting.
Transcript:
${transcript}
`;
return await generateSummary(prompt);
}
Advanced: PDF Report Generation
Transform meeting summaries into professional PDF reports using the pdf skill for client deliverables:
const { PDFDocument, rgb } = require('pdfkit');
async function generateMeetingReport(meetingData, summary) {
const pdfDoc = new PDFDocument();
// Add title
pdfDoc.fontSize(20).text(`Meeting Summary: ${meetingData.topic}`, {
align: 'center'
});
// Add metadata
pdfDoc.fontSize(12)
.text(`Date: ${meetingData.start_time}`)
.text(`Duration: ${meetingData.duration} minutes`)
.text(`Participants: ${meetingData.participants.length}`);
// Add summary sections
pdfDoc.addPage();
pdfDoc.fontSize(16).text('Key Decisions', { underline: true });
pdfDoc.fontSize(12).text(summary.decisions.join('\n\n'));
pdfDoc.addPage();
pdfDoc.fontSize(16).text('Action Items', { underline: true });
summary.actionItems.forEach((item, i) => {
pdfDoc.text(`${i + 1}. ${item.description} (${item.owner}) - ${item.deadline}`);
});
return pdfDoc;
}
PDF reports are most useful for client-facing contexts where you need to send a polished artifact rather than a Slack message or Notion page. The report can include your company branding, be version-stamped, and attached to a formal email chain. For internal use, Notion or Slack is usually more convenient because the content stays searchable and linkable.
Security Considerations
When automating meeting data access, follow these security practices:
- Scope permissions narrowly: Only request OAuth scopes necessary for your automation
- Rotate credentials regularly: Set up automated credential refresh
- Audit access logs: Monitor which meetings are being accessed
- Encrypt sensitive data: Use environment variables for credentials, never commit them to version control
Two additional considerations often get overlooked. First, meeting participants generally expect their words to be recorded if a recording is active, but they may not expect those recordings to be processed by an AI system and distributed as automated summaries. Having a clear team policy about this. and communicating it to all participants, including guests. is both courteous and, in some jurisdictions, legally relevant.
Second, if your meetings involve confidential information (legal discussions, unreleased product details, personnel matters), consider whether those meetings should be excluded from automation entirely. A simple allowlist of meeting topic patterns, rather than processing all meetings, reduces the risk of sensitive summaries landing in the wrong place.
Common Integration Patterns
Teams typically combine the Zoom MCP server with other integrations:
- Slack: Post summaries directly to channels using the slack-mcp-server
- Notion: Store meeting notes in team wikis via the Notion API
- Linear: Create tasks from action items automatically
- Supermemory: Maintain persistent context across meetings using the supermemory skill
The most useful integration pattern is one that mirrors how your team already communicates. If decisions live in Notion and tasks live in Linear, an automation that writes summaries to Slack but not to Notion creates a new silo rather than reducing one. Map the output destinations to where your team actually looks for information.
Here is a complete distribution function that handles multiple destinations:
async function distributeSummary(summary, meetingMetadata) {
const tasks = [];
// Always post to Slack
tasks.push(
postToSlack(`#${meetingMetadata.slackChannel}`, formatForSlack(summary))
);
// Store in Notion if it's a recurring meeting
if (meetingMetadata.notionPageId) {
tasks.push(
appendToNotionPage(meetingMetadata.notionPageId, formatForNotion(summary))
);
}
// Create Linear tasks for action items
if (summary.actionItems && summary.actionItems.length > 0) {
tasks.push(
createLinearTasks(summary.actionItems, meetingMetadata.linearTeamId)
);
}
await Promise.all(tasks);
console.log(`Summary distributed to ${tasks.length} destinations`);
}
Running distribution in parallel with Promise.all keeps the total time short. the bottleneck is usually Claude’s summarization, not the downstream API calls.
Troubleshooting
If your Zoom MCP server connection fails:
- Verify OAuth credentials are correctly set in environment variables
- Check that your Zoom app has the required scopes (meeting:read, recording:read)
- Ensure your Zoom account has access to the meetings you’re trying to retrieve
- Test API connectivity with
curlto the Zoom API endpoints directly
For transcription issues, ensure Cloud Recordings are enabled in your Zoom account settings and that you have permission to access the recordings.
A common gotcha: Zoom transcripts are not available immediately after a meeting ends. Zoom’s processing pipeline can take anywhere from a few minutes to about thirty minutes depending on meeting length and server load. If your automation runs immediately on meeting end, it will likely get a 404 on the transcript endpoint. Add a delay. ten minutes is usually safe for meetings under an hour. or implement a polling loop that retries every two minutes until the transcript is available:
async function waitForTranscript(meetingId, maxAttempts = 10) {
for (let i = 0; i < maxAttempts; i++) {
const transcript = await getMeetingTranscript(meetingId);
if (transcript && transcript.length > 0) {
return transcript;
}
console.log(`Transcript not ready, waiting 2 minutes... (attempt ${i + 1}/${maxAttempts})`);
await new Promise(resolve => setTimeout(resolve, 120000));
}
throw new Error(`Transcript for meeting ${meetingId} not available after ${maxAttempts} attempts`);
}
Conclusion
Automating Zoom meeting summaries with Claude Code transforms a manual, time-consuming task into a streamlined workflow. By connecting the Zoom MCP server to Claude’s analysis capabilities, you can extract value from every meeting without the overhead of manual documentation.
Start with a simple use case like daily standups, then expand to more complex meeting types as you refine your automation. The combination of MCP servers and Claude Code provides flexibility to customize the workflow to your team’s specific needs.
The most important thing is to start narrow. Pick one meeting type that runs on a predictable schedule, build the automation for that type first, and run it in parallel with your existing manual process for two or three weeks before relying on it exclusively. This gives you time to catch edge cases. unusual meeting structures, poor audio quality, meetings where half the discussion happened in chat. and tune your prompts accordingly. Once one meeting type is running reliably, expanding to others is mostly configuration work rather than engineering.
Try it: Estimate your monthly spend with our Cost Calculator.
Related Reading
- Claude Code MCP Server Setup: Complete Guide 2026
- Slack MCP Server Team Notification Automation
- Telegram MCP Server Bot Automation Workflow
- Integrations Hub
Built by theluckystrike. More at zovo.one
Configure it → Build your MCP config with our MCP Config Generator.