# Zoom Marketplace Scraper (`automation-lab/zoom-marketplace-scraper`) Actor

Scrape Zoom App Marketplace apps, publishers, categories, scopes, permissions, install links, and vendor metadata for SaaS research.

- **URL**: https://apify.com/automation-lab/zoom-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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 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 Scraper

Extract public Zoom App Marketplace listings, app detail metadata, publishers, categories, OAuth scopes, permission notices, install links, and vendor URLs from `marketplace.zoom.us`.

Use this actor when you need repeatable marketplace intelligence for Zoom integrations without logging in, installing apps, or running admin approval flows.

### What does Zoom Marketplace Scraper do?

Zoom Marketplace Scraper collects public app records from the Zoom App Marketplace. It can browse the marketplace, search by keyword, focus on category slugs, or enrich direct app URLs with detail metadata.

The output is one dataset row per app. Each row includes identifiers, listing URL, publisher, descriptions, categories, supported products, OAuth scopes, permissions, public documentation links, privacy/support/terms URLs, install flags, timestamps, and scrape metadata.

### Who is it for?

- 🧩 SaaS ecosystem teams mapping the Zoom integration landscape.
- 🤝 Partnership teams finding vendors and integration gaps.
- 🔐 Security and compliance teams reviewing public OAuth scopes and permission notices.
- 📈 RevOps and market intelligence teams tracking competitor marketplace presence.
- 🧪 Product teams monitoring which apps launch or update in Zoom Marketplace categories.

### Why use this actor?

Zoom Marketplace data is useful but hard to monitor manually. This actor turns public listings into structured data that can be exported, scheduled, compared, enriched, and loaded into BI tools.

It is HTTP/API-first and avoids Playwright browser overhead. It only uses public marketplace endpoints and does not require Zoom credentials.

### Data you can extract

| Field group | Examples |
| --- | --- |
| App identity | `appId`, `clientId`, `applicationId`, `name`, `url` |
| Publisher | `publisher`, `developerType`, `applicationType`, `usage` |
| Listing copy | `shortDescription`, `longDescription`, `categories` |
| Security metadata | `scopes`, `permissions`, `permissionNotice` |
| Vendor links | `documentationUrl`, `privacyUrl`, `supportUrl`, `termsUrl` |
| Marketplace status | `monetized`, `installSupported`, `canInstall`, `updatedAt` |
| Media | `iconUrl`, `screenshots` |

### How much does it cost to scrape Zoom Marketplace apps?

This actor uses pay-per-event pricing. A small start event is charged per run and an item event is charged for each saved app record. Final production pricing is based on cloud run costs and competitor benchmarks before QA handoff.

Use a low `maxItems` value for exploratory runs, then increase it for category monitoring or full marketplace snapshots.

### Input options

- `searchTerms` — keywords such as `calendar`, `crm`, `transcription`, or `ai`.
- `startUrls` — direct app URLs or marketplace URLs.
- `categories` — category slugs or names such as `productivity` or `ai-apps`.
- `maxItems` — maximum number of app records to save.
- `includeDetails` — fetch detail metadata, scopes, permissions, and links.

### Example input

```json
{
  "searchTerms": ["calendar", "crm", "transcription"],
  "maxItems": 100,
  "includeDetails": true
}
````

### Direct app input

```json
{
  "startUrls": [
    { "url": "https://marketplace.zoom.us/apps/PN3rVBK6R0aXBU5Fw2i6aQ" }
  ],
  "maxItems": 1,
  "includeDetails": true
}
```

### Category monitoring input

```json
{
  "categories": ["productivity", "ai-apps"],
  "maxItems": 250,
  "includeDetails": true
}
```

### Output example

```json
{
  "appId": "PN3rVBK6R0aXBU5Fw2i6aQ",
  "name": "Glean Search Crawler for Zoom",
  "url": "https://marketplace.zoom.us/apps/PN3rVBK6R0aXBU5Fw2i6aQ",
  "publisher": "Glean",
  "categories": ["Other", "Productivity"],
  "scopes": ["meeting:read:meeting:admin"],
  "privacyUrl": "https://www.glean.com/privacy-policy",
  "sourcePage": "https://marketplace.zoom.us/apps?search=calendar",
  "scrapedAt": "2026-06-27T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Enter keywords, category slugs, or app URLs.
3. Keep `includeDetails` enabled for scopes and permissions.
4. Choose `maxItems` based on your budget.
5. Run the actor and download the dataset as JSON, CSV, Excel, or via API.

### Tips for best results

- Use specific keywords when researching a narrow integration space.
- Use categories for repeatable monitoring.
- Use direct app URLs for vendor due diligence.
- Disable `includeDetails` only when you need quick listing discovery.
- Schedule recurring runs and compare by `appId` for change detection.

### Monitoring Zoom app permissions

Run the actor on a fixed input daily or weekly, export the dataset, and compare `scopes`, `permissions`, `permissionNotice`, `privacyUrl`, and `updatedAt`. This helps security teams notice permission changes before approving or renewing integrations.

### Marketplace research workflow

A common workflow is to scrape 500-1000 apps, export to CSV, filter by category and publisher, then enrich target vendors in a CRM. Ecosystem teams can identify integration white space, competitive overlap, and partner candidates.

### Category tracking workflow

Set `categories` to important marketplace categories and schedule the actor weekly. The `sourcePage` field records the discovery route, making it easier to build category-level dashboards.

### Integrations

- Send dataset items to Google Sheets for analyst review.
- Push app records into Airtable or Notion for partner tracking.
- Load JSON exports into BigQuery, Snowflake, or Postgres.
- Trigger alerts when high-risk scopes or new permission notices appear.
- Combine with CRM enrichment tools to identify partner contacts.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zoom-marketplace-scraper').call({
  searchTerms: ['crm', 'calendar'],
  maxItems: 100,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/zoom-marketplace-scraper').call(run_input={
    'categories': ['productivity'],
    'maxItems': 100,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~zoom-marketplace-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["transcription"],"maxItems":100,"includeDetails":true}'
```

### MCP usage

Use Apify MCP from Claude Code or Claude Desktop with:

`https://mcp.apify.com/?tools=automation-lab/zoom-marketplace-scraper`

Claude Code setup command:

```bash
claude mcp add apify-zoom-marketplace https://mcp.apify.com/?tools=automation-lab/zoom-marketplace-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-zoom-marketplace": {
      "url": "https://mcp.apify.com/?tools=automation-lab/zoom-marketplace-scraper"
    }
  }
}
```

Example prompts:

- “Scrape Zoom Marketplace apps for AI meeting transcription and summarize publishers.”
- “Monitor Zoom Marketplace productivity apps and flag new OAuth scopes.”
- “Find Zoom Marketplace CRM integrations and export vendor privacy links.”

### Data freshness

The actor records `scrapedAt` on every row. If Zoom exposes app timestamps, `createdAt` and `updatedAt` are included. Use these fields together to distinguish marketplace updates from collection time.

### Detail extraction notes

When `includeDetails` is enabled, the actor calls public detail endpoints for each discovered app. This adds scopes, permissions, long descriptions, vendor links, install flags, and timestamps. Runs are faster when detail extraction is disabled.

### Limits and caveats

The actor does not log in to Zoom, install apps, access private apps, or inspect account-specific approval flows. Public `canInstall` and `installSupported` values may differ from what your Zoom admin account sees.

### FAQ

#### Does this actor require a Zoom account?

No. It collects public marketplace metadata only and does not log in or run account-specific admin flows.

#### Can it extract private marketplace apps?

No. Private or account-only apps are outside the public data boundary for this actor.

### Troubleshooting

#### Why are keyword results not exact?

Zoom's public search can rank names, descriptions, categories, and marketplace signals differently. Try combining `searchTerms` with `categories`, or use direct app URLs for exact extraction.

#### Why are ratings empty?

Some Zoom Marketplace apps do not expose public review statistics or have zero reviews. The actor returns `reviewCount: 0` or `rating: null` when Zoom does not provide a public value.

### Legality

This actor extracts public marketplace metadata. Review Zoom's terms and your compliance requirements before using the data commercially. Do not use the actor to bypass authentication, admin approval, or private account controls.

### Related scrapers

Explore related Automation Lab actors for marketplace and SaaS ecosystem research:

- `https://apify.com/automation-lab/miro-marketplace-scraper`
- `https://apify.com/automation-lab/website-contact-finder`
- `https://apify.com/automation-lab/company-enrichment-scraper`

### Field selection guide

- Use `appId` for stable joins.
- Use `publisher` and `categories` for segmentation.
- Use `scopes` and `permissions` for security review.
- Use `privacyUrl`, `supportUrl`, and `termsUrl` for vendor due diligence.
- Use `sourcePage` to understand how each app was discovered.

### Scheduling recommendations

- Weekly category snapshots for market maps.
- Daily permission monitoring for high-risk categories.
- One-off direct app runs for procurement or security review.
- Monthly full-marketplace sweeps for ecosystem trend reports.

### Export formats

JSON preserves nested arrays such as `scopes` and `permissions`. CSV and Excel are convenient for analyst review. Use the Apify dataset API for automated pipelines.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search in the Zoom App Marketplace. Leave empty to browse marketplace listings.

## `startUrls` (type: `array`):

Zoom Marketplace app detail, search, category, or /apps URLs to scrape.

## `categories` (type: `array`):

Optional Zoom category slugs or names to target, such as productivity, ai-apps, collaboration, or sales.

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

Maximum number of Zoom Marketplace apps to save.

## `includeDetails` (type: `boolean`):

Fetch public app detail records for scopes, permissions, links, descriptions, and install metadata.

## Actor input object example

```json
{
  "searchTerms": [
    "calendar",
    "crm",
    "transcription"
  ],
  "startUrls": [
    {
      "url": "https://marketplace.zoom.us/apps"
    }
  ],
  "categories": [
    "productivity",
    "ai-apps"
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchTerms": [
        "calendar",
        "crm",
        "transcription"
    ],
    "startUrls": [
        {
            "url": "https://marketplace.zoom.us/apps"
        }
    ],
    "categories": [
        "productivity",
        "ai-apps"
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchTerms": [
        "calendar",
        "crm",
        "transcription",
    ],
    "startUrls": [{ "url": "https://marketplace.zoom.us/apps" }],
    "categories": [
        "productivity",
        "ai-apps",
    ],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "searchTerms": [
    "calendar",
    "crm",
    "transcription"
  ],
  "startUrls": [
    {
      "url": "https://marketplace.zoom.us/apps"
    }
  ],
  "categories": [
    "productivity",
    "ai-apps"
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/zoom-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoom Marketplace Scraper",
        "description": "Scrape Zoom App Marketplace apps, publishers, categories, scopes, permissions, install links, and vendor metadata for SaaS research.",
        "version": "0.1",
        "x-build-id": "BF7ROIBijxGzCLWGV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zoom-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~zoom-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~zoom-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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",
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search in the Zoom App Marketplace. Leave empty to browse marketplace listings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Zoom Marketplace app detail, search, category, or /apps URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categories": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional Zoom category slugs or names to target, such as productivity, ai-apps, collaboration, or sales.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Zoom Marketplace apps to save.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include detail metadata",
                        "type": "boolean",
                        "description": "Fetch public app detail records for scopes, permissions, links, descriptions, and install metadata.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```