# Zapier App Directory Scraper (`automation-lab/zapier-scraper`) Actor

Scrape the Zapier app directory for 9,000+ integrations. Get app names, slugs, descriptions, popularity rankings, categories, logos, beta/premium flags, and direct URLs. Filter by search term or category.

- **URL**: https://apify.com/automation-lab/zapier-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Zapier App Directory Scraper

Extract data on 9,000+ apps from the [Zapier app directory](https://zapier.com/apps) — including app names, slugs, categories, popularity rankings, partner tiers (PLATINUM, GOLD, etc.), logos, and more. Filter by search term or category to get targeted subsets.

### 🔍 What does it do?

The **Zapier App Directory Scraper** retrieves app metadata from Zapier's integration directory — the world's largest automation marketplace with 9,000+ connected apps. It fetches all available fields from Zapier's backend API including:

- App name, slug, and description
- Popularity ranking (Zapier's internal score)
- Category tags (e.g., CRM, Marketing Automation, AI Assistants)
- Logo URL
- Partner tier status (premium, featured, beta flags)
- Direct Zapier directory URL

Results are returned sorted by Zapier's popularity rank (most popular apps first), or filtered by your search term or category.

### 👥 Who is it for?

**SaaS companies monitoring their Zapier presence:**
Track your app's popularity ranking, partner tier, and category placement vs competitors. See which apps are rising in rank and benchmarking opportunities.

**Venture capital and market researchers:**
Map the integration ecosystem for a sector. Which CRM tools have Zapier integrations? Which AI assistants are gaining momentum? Get structured data to analyze trends across 9,000+ tools.

**Automation consultants:**
Quickly search the full Zapier catalog to find the right integrations for client workflows. Export lists of apps by category to build automation blueprints.

**Developer advocates and integration teams:**
Monitor new apps entering your competitive category. Track which tools are marked as PREMIUM and which are in BETA to stay ahead of competitors.

**No-code ecosystem analysts:**
The Zapier directory is the de-facto list of tools that "matter" in the no-code ecosystem. Use this data to power competitive analysis, market maps, and investment theses.

### 🚀 Why use this scraper?

- **No coding required** — Just set your filters and run. Get a spreadsheet-ready JSON/CSV export in seconds
- **Sorted by real demand** — Results are ranked by Zapier's internal popularity score, giving you a built-in signal of which apps users actually connect
- **Category filtering** — Filter by 50+ Zapier categories (CRM, Email, AI Assistants, eCommerce, etc.) to get targeted lists
- **Full metadata** — Get logos, descriptions, beta/premium flags, and direct URLs — everything you need for a competitive analysis
- **API-powered** — Uses Zapier's own search infrastructure for reliable, fast results

### 📊 Data extracted

| Field | Description | Example |
|-------|-------------|---------|
| `name` | App display name | `"Salesforce"` |
| `slug` | URL-friendly identifier | `"salesforce"` |
| `description` | App description from Zapier | `"Salesforce is a leading..."` |
| `imageUrl` | Logo image URL | `"https://zapier-images.imgix.net/..."` |
| `popularityRank` | Zapier popularity rank (1 = most popular) | `5` |
| `categories` | Array of category tags | `["CRM", "Sales & CRM"]` |
| `appId` | Zapier's internal app ID | `"4716"` |
| `isBeta` | Whether the app is in beta | `false` |
| `isPremium` | Whether the app requires a premium plan | `false` |
| `isFeatured` | Whether the app is featured on Zapier | `true` |
| `url` | Direct Zapier directory URL | `"https://zapier.com/apps/salesforce"` |

### 💰 How much does it cost to scrape the Zapier app directory?

This actor uses pay-per-result pricing. You only pay for results you extract.

| Volume | Estimated cost |
|--------|---------------|
| 100 apps | ~$0.10 |
| 500 apps | ~$0.50 |
| 1,000 apps (full directory) | ~$1.00 |

**Free plan estimate:** Apify's free plan includes $5 of monthly usage, enough to scrape the full 1,000-app result set 5 times per month.

**Cost tip:** Category-filtered searches are just as fast and cheap as the full directory — filter by your target category to get only the apps you need.

### 📋 How to use it

#### Option 1: Apify Console (no code)

1. Go to the [Zapier App Directory Scraper](https://apify.com/automation-lab/zapier-scraper) on the Apify Store
2. Click **Try for free**
3. Set your filters:
   - Leave everything blank to get the top 1,000 most popular apps
   - Add a **search query** (e.g., `"Salesforce"`) to find specific apps
   - Add **categories** (e.g., `["CRM (Customer Relationship Management)"]`) to filter by category
4. Click **Start** and download results as JSON or CSV

#### Option 2: API or code (see below)

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `""` | Search term to filter apps (e.g., `"email"`, `"CRM"`, `"Salesforce"`) |
| `categories` | string[] | `[]` | Filter by Zapier category names. Leave empty for all categories |
| `maxResults` | integer | `1000` | Maximum number of apps to return (1–1,000) |

#### Category names

Common categories include: `AI Assistants`, `CRM (Customer Relationship Management)`, `Email`, `eCommerce`, `Marketing Automation`, `Forms & Surveys`, `Project Management`, `Phone & SMS`, `Scheduling & Booking`, `Developer Tools`, `Productivity`, `Analytics`, `Payment Processing`, `Team Collaboration`, `Accounting`, `HR Talent & Recruitment`, `Documents`, `Communication`, `Video & Audio`, `Website Builders`.

You can filter by multiple categories at once — results will include apps in ANY of the listed categories.

### 📤 Output example

```json
[
  {
    "name": "Google Sheets",
    "slug": "google-sheets",
    "description": "Create, edit, and share spreadsheets wherever you are with Google Sheets, and get automated insights from your data.",
    "imageUrl": "https://zapier-images.imgix.net/storage/services/8913a06feb7556d01285c052e4ad59d0.png",
    "popularityRank": 1,
    "categories": ["Google", "Spreadsheets"],
    "appId": "1498",
    "isBeta": false,
    "isPremium": false,
    "isFeatured": true,
    "url": "https://zapier.com/apps/google-sheets"
  },
  {
    "name": "Gmail",
    "slug": "gmail",
    "description": "One of the most popular email services, Gmail keeps track of all your emails...",
    "imageUrl": "https://zapier-images.imgix.net/storage/services/1afcb319c029ec5da10efb593b7159c8.png",
    "popularityRank": 2,
    "categories": ["Email", "Google"],
    "appId": "20",
    "isBeta": false,
    "isPremium": false,
    "isFeatured": true,
    "url": "https://zapier.com/apps/gmail"
  }
]
````

### 💡 Tips and tricks

- **Get the full top-1000 list**: Leave all filters empty and set `maxResults: 1000`. This gives you Zapier's most popular integrations sorted by usage.
- **Monitor a category**: Filter by a category (e.g., `"AI Assistants"`) to track all tools in your competitive space.
- **Find beta apps**: Export the full directory and filter locally by `isBeta: true` to find apps in early access.
- **Competitive intelligence**: Search for your product category and sort by `popularityRank` to see the top players.
- **Category names are case-sensitive**: Use the exact names from Zapier, e.g., `"CRM (Customer Relationship Management)"` not `"CRM"`.
- **Combine search + category**: You can set both `searchQuery` and `categories` to narrow down results further.

### 🔗 Integrations

#### Google Sheets — Build a competitor tracker

1. Run the actor filtered to your category (e.g., `["CRM (Customer Relationship Management)"]`)
2. Use Apify's Google Sheets integration to push results directly to a spreadsheet
3. Set up a scheduled run weekly to track ranking changes over time

#### Airtable — Integration marketplace map

1. Scrape the full 1,000 apps
2. Push to Airtable as a base with category views
3. Filter and group by category to create market landscape maps

#### Make / Zapier — Automate competitive monitoring

1. Connect the actor to Make or Zapier's scheduler
2. Run weekly and compare new results to previous exports
3. Alert when new competitors appear in your category or existing ones move up in rank

#### Notion — Build an integration database

1. Run the scraper for your target categories
2. Send results to a Notion database via Apify's Notion integration
3. Tag, annotate, and filter integrations for your team's reference

### 🔌 API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/zapier-scraper').call({
  searchQuery: '',
  categories: ['AI Assistants'],
  maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} apps`);
items.forEach(app => console.log(`${app.name} (rank #${app.popularityRank})`));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/zapier-scraper').call(run_input={
    'searchQuery': '',
    'categories': ['AI Assistants'],
    'maxResults': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Got {len(items)} apps')
for app in items:
    print(f"{app['name']} (rank #{app['popularityRank']})")
```

#### cURL

```bash
## Start the actor
curl -X POST "https://api.apify.com/v2/acts/automation-lab~zapier-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "",
    "categories": ["AI Assistants"],
    "maxResults": 100
  }'

## Get results (replace RUN_ID and DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

### 🤖 MCP (AI assistant) usage

Use this actor directly from Claude, Cursor, VS Code, or any MCP-compatible AI assistant to query the Zapier app directory without writing code.

#### Claude Code (terminal)

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/zapier-scraper"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config file (`~/.claude/claude_desktop_config.json` or equivalent):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/zapier-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Example prompts

- *"What are the top 20 most popular AI tools in the Zapier directory?"*
- *"Find all CRM apps with Zapier integrations and export to CSV"*
- *"Which email marketing tools are featured on Zapier?"*
- *"Get me the full list of project management apps ranked by popularity"*
- *"Are there any beta apps in the eCommerce category on Zapier?"*

### ⚖️ Legality and terms of service

This actor scrapes publicly available data from the Zapier app directory (zapier.com/apps), which is accessible without authentication. The data extracted (app names, descriptions, categories, logos) is publicly listed by Zapier for the purpose of promoting their integrations.

Web scraping of publicly available data is generally lawful in most jurisdictions. However, users are responsible for ensuring their use case complies with Zapier's [Terms of Service](https://zapier.com/legal/terms-of-service) and applicable law.

This actor is intended for market research, competitive analysis, and integration discovery — not for republishing Zapier's content or circumventing any access controls.

### ❓ FAQ

**Q: Why do I only get 1,000 results when Zapier has 9,000+ apps?**
A: The Zapier search API used by this actor returns up to 1,000 results per query. The results are sorted by popularity, so you get the top 1,000 most popular integrations — which covers most practical use cases. Use category filtering to access different subsets.

**Q: The categories filter returned 0 results — what's wrong?**
A: Category names are case-sensitive and must match exactly. Use the examples from the "Category names" section above. For example: `"CRM (Customer Relationship Management)"` not just `"CRM"`. You can also leave categories empty and filter the exported data yourself.

**Q: How often is Zapier's directory updated?**
A: Zapier regularly adds new integrations. The actor always fetches live data from Zapier's current directory — no cached data.

**Q: Can I scrape individual app pages for more details?**
A: This actor focuses on the directory listing data. Each app also has a detail page at `https://zapier.com/apps/{slug}` with trigger/action counts. Contact us if you need a more detailed app profile scraper.

**Q: My run succeeded but the dataset is empty — what happened?**
A: If no apps match your search query or category filter, the actor will succeed but produce no results. Try a different category name (see the category list above) or remove the filters to get all apps.

### 🔗 Related scrapers

- [Apify Store](https://apify.com/automation-lab) — More automation-lab actors for integration ecosystem data

# Actor input Schema

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

Search term to find specific apps (e.g. "CRM", "email", "Salesforce"). Leave empty to get all apps sorted by popularity.

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

Filter apps by Zapier category names (e.g. \["Email", "CRM (Customer Relationship Management)"]). Leave empty to include all categories.

## `maxResults` (type: `integer`):

Maximum number of apps to return. The Zapier directory contains 9,000+ apps, but the API returns up to 1,000 per query.

## Actor input object example

```json
{
  "categories": [],
  "maxResults": 20
}
```

# 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 = {
    "searchQuery": "",
    "categories": [],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zapier-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 = {
    "searchQuery": "",
    "categories": [],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/zapier-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 '{
  "searchQuery": "",
  "categories": [],
  "maxResults": 20
}' |
apify call automation-lab/zapier-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zapier App Directory Scraper",
        "description": "Scrape the Zapier app directory for 9,000+ integrations. Get app names, slugs, descriptions, popularity rankings, categories, logos, beta/premium flags, and direct URLs. Filter by search term or category.",
        "version": "0.1",
        "x-build-id": "bB2r0m5caErjzn1jd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zapier-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-zapier-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~zapier-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-zapier-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~zapier-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-zapier-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": {
                    "searchQuery": {
                        "title": "🔍 Search query",
                        "type": "string",
                        "description": "Search term to find specific apps (e.g. \"CRM\", \"email\", \"Salesforce\"). Leave empty to get all apps sorted by popularity."
                    },
                    "categories": {
                        "title": "📂 Categories",
                        "type": "array",
                        "description": "Filter apps by Zapier category names (e.g. [\"Email\", \"CRM (Customer Relationship Management)\"]). Leave empty to include all categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "📊 Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of apps to return. The Zapier directory contains 9,000+ apps, but the API returns up to 1,000 per query.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
