# Zoom Recording Downloader (`agentx/zoom-recording-downloader`) Actor

Process one publicly accessible Zoom cloud recording or clip for structured metadata and an optional stored video file.

- **URL**: https://apify.com/agentx/zoom-recording-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Zoom Video Downloader processes one publicly accessible cloud recording or clip into normalized metadata and can optionally store its video file in Apify.

- Two public inputs cover one recording URL and an optional download preference.
- Four quality values provide metadata-only, low, medium, and high processing modes.
- Successful output uses a 39-field Dataset contract with thumbnail-first review.
- Passwords and comments are not inputs; the reserved `comments` list is normally empty.

**[Run one Zoom recording test](https://apify.com/agentx/zoom-video-downloader)**

**[View the Apify API](https://apify.com/agentx/zoom-video-downloader/api)**

Publish the Actor, replace the illustrative URL, and test an unprotected recording in metadata mode.

### Why Choose This API

Zoom Video Downloader provides a narrow workflow for one recording share page or clip that is accessible without a password or account session. Available values are normalized into fields for recording identity, title, description, thumbnail, duration, publication time, owner information, dimensions, audio labels, and processing provenance.

Metadata mode avoids transferring the recording. Low, medium, and high are download preferences limited by the rendition Zoom exposes. The Actor does not change recording permissions or create a resolution absent from the source.

This is not a Zoom meeting client, account export, transcript service, webinar crawler, chat downloader, or passcode bypass. The local extractor list contains `zoom` and `zoom:clips`, but representative public cases are still required before release.

### Quick Start Guide

The same URL-shaped placeholder is used throughout:

```json
{
  "video_url": "https://zoom.us/rec/share/example",
  "video_quality": "metadata"
}
```

Replace `example` with a current share page you are authorized to process. Open it in a private browser window. If Zoom asks for a passcode, login, email, or host approval, it is outside this two-field public contract.

Submit metadata mode and verify the recording ID, title, thumbnail, owner, and duration. Only request a file after the identity matches. Process additional recordings through separate runs.

### Input Parameters

| Parameter | Type | Required | Purpose |
|---|---|---:|---|
| `video_url` | string | Yes | One public Zoom cloud recording or clip URL. |
| `video_quality` | string | No | `metadata`, `low`, `medium`, or `high`; metadata skips storage. |

The required URL has a matching placeholder prefill and example. The optional quality field has no prefill or example and uses metadata when omitted.

No passcode, account, cookie, meeting ID, webinar, transcript, chat, date, batch, or comment input exists. Additional properties are rejected.

### Output Data Schema

The output contains 39 possible fields:

| Area | Fields |
|---|---|
| Recording | `thumbnail`, `id`, `platform`, `title`, `description`, `duration`, `published_at` |
| Owner | `author`, `author_id`, `author_url` |
| Labels and counters | `categories`, `tags`, `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Media | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `video` |
| Reserved and provenance | `comments`, `processed_at`, `processor` |

Abbreviated shape for the same placeholder:

```json
{
  "id": "example",
  "platform": "Zoom",
  "title": "Example cloud recording",
  "author": "Example host",
  "thumbnail": "https://example.com/zoom-thumbnail.jpg",
  "comments": [],
  "video": ""
}
```

This is a schema illustration, not captured output. Zoom may omit cross-platform fields. Metadata mode returns no stored file, and the public input does not request comments or meeting chat.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `language` | Primary language of the item as reported by the source |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `subtitles` | Language codes of published subtitle tracks; auto-captions excluded |
| `chapters` | Chapter markers with title and start and end time in seconds |

### Integration Examples

The intended reference is `agentx/zoom-video-downloader`.submit the same placeholder form over HTTP:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~zoom-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://zoom.us/rec/share/example","video_quality":"metadata"}'
```

The matching hosted MCP configuration is:

```json
{
  "mcpServers": {
    "apify-zoom-video": {
      "url": "https://mcp.apify.com?tools=agentx/zoom-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://zoom.us/rec/share/example",
    "video_quality": "metadata"
  }
}
```

Publication is required for discovery. Keep tokens secret and follow the [Apify MCP documentation](https://docs.apify.com/integrations/mcp).

### Pricing & Cost Calculator

Local metadata declares these events, not a verified public offer:

| Event | Billing unit | Local price |
|---|---|---:|
| `actor_usage` | Metered runtime, proxy, and storage usage | $0.00001 |
| `metadata` | One successfully processed metadata result | $0.11 |
| `download` | One successfully processed result with stored video | $0.30 |

The smallest metadata result declares $0.11 plus metered usage. A download declares $0.30 plus metered usage.

### Use Cases & Applications

Teams can archive an authorized public training, demo, or event recording with its metadata and processing time. Developers can route the Dataset item into a catalog or webhook. AI teams can send a permitted stored file to Video Transcript. Metadata-first checks reduce transfer and expose permission problems early.

The Actor does not retrieve Zoom-generated transcripts or chat. Those artifacts require their own authorized workflow and should not be inferred from the video record.

### Limits & Troubleshooting

Passcodes, login requirements, waiting-room or host approval, expired shares, owner deletion, domain restrictions, and Zoom platform changes may block processing. No credential input exists.

If no item appears, replace open the exact recording privately, and confirm it plays without a challenge. Retry metadata mode. If a download has no `video`, inspect logs and storage and confirm metadata still works.

Before release, test a public share, a public clip, a passcode recording, an expired share, and one download preference. Record detected extractor, ID, thumbnail, duration, terminal status, and file outcome.

### FAQ

#### Can I provide a Zoom passcode?

No passcode field is exposed.

#### Does it download meeting chat or transcripts?

No. The contract covers available video metadata and optional media storage.

#### Can it join a live meeting?

No. This is not a meeting client or live recorder.

#### Does it retrieve comments?

No comment input exists; the reserved list is normally empty.

#### Does high guarantee a resolution?

No. Available Zoom renditions determine the result.

#### Why are fields null?

The recording page did not expose them. Null is not zero.

#### Can I schedule it?

Yes, but the same share is reprocessed and permissions may change.

#### Why can a share link stop working?

Zoom cloud recordings expire on the owner's retention schedule and can be passcode-protected or restricted to signed-in members at any time. No passcode or credential input exists, so a link that resolved previously may later end the run without a Dataset item. Confirm the recording opens in a private window first.

### Legal & Responsible Use

Process only recordings you are authorized to access, download, and retain. Meeting participants may have privacy and consent rights. The caller is responsible for Zoom terms, law, copyright, consent, and retention policy.

### Related Tools

- [Video Transcript](https://apify.com/agentx/video-transcript) converts authorized speech to text.
- [Video Captions Downloader](https://apify.com/agentx/video-captions-downloader) retrieves available caption tracks.
- [Live Stream Transcript](https://apify.com/agentx/live-stream-transcript) handles live-audio transcription workflows.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) accepts supported URLs from multiple hosts.

### Support & Community

- [AgentX community](https://t.me/Apify_Actor)
- [Contact the AgentX team](https://t.me/AiAgentApi)
- [Apify Actor dashboard](https://apify.com/agentx/zoom-video-downloader)
- [Apify API reference](https://apify.com/agentx/zoom-video-downloader/api)
- [Apify MCP documentation](https://docs.apify.com/integrations/mcp)

Include the stable ID, redacted share URL, access condition, input, and run ID in support requests.

**[Run one Zoom recording test](https://apify.com/agentx/zoom-video-downloader)**

**[View the Apify API](https://apify.com/agentx/zoom-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible Zoom cloud recording or clip URL to process.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://zoom.us/rec/share/example"
}
```

# Actor output Schema

## `results` (type: `string`):

All video details and optional download links with full engagement stats and comments

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "video_url": "https://zoom.us/rec/share/example"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/zoom-recording-downloader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "video_url": "https://zoom.us/rec/share/example" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/zoom-recording-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "video_url": "https://zoom.us/rec/share/example"
}' |
apify call agentx/zoom-recording-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agentx/zoom-recording-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aXgY0Ouvdd330WUhQ/builds/bDZ5qp6JrOXFyWSf3/openapi.json