Zoom Recordings No-Auth
This server allows you to access and manage Zoom recordings and transcripts without requiring local authentication. All credentials are passed through tool arguments, with no credential storage required.
Capabilities include:
Refreshing Zoom OAuth2 access tokens using refresh tokens and client credentials
Listing cloud recordings from a user's Zoom account with date filtering and pagination
Getting detailed information about specific meeting recordings including files and metadata
Accessing meeting transcript files and content when available
Enables access to Zoom API functionality without requiring direct user authentication, providing tools to list cloud recordings, get detailed recording information, and access meeting transcripts.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Zoom Recordings No-Authlist my recordings from last week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Server for Zoom (No Auth) - Python & Node.js
This project is a Model Control Protocol (MCP) server for accessing Zoom API functionality without requiring direct authentication from the end user. It handles the OAuth flows and provides a set of tools for interacting with Zoom recordings and transcripts.
Features
OAuth credential management through tool arguments (no local auth flow)
List user's cloud recordings with pagination
Get detailed information about specific meeting recordings
Access meeting transcripts
Related MCP server: Zoom API MCP Server
Installation
Clone the repository:
git clone https://github.com/peakmojo/mcp-server-zoom-noauth.git
cd mcp-server-zoom-noauthInstall the required dependencies:
pip install -r requirements.txtDocker
Building the Docker Image
# Build the Docker image
docker build -t mcp-server-zoom-noauth .Cross-Platform Publishing
To publish the Docker image for multiple platforms, you can use the docker buildx command:
Create a new builder instance (if you haven't already):
docker buildx create --useBuild and push the image for multiple platforms:
docker buildx build --platform linux/amd64,linux/arm64 -t buryhuang/mcp-server-zoom-noauth:latest --push .Verify the image is available for the specified platforms:
docker buildx imagetools inspect buryhuang/mcp-server-zoom-noauth:latestUsage
Starting the server
python -m src.mcp_server_zoom_noauth.serverAvailable Tools
The server provides the following tools:
zoom_refresh_token - Refresh an OAuth token using a refresh token
zoom_list_recordings - Get a list of user's cloud recordings
zoom_get_recording_details - Get detailed information about a specific meeting recording
zoom_get_meeting_transcript - Get transcript for a specific meeting recording
Tool Usage Examples
Refreshing a token
{
"zoom_refresh_token": "your_refresh_token",
"zoom_client_id": "your_client_id",
"zoom_client_secret": "your_client_secret"
}Listing recordings
{
"zoom_access_token": "your_access_token",
"from_date": "2023-01-01",
"to_date": "2023-01-31",
"page_size": 30,
"page_number": 1
}Getting recording details
{
"zoom_access_token": "your_access_token",
"meeting_id": "meeting_id_here"
}Getting meeting transcript
{
"zoom_access_token": "your_access_token",
"meeting_id": "meeting_id_here"
}OAuth Credential Handling
This server is designed to be completely "noauth" from its perspective:
No local authentication flow is needed
No credentials are stored on the server
All credentials are passed through tool arguments
The server can run in a headless environment
To use the tools, you'll need to obtain OAuth credentials from Zoom:
Create a Zoom OAuth app in the Zoom Marketplace
Configure the required scopes for recordings access
Obtain access and refresh tokens through the OAuth flow
Pass these tokens as arguments when calling the tools
Zoom API Reference
This project uses the Zoom API v2. For more information, refer to the Zoom API documentation.
License
Available Tools
4 toolszoom_get_meeting_transcriptC
Get transcript files and content from a specific Zoom meeting recording if available
| Name | Required | Description | Default |
|---|---|---|---|
| meeting_id | Yes | The Zoom meeting ID to retrieve transcript for | |
| zoom_access_token | Yes | Zoom OAuth2 access token |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions transcripts are only available 'if available', hinting at conditional output, but fails to describe key traits: authentication requirements (implied by 'zoom_access_token' but not explained), rate limits, error handling (e.g., if no transcript exists), or output format (e.g., file vs. text). For a tool with no annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get transcript files and content') and includes a key constraint ('if available'). There is no wasted wording, and it effectively communicates the essential information in a compact form.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (retrieving specific data with authentication), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'transcript files and content' entails (e.g., format, structure), how to handle missing transcripts, or any behavioral nuances. For a tool with these gaps in structured data, the description should provide more context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters ('meeting_id', 'zoom_access_token') well-documented in the schema. The description adds no additional parameter semantics beyond what the schema provides (e.g., no details on meeting ID format or token scope). With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to heavily.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get transcript files and content from a specific Zoom meeting recording if available'. It specifies the verb ('Get'), resource ('transcript files and content'), and target ('specific Zoom meeting recording'). However, it doesn't explicitly differentiate from sibling tools like 'zoom_get_recording_details' or 'zoom_list_recordings', which might also involve meeting data retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal usage guidance. It mentions 'if available', implying transcripts might not exist, but offers no explicit when-to-use advice, prerequisites (e.g., requires a recorded meeting), or alternatives (e.g., use 'zoom_get_recording_details' for non-transcript details). Without clear context on when to choose this tool over siblings, the guidance is insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
zoom_get_recording_detailsC
Get detailed information about a specific Zoom meeting recording including recording files and metadata
| Name | Required | Description | Default |
|---|---|---|---|
| meeting_id | Yes | The Zoom meeting ID to retrieve recording details for | |
| zoom_access_token | Yes | Zoom OAuth2 access token |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions retrieving 'recording files and metadata' but doesn't specify what metadata is included, whether this is a read-only operation, if authentication is required beyond the token parameter, or any rate limits. This leaves significant gaps for a tool that likely accesses sensitive recording data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for a simple retrieval tool, though it could potentially be more front-loaded with critical behavioral information given the lack of annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that retrieves sensitive recording details with no annotations and no output schema, the description is inadequate. It doesn't explain what 'detailed information' includes, what format recording files are returned in, whether this requires specific permissions, or what happens if the meeting has no recordings. The combination of no annotations and no output schema creates significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any meaningful parameter semantics beyond what's in the schema - it doesn't explain format requirements for meeting_id, clarify what 'detailed information' includes, or provide context about the zoom_access_token beyond OAuth2.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get detailed information') and resource ('specific Zoom meeting recording'), making the purpose unambiguous. It distinguishes from 'zoom_list_recordings' by specifying retrieval of details for a single recording rather than listing multiple. However, it doesn't explicitly differentiate from 'zoom_get_meeting_transcript' which might also retrieve meeting-related details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'zoom_list_recordings' or 'zoom_get_meeting_transcript'. It doesn't mention prerequisites such as needing a valid meeting ID with existing recordings or specify use cases where detailed metadata is required versus just a transcript.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
zoom_list_recordingsB
List Zoom cloud recordings from a user's Zoom account with pagination support
| Name | Required | Description | Default |
|---|---|---|---|
| from_date | No | Start date for Zoom recording search in 'YYYY-MM-DD' format | |
| page_number | No | Page number of Zoom recordings to return (default: 1) | |
| page_size | No | Number of Zoom recordings to return per page (default: 30, max: 300) | |
| to_date | No | End date for Zoom recording search in 'YYYY-MM-DD' format | |
| zoom_access_token | Yes | Zoom OAuth2 access token |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'pagination support' which is a useful behavioral trait, but fails to disclose critical aspects such as authentication requirements (though implied by the zoom_access_token parameter), rate limits, error handling, or what the output format looks like (e.g., list structure, fields included). For a tool with 5 parameters and no annotations, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('List Zoom cloud recordings') and includes key features ('from a user's Zoom account with pagination support'). There is zero waste—every word contributes to understanding the tool's function without redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (5 parameters, no annotations, no output schema), the description is incomplete. It lacks details on authentication (beyond the token parameter), output format, error cases, or usage constraints. While it mentions pagination, it doesn't describe how pagination works in practice (e.g., total pages, next token). For a tool that likely returns structured data, this leaves the agent with insufficient context to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all parameters are well-documented in the input schema itself (e.g., date formats, defaults, max values). The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain relationships between parameters (e.g., how from_date and to_date interact) or provide usage examples. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('Zoom cloud recordings') with the scope ('from a user's Zoom account') and mentions pagination support. It distinguishes from siblings like zoom_get_recording_details (which gets details of a specific recording) and zoom_get_meeting_transcript (which gets transcripts), but doesn't explicitly differentiate from zoom_refresh_token (which is unrelated). The purpose is specific but could be slightly more precise about what 'list' entails.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving recordings with date filtering and pagination, but provides no explicit guidance on when to use this tool versus alternatives like zoom_get_recording_details for specific recordings or zoom_refresh_token for token management. It mentions pagination support, which hints at usage for large datasets, but lacks clear when/when-not scenarios or prerequisites beyond the implied need for a Zoom account.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
zoom_refresh_tokenB
Refresh the Zoom OAuth2 access token using the refresh token and client credentials for API access
| Name | Required | Description | Default |
|---|---|---|---|
| zoom_access_token | No | Zoom OAuth2 access token (optional if expired) | |
| zoom_client_id | Yes | Zoom OAuth2 client ID for token refresh | |
| zoom_client_secret | Yes | Zoom OAuth2 client secret for token refresh | |
| zoom_refresh_token | Yes | Zoom OAuth2 refresh token |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool's action but lacks behavioral details such as whether this is a read-only or mutating operation (though 'Refresh' implies mutation), authentication requirements beyond parameters, rate limits, error conditions, or what the output looks like (no output schema). This is a significant gap for a security-sensitive tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Refresh the Zoom OAuth2 access token') and includes essential context without waste. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an OAuth2 token refresh operation, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., mutability, security implications), error handling, and output format, which are critical for an AI agent to use this tool correctly and safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minimal value beyond the schema by mentioning the optional 'zoom_access_token' parameter context ('optional if expired'), but does not provide additional syntax, format, or usage details. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Refresh') and resource ('Zoom OAuth2 access token'), with explicit mention of the method ('using the refresh token and client credentials') and purpose ('for API access'). It distinguishes this authentication tool from its sibling tools (e.g., zoom_get_meeting_transcript) which are data retrieval operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (when the access token needs refreshing for API access) but does not explicitly state when to use this tool versus alternatives (e.g., initial token acquisition) or any prerequisites beyond the parameters. It mentions the optional 'zoom_access_token' parameter indirectly via 'optional if expired', but lacks clear when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose with no overlap: list_recordings for listing, get_recording_details for metadata, get_meeting_transcript for transcripts, and refresh_token for authentication. The descriptions reinforce these distinct roles, making tool selection unambiguous.
All tool names follow a consistent snake_case pattern with a 'zoom_' prefix and descriptive verb_noun combinations (e.g., list_recordings, get_meeting_transcript). This predictability enhances readability and usability across the tool set.
With 4 tools, this server is well-scoped for managing Zoom recordings, covering essential operations like listing, retrieving details, accessing transcripts, and handling authentication. Each tool earns its place without bloat or thinness for the domain.
The tool set provides strong coverage for core Zoom recording workflows, including listing, metadata retrieval, and transcript access, with authentication support. A minor gap exists in lacking update or delete operations for recordings, but this is not critical for typical read-only use cases.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
An MCP server that provides tools to discover and retrieve podcast episodes transcripts.
Zoom Meetings server for meeting search, recordings, transcripts, summaries, and meeting assets.
MCP server for RiverScript, an AI transcription platform - fetches transcripts shared via a link.
Related MCP Servers
- AlicenseAqualityDmaintenanceAn MCP server that enables users to list, download, search, and manage Zoom meeting transcripts through a structured interface.610MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP (Multi-Agent Conversation Protocol) Server that enables interaction with the Zoom API through natural language commands, auto-generated using AG2's MCP builder.
- -licenseNot gradedqualityNot gradedmaintenanceAn MCP Server that enables interaction with Zoom's API through the Multi-Agent Conversation Protocol, allowing users to access and control Zoom's functionality via natural language commands.
- FlicenseNot gradedqualityDmaintenanceAn MCP (Multi-Agent Conversation Protocol) Server that enables interaction with the Zoom API through natural language, auto-generated using AG2's MCP builder.
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/peakmojo/mcp-server-zoom-noauth'
If you have feedback or need assistance with the MCP directory API, please join our Discord server