# Zoom App Marketplace Scraper (`crawlerbros/zoom-marketplace-scraper`) Actor

Scrape the Zoom App Marketplace, browse all 3400+ apps, search by keyword, or filter by Zoom product (Meeting, Phone, Webinar, etc.). Returns app name, company, description, icon, usage type, FedRAMP status, and ratings.

- **URL**: https://apify.com/crawlerbros/zoom-marketplace-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 App Marketplace Scraper

Extract apps from the [Zoom App Marketplace](https://marketplace.zoom.us/apps) — the official directory of 3,400+ integrations for Zoom Meeting, Zoom Phone, Zoom Webinar, and more. No API key or login required.

### What You Can Do

- **Browse** all marketplace apps with optional filters (usage type, FedRAMP status, essential apps)
- **Search** for apps by keyword in app name and description
- **Filter by Zoom product** to find all apps that work with a specific Zoom product (e.g., Zoom Phone, Zoom Webinar)

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `mode` | Select | `browse` / `search` / `byProduct` | `browse` |
| `searchQuery` | String | Keyword to search (required for `search` mode) | `scheduling` |
| `product` | Select | Zoom product to filter by (required for `byProduct` mode) | — |
| `usage` | Select | Filter by usage type: `ALL` / `ADMIN_MANAGEMENT` / `USER_OPERATION` | `ALL` |
| `fedRampOnly` | Boolean | Only return FedRAMP authorized apps | `false` |
| `essentialAppsOnly` | Boolean | Only return apps marked as Essential by Zoom | `false` |
| `maxItems` | Integer | Maximum number of apps to return (1–3419) | `100` |

#### Supported Zoom Products (`product` field)

| Value | Label |
|---|---|
| `ZOOM_MEETING` | Zoom Meeting |
| `ZOOM_PHONE` | Zoom Phone |
| `ZOOM_WEBINAR` | Zoom Webinar |
| `ZOOM_CHAT` | Zoom Chat |
| `ZOOM_ROOM` | Zoom Rooms |
| `ZOOM_EVENTS` | Zoom Events |
| `ZOOM_WHITEBOARD` | Zoom Whiteboard |
| `ZOOM_IQ` | Zoom IQ |
| `ZOOM_CONTACT_CENTER` | Zoom Contact Center |

#### Example Input — Browse FedRAMP apps

```json
{
  "mode": "browse",
  "fedRampOnly": true,
  "maxItems": 50
}
````

#### Example Input — Search for CRM integrations

```json
{
  "mode": "search",
  "searchQuery": "CRM",
  "maxItems": 20
}
```

#### Example Input — All Zoom Phone apps

```json
{
  "mode": "byProduct",
  "product": "ZOOM_PHONE",
  "maxItems": 100
}
```

### Output

Each record contains:

| Field | Type | Description |
|---|---|---|
| `appId` | String | Unique Zoom Marketplace app ID |
| `name` | String | App display name |
| `companyName` | String | Developer/company name |
| `description` | String | App description |
| `iconUrl` | String | App icon URL |
| `appUrl` | String | Link to app page on Zoom Marketplace |
| `worksWith` | Array | Zoom products this app works with |
| `workIn` | Array | Zoom surfaces this app works in |
| `usage` | String | `ADMIN_MANAGEMENT` or `USER_OPERATION` |
| `fedRampAuthorized` | Boolean | Whether the app is FedRAMP authorized |
| `essentialApp` | Boolean | Whether Zoom marked this as an Essential App |
| `ratingStatistics` | Object | Rating breakdown (only present if rated) |
| `ratingStatistics.totalRatings` | Integer | Total number of ratings |
| `ratingStatistics.averageRating` | Float | Average star rating |
| `scrapedAt` | String | ISO 8601 timestamp of when the record was scraped |

#### Example Output Record

```json
{
  "appId": "PN3rVBK6R0aXBU5Fw2i6aQ",
  "name": "Glean Search Crawler for Zoom",
  "companyName": "Glean Technologies, Inc.",
  "description": "Know what your company knows, instantly. Search across your meetings and recordings.",
  "iconUrl": "https://marketplace.zoom.us/9deleS6VTsWPLsxe_9W-7w/4H8xCQxQRgK3AhKf1TtHSA/app/icon.png",
  "appUrl": "https://marketplace.zoom.us/apps/PN3rVBK6R0aXBU5Fw2i6aQ",
  "worksWith": ["ZOOM_MEETING"],
  "workIn": ["ZOOM_CHAT"],
  "usage": "ADMIN_MANAGEMENT",
  "fedRampAuthorized": false,
  "essentialApp": false,
  "ratingStatistics": {
    "totalRatings": 69,
    "averageRating": 2.5,
    "rating1Count": 39,
    "rating2Count": 3,
    "rating3Count": 3,
    "rating4Count": 3,
    "rating5Count": 21
  },
  "scrapedAt": "2026-05-20T12:00:00+00:00"
}
```

### Use Cases

- **Sales & Business Development** — Find all apps in a specific category or product area for competitive analysis
- **IT/Security Teams** — Identify FedRAMP-authorized apps for compliance requirements
- **Developers** — Explore the Zoom app ecosystem for integration planning
- **Market Research** — Analyze which companies have built Zoom integrations
- **Procurement** — Compare apps by product area before purchasing

### FAQ

**Q: Does this require a Zoom account or API key?**
A: No. The Zoom App Marketplace is publicly accessible. No credentials needed.

**Q: How many apps are available?**
A: The marketplace has approximately 3,400+ apps. The total updates as Zoom adds/removes apps.

**Q: Can I filter by multiple products at once?**
A: The `byProduct` mode filters by a single product. Use `browse` mode and post-process the `worksWith` array for multi-product filtering.

**Q: What does `usage` mean?**
A: `ADMIN_MANAGEMENT` apps are installed by Zoom admins for the entire organization. `USER_OPERATION` apps are installed by individual users.

**Q: What are Essential Apps?**
A: Zoom-curated apps that are free for all Zoom users, available pre-approved without admin installation.

**Q: Why doesn't every app have `ratingStatistics`?**
A: Not all apps have received user ratings yet. The field is only included when rating data exists.

**Q: Are search results real-time?**
A: Yes. The scraper fetches directly from the live Zoom Marketplace API on each run.

### Data Source

Data is sourced from the public Zoom App Marketplace REST API at `https://marketplace.zoom.us/api/v1/`. No unofficial access or reverse-engineering is involved.

# Actor input Schema

## `mode` (type: `string`):

How to retrieve apps.

## `searchQuery` (type: `string`):

Keyword to search for in app name and description. Required for mode=search.

## `product` (type: `string`):

Return only apps that work with this Zoom product. Required for mode=byProduct.

## `usage` (type: `string`):

Filter by app usage type. Leave empty to include all.

## `fedRampOnly` (type: `boolean`):

Only return apps that are FedRAMP authorized.

## `essentialAppsOnly` (type: `boolean`):

Only return apps marked as Essential Apps by Zoom.

## `maxItems` (type: `integer`):

Maximum number of apps to return.

## Actor input object example

```json
{
  "mode": "browse",
  "searchQuery": "scheduling",
  "usage": "ALL",
  "fedRampOnly": false,
  "essentialAppsOnly": false,
  "maxItems": 100
}
```

# Actor output Schema

## `apps` (type: `string`):

Dataset containing all scraped Zoom Marketplace apps.

# 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 = {
    "mode": "browse",
    "searchQuery": "scheduling",
    "usage": "ALL",
    "fedRampOnly": false,
    "essentialAppsOnly": false,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/zoom-marketplace-scraper").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 = {
    "mode": "browse",
    "searchQuery": "scheduling",
    "usage": "ALL",
    "fedRampOnly": False,
    "essentialAppsOnly": False,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/zoom-marketplace-scraper").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 '{
  "mode": "browse",
  "searchQuery": "scheduling",
  "usage": "ALL",
  "fedRampOnly": false,
  "essentialAppsOnly": false,
  "maxItems": 100
}' |
apify call crawlerbros/zoom-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoom App Marketplace Scraper",
        "description": "Scrape the Zoom App Marketplace, browse all 3400+ apps, search by keyword, or filter by Zoom product (Meeting, Phone, Webinar, etc.). Returns app name, company, description, icon, usage type, FedRAMP status, and ratings.",
        "version": "1.0",
        "x-build-id": "R5uVe6zM15YN4zRUo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~zoom-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-zoom-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~zoom-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-zoom-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~zoom-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-zoom-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "browse",
                            "search",
                            "byProduct"
                        ],
                        "type": "string",
                        "description": "How to retrieve apps.",
                        "default": "browse"
                    },
                    "searchQuery": {
                        "title": "Search Query (mode=search)",
                        "type": "string",
                        "description": "Keyword to search for in app name and description. Required for mode=search."
                    },
                    "product": {
                        "title": "Zoom Product (mode=byProduct)",
                        "enum": [
                            "ZOOM_MEETING",
                            "ZOOM_PHONE",
                            "ZOOM_WEBINAR",
                            "ZOOM_CHAT",
                            "ZOOM_ROOM",
                            "ZOOM_EVENTS",
                            "ZOOM_WHITEBOARD",
                            "ZOOM_IQ",
                            "ZOOM_CONTACT_CENTER"
                        ],
                        "type": "string",
                        "description": "Return only apps that work with this Zoom product. Required for mode=byProduct."
                    },
                    "usage": {
                        "title": "Usage Type Filter",
                        "enum": [
                            "ALL",
                            "ADMIN_MANAGEMENT",
                            "USER_OPERATION"
                        ],
                        "type": "string",
                        "description": "Filter by app usage type. Leave empty to include all.",
                        "default": "ALL"
                    },
                    "fedRampOnly": {
                        "title": "FedRAMP Authorized Only",
                        "type": "boolean",
                        "description": "Only return apps that are FedRAMP authorized.",
                        "default": false
                    },
                    "essentialAppsOnly": {
                        "title": "Essential Apps Only",
                        "type": "boolean",
                        "description": "Only return apps marked as Essential Apps by Zoom.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 3419,
                        "type": "integer",
                        "description": "Maximum number of apps to return.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```