# Zoom Marketplace Category Tracker (`crawlerbros/zoom-marketplace-category-tracker`) Actor

Track all Zoom App Marketplace apps for a specific Zoom product (Meeting, Phone, Webinar, etc.) in their default marketplace ranking order. Returns rank position among all apps for that product

- **URL**: https://apify.com/crawlerbros/zoom-marketplace-category-tracker.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, 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 Marketplace Category Tracker

Track all apps in the [Zoom App Marketplace](https://marketplace.zoom.us/apps) for a specific Zoom product — ranked by their default marketplace position. Perfect for monitoring app rankings, tracking new entrants, and comparing competitors within a Zoom product category.

### What You Can Do

- Get all apps that work with **Zoom Meeting**, **Zoom Phone**, **Zoom Webinar**, or any other Zoom product
- See apps in their **default marketplace ranking order** (`rankInProduct`)
- Monitor which apps appear at which position over time (run on a schedule to track changes)

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `product` | Select | Zoom product to track (required) | — |
| `maxItems` | Integer | Maximum number of ranked apps to return (1–1000) | `50` |

#### Supported Zoom Products

| 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 — Track top 20 Zoom Meeting apps

```json
{
  "product": "ZOOM_MEETING",
  "maxItems": 20
}
````

#### Example Input — All Zoom Phone apps ranked

```json
{
  "product": "ZOOM_PHONE",
  "maxItems": 200
}
```

### Output

Each record contains:

| Field | Type | Description |
|---|---|---|
| `rankInProduct` | Integer | 1-based position in the default marketplace listing for this product |
| `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 | All 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) |
| `scrapedAt` | String | ISO 8601 timestamp of when the record was scraped |

#### Example Output Record

```json
{
  "rankInProduct": 1,
  "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/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

- **Competitive Intelligence** — Monitor where your app ranks among Zoom Meeting or Zoom Phone integrations
- **Market Research** — Get a complete list of all apps competing in your Zoom product category
- **Partnership Discovery** — Find all apps built for a specific Zoom product to identify potential partners
- **Category Monitoring** — Run on a weekly schedule to detect new entrants or ranking changes
- **Sales Prospecting** — Find companies building Zoom integrations for outreach

### Ranking

The `rankInProduct` field reflects the position of each app within the full Zoom Marketplace listing, filtered for the selected product. Apps are ranked in the same order they appear when browsing the marketplace — this is Zoom's default ordering, which typically favors popular, well-rated, and featured apps.

### FAQ

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

**Q: What does `rankInProduct` mean exactly?**
A: It is the 1-based position of the app among all marketplace apps that work with the selected product, in the order Zoom returns them from their API. Rank 1 = first app listed for that product.

**Q: How do I track rank changes over time?**
A: Run this actor on a schedule (daily or weekly) and save each run's dataset. Compare `rankInProduct` values across datasets to detect changes.

**Q: An app appears in multiple Zoom product categories — how is it ranked?**
A: Each product has its own independent ranking. An app can have rank 5 for `ZOOM_MEETING` and rank 20 for `ZOOM_PHONE`.

**Q: Why does the same app appear in `worksWith` for multiple products?**
A: Some apps integrate with multiple Zoom products simultaneously. The `worksWith` array lists all products. This actor filters to apps where your selected product is in the `worksWith` array.

**Q: How fresh is the data?**
A: Data is fetched live from the Zoom Marketplace API on every 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

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

Return all apps that work with this Zoom product, ranked by their position in the full marketplace listing.

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

Maximum number of apps to return.

## Actor input object example

```json
{
  "product": "ZOOM_MEETING",
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped Zoom Marketplace apps for the selected product, with rank position.

# 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 = {
    "product": "ZOOM_MEETING",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/zoom-marketplace-category-tracker").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 = {
    "product": "ZOOM_MEETING",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/zoom-marketplace-category-tracker").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 '{
  "product": "ZOOM_MEETING",
  "maxItems": 50
}' |
apify call crawlerbros/zoom-marketplace-category-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoom Marketplace Category Tracker",
        "description": "Track all Zoom App Marketplace apps for a specific Zoom product (Meeting, Phone, Webinar, etc.) in their default marketplace ranking order. Returns rank position among all apps for that product",
        "version": "1.0",
        "x-build-id": "ZSuwckR8qCiUpleSa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~zoom-marketplace-category-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-zoom-marketplace-category-tracker",
                "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-category-tracker/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-zoom-marketplace-category-tracker",
                "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-category-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-zoom-marketplace-category-tracker",
                "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": [
                    "product"
                ],
                "properties": {
                    "product": {
                        "title": "Zoom Product",
                        "enum": [
                            "ZOOM_MEETING",
                            "ZOOM_PHONE",
                            "ZOOM_WEBINAR",
                            "ZOOM_CHAT",
                            "ZOOM_ROOM",
                            "ZOOM_EVENTS",
                            "ZOOM_WHITEBOARD",
                            "ZOOM_IQ",
                            "ZOOM_CONTACT_CENTER"
                        ],
                        "type": "string",
                        "description": "Return all apps that work with this Zoom product, ranked by their position in the full marketplace listing."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of apps to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```