Zoom MCP Server Cursor IDE Setup 2026: mcp.json + OAuth Config

How do you set up the Zoom MCP server in Cursor? Add a zoom entry under mcpServers in ~/.cursor/mcp.json pointing at Zoom's official hosted endpoint, https://mcp.zoom.us/mcp/zoom/streamable. Restart Cursor, ask something that requires real meeting data, and complete the OAuth authorization-code flow that opens in your browser. There's no API key to paste into config — Zoom's own MCP server runs remotely and authenticates through the same OAuth app model Zoom uses for any Marketplace integration.

This page covers Zoom's official server: the exact endpoint, the OAuth setup a General App on the Marketplace requires, the nine tools Zoom documents by name, and what each one actually does — as opposed to a third-party transcript scraper or a Composio/Merge bridge, which are different products with different setup steps.

What the Zoom MCP server is for

Zoom's MCP server exposes what's already sitting in your Zoom account — meeting recordings, AI-generated summaries, transcripts, Team Chat and Canvas content, and notes — to any MCP-compatible client. The practical use case for a developer is less "schedule my meetings" and more "pull the actual content of that stand-up from Tuesday without opening the Zoom app, searching for the recording, and reading the summary by hand." Cursor becomes a place you can ask "what did we decide about the API versioning approach in yesterday's call" and get an answer sourced from a real transcript, not a guess.

Quick reference

The nine tools Zoom documents

Unlike a lot of community MCP servers that wrap a REST API one endpoint at a time, Zoom's official server ships a fixed, named tool set:

Two things worth noting before you start prompting: there's no plain get_meeting tool by that name, and transcript access goes through get_recording_resource rather than a dedicated search_transcripts tool. If you're translating a prompt from a different MCP server's naming conventions, don't assume Zoom's tool names match — check this list first.

Prerequisites

Step 1: Create a Zoom General App for MCP scopes

Zoom's MCP integration authenticates through a Marketplace OAuth app, not a bare account login — this is the detail that trips people up coming from a server like Stripe's or GitLab's, which onboard with plain personal OAuth. Go to the Zoom Marketplace's app template selector and create a General App. This app is what actually holds the OAuth client identity and, critically, the MCP-specific scopes — these are a distinct scope category from the standard Zoom REST API scopes you'd add for a normal integration, so don't assume the scopes you already granted a different Zoom app carry over.

Step 2: Add the server to Cursor's mcp.json

{
  "mcpServers": {
    "zoom": {
      "url": "https://mcp.zoom.us/mcp/zoom/streamable"
    }
  }
}

Save this to ~/.cursor/mcp.json for a connection available everywhere, or .cursor/mcp.json in a project root if only that workspace should reach it. No headers, no token, no command/args bridge — this is a native remote-URL entry, the same shape Cursor uses for other hosted-OAuth servers on this site.

Step 3: Restart Cursor and authorize

1. Quit and restart Cursor completely.
2. Open a new chat and ask something that requires real Zoom data — for example: "Find the meeting where we discussed the Q3 roadmap and summarize the decisions."
3. Cursor opens a browser window for Zoom's OAuth authorization-code flow. Sign in if needed and review the scopes the General App is requesting before approving.
4. Approve it. The token is cached by Cursor's MCP client, so this shouldn't recur unless the grant expires or you revoke it from the Marketplace app's settings.

If your Cursor build can't hold a client secret safely (common in some sandboxed or portable installs), the flow falls back to PKCE automatically — this is Zoom's documented behavior, not something you configure manually.

Practical workflows

Catching up on a missed meeting:

Search Zoom for the standup from yesterday and give me a summary of what was decided, plus any action items assigned to me.

Pulling a decision into a PR description:

Find the recording where we discussed the API versioning approach, get the recording resource, and summarize the reasoning so I can paste it into a pull request description.

Listing recent recordings before a retro:

List all cloud recordings from the last two weeks so I can pick which ones to reference in tomorrow's retro.

Turning a meeting into written notes:

Take the summary from today's design review call and create a new Canvas file with it, formatted as a decision log.

That last one is create_new_file_with_markdown in action — it's the tool that makes this a two-way integration rather than a read-only meeting archive: Cursor can write a generated artifact back into Zoom's Canvas or My Notes, not just pull content out of it.

Cross-referencing chat and meeting content:

Search across my Zoom Team Chat and recent meetings for anything mentioning "rate limit" from this week.

That's search_zoom, not search_meetings — the distinction matters because a prompt scoped only to meetings won't surface a relevant Team Chat thread even if it used the exact phrase you're looking for.

When this isn't the right tool

If your team's calls aren't recorded, or recordings exist without Smart Recording or Meeting Summary turned on, most of what makes this integration valuable — semantic search over content, AI-backed summaries — has nothing to search against. recordings_list will return entries, but search_meetings on a library of un-transcribed raw video is a much weaker tool than the same call against summarized ones. Turn on Meeting Summary at the account level before judging whether this integration is worth the setup time.

Also worth flagging: because meeting content can include sensitive discussion — compensation, incident postmortems naming individuals, unreleased product plans — treat the OAuth grant with the same care you'd give a GitHub token with broad repo access. Anyone who can prompt Cursor in a session with this server connected can, in principle, ask it to search and summarize anything the underlying account can see.

Troubleshooting

Server never appears in Cursor. Confirm the file is ~/.cursor/mcp.json or .cursor/mcp.json, the top-level key is mcpServers, and the JSON is syntactically valid — one bad comma drops every server in that file.

OAuth popup never opens, or authorization fails immediately. Confirm the Marketplace app is a General App with MCP scopes actually added — a General App created for a different, older integration on the same account won't automatically carry these scopes. Add them explicitly in the app's scope configuration before retrying.

search_meetings returns nothing for a call you know happened. Check whether that specific recording has Smart Recording or an AI-generated summary attached. A recording with neither is a much weaker search target — try recordings_list scoped to the date instead, then use get_recording_resource on the specific result once you've identified it by date and time rather than by semantic search.

Getting the platform-level account's content instead of the workspace/team you expected. Confirm which Zoom account the OAuth grant actually authorized, particularly on larger organizations with multiple Zoom accounts or sub-accounts — the grant is scoped to whichever account you were logged into during the browser approval step, not necessarily the one you assumed.

Writes to Canvas or My Notes don't show up where expected. create_new_file_with_markdown and the Hub equivalents create new files rather than appending to existing ones — if you expected an update to an existing Canvas page, ask Cursor to fetch and rewrite the existing file's content with get_file_content first rather than assuming the write tool merges into what's already there.

Everything works but responses feel slow. Streamable HTTP round-trips to a hosted server carrying meeting-length transcripts are inherently heavier than a database lookup — expect noticeably longer tool-call latency on get_recording_resource for a long meeting than on recordings_list, which only returns metadata.

Frequently Asked Questions

Is there an official Zoom MCP server, or only third-party ones? Both exist, and they're not interchangeable. Zoom itself hosts the official server at mcp.zoom.us/mcp/zoom/streamable, documented in Zoom's own developer skills repository — that's what this guide covers. Third-party servers, like standalone transcript scrapers, wrap a narrower slice of functionality and use their own separate setup and auth.

Do I need a Zoom developer account or paid plan? You need permission to create a Marketplace General App on the account, and cloud recording enabled to get real value from the content-search tools. The MCP connection itself doesn't require a separate developer-specific Zoom plan beyond what your account already needs for cloud recording and AI Companion features.

What's the exact Zoom MCP server Cursor IDE setup process, start to finish? Create a Marketplace General App with MCP scopes, add a zoom entry to mcp.json with url set to https://mcp.zoom.us/mcp/zoom/streamable, restart Cursor, ask a Zoom-related question, and approve the OAuth authorization-code prompt in your browser. No API key or local server process is involved.

Can Cursor write content back into Zoom, or only read meeting data? Both. create_new_file_with_markdown and the hub_create_file_from_content / hub_get_file_content pair let Cursor generate and push content — summaries, decision logs, notes — into Canvas, My Notes, or Hub, not just pull recordings and transcripts out.

Why does search return poor results for some meetings and great results for others? Almost always Smart Recording / Meeting Summary status. Meetings with an AI-generated summary attached are far more searchable through search_meetings than raw, un-summarized recordings. Enable Meeting Summary at the account level if this keeps happening across most of your calls.

Is this the same thing as Zoom AI Companion? Related but not identical. AI Companion is the feature that generates meeting summaries and notes inside Zoom itself; the MCP server is the protocol-level interface that lets an external client like Cursor query that content (and the rest of the account) programmatically. AI Companion being enabled on your account is what makes the MCP server's summary-dependent tools actually useful.

Does the Zoom MCP server work with SSE instead of streamable HTTP? Zoom's own documentation describes streamable HTTP as the primary transport at this endpoint and doesn't guarantee an SSE fallback the way some other vendors' servers do. Use the url-based streamable HTTP entry shown above rather than assuming an /sse path is equivalent.

Related guides

Official docs cited