How to connect a Zoom MCP to Cursor (4 steps)

You already write and reason about your code in Cursor. But the moment you start building something that integrates with Zoom, like a recording-archival job, you need details that only live in your Zoom account.

What does a recording's file list actually contain, given that one meeting returns several file types? How is the VTT transcript structured? And how do you encode a meeting UUID that starts with a slash?

Without the MCP connection, answering those questions means leaving the editor, authenticating against Zoom's API separately, running test calls, and pasting responses back into the session where the integration code is being written.

To help your developers inspect Zoom's data model and query real meeting data without leaving Cursor, we'll show you how to connect Zoom with Merge Agent Handler's Zoom MCP server.

How it works

Merge Agent Handler connects Cursor to the Zoom API through the Merge CLI.

You install the CLI, authenticate once, and run a single setup command from your project root. That command writes a ## Merge CLI section to the project's .cursorrules file, which tells Cursor's agent when to call merge search-tools and merge execute-tool to reach Zoom.

Once connected, Merge handles Zoom's OAuth token lifecycle so you never store credentials locally or rewire auth when tokens change.

Prerequisites

Before getting started, you'll need the following:

• A Merge Agent Handler account
• Cursor installed
• pipx installed (run pipx --version to confirm, or install via pip install pipx)
• A Zoom account, with cloud recording enabled if you want recording and transcript access

If you want to connect Merge Agent Handler's Zoom MCP with internal or customer-facing agentic products, you can follow the steps in our docs.

1. Install the Merge CLI

Run the following to install the Merge CLI: pipx install merge-api

Verify your installation: merge --version

Related: How to use the Zoom MCP in Claude Code

2. Log in to Merge

Authenticate the CLI with your Merge Agent Handler account: merge login

This links the CLI to your account so it can make authorized requests to Zoom on your behalf.

3. Connect the CLI to Cursor

Run the following from the root of the project where you want to use Merge tools:

merge setup cursor

This writes a ## Merge CLI section to .cursorrules so Cursor knows to use the CLI for third-party services. The command is idempotent, safe to re-run if you need to reset.

Related: The steps for integrating a Zoom MCP with Codex

4. Authenticate Zoom

Open a Cursor chat in your project and try a prompt like:

Fetch a recent meeting's recording files and its transcript so I can see the exact file list and VTT structure before I write the download-and-parse code.

The first time you invoke a Zoom tool, a Magic Link will appear to complete connector authentication.

{{this-blog-only-cta}}

Zoom MCP FAQ

In case you have more questions on setting up and using the Zoom MCP in Cursor, we've addressed several more commonly-asked questions below.

What can you do once the Zoom MCP is connected to Cursor?

With Zoom connected, Cursor can:

• Inspect a recording's file list before writing download code: fetch a real recording to see the full set of files one meeting returns, video, audio, chat, and transcript, so the download and storage code you write handles each file type and its download URL correctly

• Check the VTT transcript structure before writing a parser: retrieve a real transcript to see the exact timestamp and speaker-label format before writing the code that parses or chunks it

• Confirm meeting UUID encoding before writing endpoint paths: fetch a meeting whose UUID starts with a slash or contains double slashes so you can write the double URL-encoding your API calls need before they fail in production

• Inspect participant object fields before writing attendance logic: pull a meeting's participant list to see the join and leave timestamp formats before writing reporting or duration-calculation code

• Validate the meeting settings object before writing creation code: retrieve a real meeting to see which settings fields the API returns before writing the payload your meeting-creation code sends

• Check pagination behavior before writing a sync loop: fetch a range that returns multiple pages so you can see how the next_page_token field behaves before writing the loop your sync job depends on

Why use Merge Agent Handler vs. a self-hosted Zoom MCP server?

You can connect directly to Zoom's API using your own OAuth app. The API is documented, app creation is straightforward, and for a single developer building against one account the setup is fast.

The access control problem appears when you scale beyond one developer or one agent.

Zoom recordings and transcripts contain meeting content, and a token that can read them carries that access wherever it's shared, with no way to restrict which operations a given agent can call. Rotating the token means updating every system that holds it at once.

Merge Agent Handler handles Zoom authentication centrally.

You define exactly which Zoom operations each agent can call: an agent that inspects meeting and recording structure for code generation can read that data without reaching write operations like creating or deleting meetings. Every call is logged with the timestamp, tool, and inputs, so you have a full record of what each agent read or changed.

For teams running multiple agents against a shared Zoom account, that combination of scoped access and central logging is the difference between a controlled deployment and a shared credential problem.

Why connect Zoom to Cursor?

Zoom's API data, recording file lists, transcript formats, participant objects, meeting settings, isn't something you can accurately reconstruct from documentation alone.

These specifics are real-response details: the set of files a recording returns depends on the meeting, the transcript arrives as VTT with a particular structure, and meeting UUIDs follow an encoding rule that trips up endpoint paths.

Connecting Zoom to Cursor puts that discovery step inside the editor.

When you're writing recording-archival code and need the file list, you fetch a real recording. When you're writing a transcript parser and need the VTT structure, you pull a real transcript. When you're writing endpoint paths and need to handle a slash-prefixed UUID, you query a real meeting.

The data that makes the integration code correct stays in the same session where the code is being written, instead of forcing a separate API exploration phase before development can start.

Can I use Merge Agent Handler's Zoom MCP with my employees?

Yes, Agent Handler for Employees is built to help organizations provision, secure, and govern how employees connect AI tools like Cursor to systems like Zoom.

Common patterns include:

• Provisioning and access control via SCIM with identity providers like Okta and Microsoft Entra ID, so IT can manage which Zoom accounts and data types an employee's agent can reach by role or team

• DLP and policy enforcement on tool calls, so admins can block queries that would return sensitive recording or transcript content before results reach the editor session

• User-level audit logging so security and IT teams can review which meetings, recordings, and transcripts were accessed, by which employee identity, and when

The result is that employees can use the Zoom MCP to write recording-archival code against real file lists, build transcript parsers grounded in the actual VTT structure, and write meeting-creation code with correct settings payloads, and more, while IT keeps centralized control over which data each agent can reach.