# Pipedrive Marketplace Apps Scraper (`automation-lab/pipedrive-marketplace-apps-scraper`) Actor

Extract Pipedrive Marketplace apps, vendors, categories, ratings, and CRM integration metadata for RevOps and SaaS market intelligence.

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

## Pipedrive Marketplace Apps Scraper

Extract structured app and integration records from the public Pipedrive Marketplace. The actor discovers apps from the marketplace page and sitemap, then returns catalog-ready records for RevOps, SaaS partnership, CRM consulting, and competitive-intelligence workflows.

### What does Pipedrive Marketplace Apps Scraper do?

Pipedrive Marketplace Apps Scraper turns Pipedrive's public integration marketplace into clean dataset rows.

It can collect:

- App names and marketplace URLs
- Slugs and Pipedrive client IDs
- Taglines and descriptions when available
- Categories and use-case collections
- Vendor/developer names from detail pages
- Ratings and review counts from detail pages
- Free/pricing labels when visible
- Feature labels, action names, screenshots, icons, and install URLs when detail pages are fetched
- A timestamp for monitoring and change detection

### Who is it for?

This actor is built for people who need repeatable CRM ecosystem intelligence.

- RevOps teams tracking tools that connect to Pipedrive
- SaaS partnership teams looking for integration partners
- CRM consultants building recommended app stacks
- Competitive-intelligence teams monitoring marketplace changes
- Data teams enriching internal app catalogs
- Agencies comparing integration coverage across CRM ecosystems

### Why use this Pipedrive Marketplace scraper?

Manual marketplace review is slow and hard to repeat. A dataset gives you a sortable, exportable view of the ecosystem.

Use it to:

- Build a current list of Pipedrive apps
- Monitor new or removed integrations
- Compare app categories and use cases
- Find vendors with strong review signals
- Track free-vs-paid labels where Pipedrive exposes them
- Feed BI dashboards, spreadsheets, or partner sourcing workflows

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

The actor uses pay-per-event pricing. You pay a small start fee and a per-record fee for each dataset item.

A cheap first run can use the default input with `maxItems` set to 20. For detail-rich enrichment, enable detail pages on a smaller batch first, then scale up when the run cost and output quality match your workflow.

### Input

The input is intentionally small.

```json
{
  "startUrls": [{ "url": "https://www.pipedrive.com/en/marketplace" }],
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMillis": 0,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### `startUrls`

Use the main marketplace URL for broad discovery. You can also pass individual app detail URLs such as:

```text
https://www.pipedrive.com/en/marketplace/app/zapier/10f6b602cda330ef
```

#### `maxItems`

Maximum number of app records to save. Use a small value for quick tests and a larger value for catalog monitoring.

#### `includeDetails`

When `false`, the actor returns fast catalog records from the marketplace page plus sitemap fallback URLs. This is the best default for monitoring large batches.

When `true`, the actor visits app detail pages to collect richer vendor, rating, screenshot, label, and feature metadata. Detail pages can be slower and may require proxy rotation.

#### `proxyConfiguration`

Apify Proxy is enabled by default because larger Pipedrive detail-page runs may rate-limit a single IP. Automatic/datacenter proxy is enough for normal use; residential proxy is not required by default.

### Output

Each dataset item represents one Pipedrive Marketplace app.

```json
{
  "clientId": "10f6b602cda330ef",
  "name": "Zapier",
  "slug": "zapier",
  "url": "https://www.pipedrive.com/en/marketplace/app/zapier/10f6b602cda330ef",
  "tagline": "Zapier automatically moves info between Pipedrive and the other apps you use every day...",
  "categories": ["Workflow automation"],
  "vendor": "Zapier, Inc.",
  "ratingAverage": 4.5,
  "reviewCount": 469,
  "isFree": true,
  "sourceType": "app",
  "scrapedAt": "2026-07-09T00:00:00.000Z"
}
```

### Data fields

| Field | Description |
| --- | --- |
| `clientId` | Pipedrive marketplace client ID |
| `name` | App name |
| `slug` | URL slug |
| `url` | Public Pipedrive Marketplace URL |
| `tagline` | Short app tagline when available |
| `description` | Full public description when detail pages are fetched |
| `categories` | Marketplace categories |
| `jtbdCategories` | Use-case/job-to-be-done collections |
| `vendor` | Developer or company name when available |
| `websiteUrl` | Vendor website URL when available |
| `installUrl` | Install/OAuth URL when exposed |
| `iconUrl` | App icon URL |
| `screenshotUrls` | Screenshot URLs from detail pages |
| `ratingAverage` | Average rating |
| `ratingTotal` | Rating score total exposed by Pipedrive |
| `reviewCount` | Number of reviews |
| `isFree` | Free label when visible |
| `labels` | Pipedrive app labels/flags |
| `featureTypes` | Active feature groups such as actions or panels |
| `actionNames` | Public action names from detail data |
| `collections` | Featured collections/use cases |
| `sourceType` | `marketplace`, `category`, or `app` |
| `sourceUrl` | URL used for extraction |
| `scrapedAt` | ISO timestamp |

### Fast catalog mode

Leave `includeDetails` disabled for large recurring jobs.

Fast mode:

- Reads the marketplace page
- Extracts rich records for apps embedded in the page
- Uses the public sitemap to discover additional app URLs
- Emits URL-only fallback rows for apps not embedded in the landing page
- Avoids hundreds of slow detail-page requests

This is useful for monitoring whether new apps appeared in the catalog.

### Detail enrichment mode

Enable `includeDetails` when you need richer app metadata.

Detail mode can collect:

- Vendor names
- Ratings and reviews
- Long descriptions
- Install instructions
- Screenshots
- Labels and feature types
- Action names

For best results, start with a small `maxItems` value, confirm the detail fields you need, then scale gradually.

### How to scrape the Pipedrive Marketplace

1. Open the actor on Apify.
2. Keep the default start URL: `https://www.pipedrive.com/en/marketplace`.
3. Set `maxItems` to the number of apps you want.
4. Keep `includeDetails` disabled for a fast catalog export, or enable it for richer app records.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Example use cases

- Weekly monitor of Pipedrive ecosystem additions
- Partner shortlist for SaaS integration outreach
- CRM stack recommendations for consultants
- Category-level market map of phone, email, automation, and analytics apps
- App catalog enrichment for internal RevOps portals
- Competitive comparison against HubSpot, Zoho, Salesforce, or Monday app marketplaces

### Tips for reliable runs

- Use the default proxy setting for larger runs.
- Keep `includeDetails` off for high-volume monitoring.
- Use `includeDetails` on smaller batches when you need screenshots, ratings, or vendor metadata.
- Increase `requestDelayMillis` if you want a gentler long-running detail crawl.
- Use exact app URLs for targeted enrichment of specific vendors.

### Integrations

Send the dataset to:

- Google Sheets for partnership research
- Airtable for vendor pipeline tracking
- BigQuery or Snowflake for ecosystem analytics
- Slack alerts for new app monitoring
- CRM records for partner account enrichment
- BI dashboards for category coverage reporting

### 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/pipedrive-marketplace-apps-scraper').call({
  startUrls: [{ url: 'https://www.pipedrive.com/en/marketplace' }],
  maxItems: 100,
  includeDetails: false,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/pipedrive-marketplace-apps-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.pipedrive.com/en/marketplace'}],
    'maxItems': 100,
    'includeDetails': False,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~pipedrive-marketplace-apps-scraper/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.pipedrive.com/en/marketplace"}],"maxItems":100,"includeDetails":false}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through Apify MCP.

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Scrape the first 100 Pipedrive Marketplace apps and summarize the top categories."
- "Find Pipedrive apps related to calling, messaging, and lead enrichment."
- "Create a partner outreach shortlist from Pipedrive Marketplace app vendors."

### Legality

This actor extracts publicly available marketplace information. Always follow Apify terms, Pipedrive terms, and applicable laws. Do not use the output for spam, credential abuse, or unauthorized access. Use reasonable limits and delays for repeated monitoring.

### FAQ

#### Can I scrape the full Pipedrive Marketplace catalog?

Yes. Use the main marketplace URL with a higher `maxItems` value. Fast mode combines visible marketplace cards with sitemap discovery for broad catalog coverage.

#### Should I enable detail pages for every run?

Use `includeDetails` when you need richer descriptions, labels, screenshots, and installation metadata. Leave it off for cheaper recurring monitoring.

### Troubleshooting

#### Why are some fields empty?

Fast catalog mode intentionally avoids detail-page requests. Enable `includeDetails` to fill more fields such as vendor, screenshots, and full descriptions.

#### Why did a detail run slow down?

Pipedrive can rate-limit repeated detail-page requests. Keep Apify Proxy enabled, reduce `maxItems`, or add a delay.

#### Why do I see fallback records?

Fallback records come from Pipedrive's public sitemap. They preserve app discovery coverage even when a detail page is slow or rate-limited.

### Related scrapers

You may also find these Automation Lab actors useful:

- https://apify.com/automation-lab/hubspot-marketplace-apps-scraper
- https://apify.com/automation-lab/zoho-marketplace-apps-scraper
- https://apify.com/automation-lab/stripe-marketplace-apps-scraper
- https://apify.com/automation-lab/zoom-marketplace-apps-scraper
- https://apify.com/automation-lab/google-workspace-marketplace-scraper

### Support

If the marketplace changes or you need a new field, open an Apify issue with a sample input and expected output. Include whether you ran fast catalog mode or detail enrichment mode.

# Actor input Schema

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

Pipedrive Marketplace URLs to scrape. Use the main marketplace URL for full catalog discovery, collection/category URLs for focused lists, or individual /marketplace/app/ URLs for specific apps.

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

Maximum number of app records to save. Keep this low for a cheap first run; increase to 460+ for the full current catalog.

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

When enabled, the actor visits app detail pages for vendor, labels, features, screenshots, ratings, and installation metadata. Leave disabled for fast catalog monitoring; the actor still uses the sitemap to discover app URLs.

## `requestDelayMillis` (type: `integer`):

Optional delay between app detail-page requests. The default is fast but polite enough for the public Next.js pages; raise it for monitoring jobs if needed.

## `proxyConfiguration` (type: `object`):

Uses Apify Proxy by default so larger detail-page runs avoid Pipedrive IP cooldowns. Datacenter/automatic Apify Proxy is enough; residential is not required by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.pipedrive.com/en/marketplace"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMillis": 0,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "startUrls": [
        {
            "url": "https://www.pipedrive.com/en/marketplace"
        }
    ],
    "maxItems": 20,
    "includeDetails": false,
    "requestDelayMillis": 0,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pipedrive-marketplace-apps-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 = {
    "startUrls": [{ "url": "https://www.pipedrive.com/en/marketplace" }],
    "maxItems": 20,
    "includeDetails": False,
    "requestDelayMillis": 0,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pipedrive-marketplace-apps-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 '{
  "startUrls": [
    {
      "url": "https://www.pipedrive.com/en/marketplace"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "requestDelayMillis": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/pipedrive-marketplace-apps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pipedrive Marketplace Apps Scraper",
        "description": "Extract Pipedrive Marketplace apps, vendors, categories, ratings, and CRM integration metadata for RevOps and SaaS market intelligence.",
        "version": "0.1",
        "x-build-id": "qpYeLNVo0DDF9ce5x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pipedrive-marketplace-apps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pipedrive-marketplace-apps-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~pipedrive-marketplace-apps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pipedrive-marketplace-apps-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~pipedrive-marketplace-apps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pipedrive-marketplace-apps-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": {
                    "startUrls": {
                        "title": "Marketplace, category, or app URLs",
                        "type": "array",
                        "description": "Pipedrive Marketplace URLs to scrape. Use the main marketplace URL for full catalog discovery, collection/category URLs for focused lists, or individual /marketplace/app/ URLs for specific apps.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of app records to save. Keep this low for a cheap first run; increase to 460+ for the full current catalog.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch app detail pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits app detail pages for vendor, labels, features, screenshots, ratings, and installation metadata. Leave disabled for fast catalog monitoring; the actor still uses the sitemap to discover app URLs.",
                        "default": false
                    },
                    "requestDelayMillis": {
                        "title": "Delay between detail requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional delay between app detail-page requests. The default is fast but polite enough for the public Next.js pages; raise it for monitoring jobs if needed.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify Proxy by default so larger detail-page runs avoid Pipedrive IP cooldowns. Datacenter/automatic Apify Proxy is enough; residential is not required by default.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
