Zoom Recordings No-Auth

Instructions

Implementation Reference

• src/mcp_server_zoom_noauth/server.py:162-216 (handler)

  Core handler function in ZoomClient class that fetches and returns list of cloud recordings using Zoom API endpoint /users/me/recordings with support for date filtering and pagination.

  def list_recordings(self, from_date: Optional[str] = None, to_date: Optional[str] = None, 
                      page_size: int = 30, page_number: int = 1) -> str:
      """List cloud recordings from Zoom
      
      Args:
          from_date: Start date for recording search in 'YYYY-MM-DD' format
          to_date: End date for recording search in 'YYYY-MM-DD' format
          page_size: Number of records to return per page (default: 30, max: 300)
          page_number: Page number to return (default: 1)
          
      Returns:
          JSON string with recordings data
      """
      try:
          # Define the operation
          def _operation():
              logger.debug(f"Fetching recordings with page_size={page_size}, page_number={page_number}")
              
              # Prepare query parameters
              params = {
                  "page_size": min(page_size, 300),  # Zoom API limits to 300 max
                  "page_number": page_number
              }
              
              if from_date:
                  params["from"] = from_date
              if to_date:
                  params["to"] = to_date
              
              # Get user's recordings (me = current authenticated user)
              response = requests.get(
                  f"{self.base_url}/users/me/recordings",
                  headers=self._get_headers(),
                  params=params
              )
              
              if response.status_code != 200:
                  return json.dumps({
                      "error": f"Failed to retrieve recordings. Status code: {response.status_code}",
                      "details": response.text,
                      "status": "error"
                  })
              
              recordings_data = response.json()
              
              # Process and return recordings
              return json.dumps(convert_datetime_fields(recordings_data))
          
          # Execute the operation with token refresh handling
          return self._handle_token_refresh(_operation)
              
      except Exception as e:
          logger.error(f"Exception in list_recordings: {str(e)}", exc_info=True)
          return json.dumps({"error": str(e)})

• src/mcp_server_zoom_noauth/server.py:368-382 (registration)

  Tool registration in MCP server's list_tools method, defining name, description, and input schema for zoom_list_recordings.

  types.Tool(
      name="zoom_list_recordings",
      description="List Zoom cloud recordings from a user's Zoom account with pagination support",
      inputSchema={
          "type": "object",
          "properties": {
              "zoom_access_token": {"type": "string", "description": "Zoom OAuth2 access token"},
              "from_date": {"type": "string", "description": "Start date for Zoom recording search in 'YYYY-MM-DD' format"},
              "to_date": {"type": "string", "description": "End date for Zoom recording search in 'YYYY-MM-DD' format"},
              "page_size": {"type": "integer", "description": "Number of Zoom recordings to return per page (default: 30, max: 300)"},
              "page_number": {"type": "integer", "description": "Page number of Zoom recordings to return (default: 1)"}
          },
          "required": ["zoom_access_token"]
      },
  ),

• src/mcp_server_zoom_noauth/server.py:500-522 (handler)

  Dispatch handler within the MCP call_tool function that parses arguments, initializes ZoomClient, and calls list_recordings for the zoom_list_recordings tool.

  if name == "zoom_list_recordings":
      # Initialize Zoom client with just access token
      logger.debug(f"Initializing Zoom client for list_recordings with access token: {access_token[:10]}...")
      try:
          zoom = ZoomClient(
              access_token=access_token
          )
          logger.debug("Zoom client initialized successfully")
          
          from_date = arguments.get("from_date")
          to_date = arguments.get("to_date")
          page_size = int(arguments.get("page_size", 30))
          page_number = int(arguments.get("page_number", 1))
          
          logger.debug(f"Calling list_recordings with from_date={from_date}, to_date={to_date}, page_size={page_size}, page_number={page_number}")
          results = zoom.list_recordings(from_date=from_date, to_date=to_date, 
                                         page_size=page_size, page_number=page_number)
          logger.debug(f"list_recordings result (first 200 chars): {results[:200]}...")
          return [types.TextContent(type="text", text=results)]
      except Exception as e:
          logger.error(f"Exception in zoom_list_recordings handler: {str(e)}", exc_info=True)
          return [types.TextContent(type="text", text=f"Error: {str(e)}")]

• server.js:157-194 (handler)

  JavaScript implementation of the listRecordings method in ZoomClient class that fetches Zoom cloud recordings using the API.

  async listRecordings({ from_date, to_date, page_size = 30, page_number = 1 } = {}) {
    try {
      const operation = async () => {
        logger.debug(`Fetching recordings with page_size=${page_size}, page_number=${page_number}`);
        
        const params = {
          page_size: Math.min(page_size, 300),
          page_number: page_number
        };
        
        if (from_date) params.from = from_date;
        if (to_date) params.to = to_date;
        
        const response = await axios.get(
          `${this.baseUrl}/users/me/recordings`,
          {
            headers: this._getHeaders(),
            params
          }
        );
        
        if (response.status !== 200) {
          return JSON.stringify({
            error: `Failed to retrieve recordings. Status code: ${response.status}`,
            details: response.data,
            status: "error"
          });
        }
        
        return JSON.stringify(response.data);
      };
      
      return await this._handleTokenRefresh(operation);
    } catch (error) {
      logger.error(`Exception in listRecordings: ${error.message}`);
      return JSON.stringify({ error: error.message });
    }
  }

• server.js:332-356 (registration)

  JavaScript MCP server.tool registration for zoom_list_recordings, including Zod schema and inline handler function.

  server.tool(
    'zoom_list_recordings',
    'List Zoom cloud recordings from a user\'s Zoom account with pagination support',
    {
      zoom_access_token: z.string().describe('Zoom OAuth2 access token'),
      from_date: z.string().optional().describe('Start date for Zoom recording search in \'YYYY-MM-DD\' format'),
      to_date: z.string().optional().describe('End date for Zoom recording search in \'YYYY-MM-DD\' format'),
      page_size: z.number().optional().describe('Number of Zoom recordings to return per page (default: 30, max: 300)'),
      page_number: z.number().optional().describe('Page number of Zoom recordings to return (default: 1)')
    },
    async ({ zoom_access_token, from_date, to_date, page_size = 30, page_number = 1 }) => {
      try {
        const zoom = new ZoomClient({ accessToken: zoom_access_token });
        logger.error(`listing recordings with from_date=${from_date}, to_date=${to_date}, page_size=${page_size}, page_number=${page_number}`);
        const result = await zoom.listRecordings({ from_date, to_date, page_size, page_number });
        return {
          content: [{ type: 'text', text: result }]
        };
      } catch (error) {
        return {
          content: [{ type: 'text', text: `Error: ${error.message}` }]
        };
      }
    }
  );