# Depop Scraper (`khadinakbar/depop-scraper`) Actor

Scrape public Depop listings by keyword or product URL with prices, brands, sizes, images, seller stats, and detail enrichment. MCP-ready.

- **URL**: https://apify.com/khadinakbar/depop-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Depop Scraper

Scrape public Depop marketplace listings by keyword or product URL. This actor returns structured listing data for resale market research, vintage sourcing, price checks, brand monitoring, and seller catalog analysis. It is designed for AI agents, MCP clients, automations, and analysts who need clean JSON instead of screenshots or copied product-card text.

### When to use it

Use this actor when you need public Depop listing records for a keyword such as `vintage levis`, `carhartt jacket`, `y2k baby tee`, or when you already have Depop product URLs and want a structured record for each one. The actor is best for:

- Resale sellers checking comparable prices before buying or listing inventory.
- Vintage shops tracking brand, size, and price trends.
- Analysts building a small public Depop dataset for market research.
- AI agents that need a reliable tool call returning one JSON row per listing.
- Automations that monitor selected product URLs over time.

This actor does not log in, buy items, message sellers, scrape private account data, or manage a shop. It reads public marketplace pages and public product metadata only.

### Output data

Each dataset row is one Depop listing. When detail enrichment is enabled, rows can include:

| Field | Description |
| --- | --- |
| `productUrl` | Canonical public Depop product URL |
| `title` | Product title from the detail page |
| `description` | Public product description |
| `brandName` | Listing brand |
| `price`, `originalPrice`, `currency` | Current and original price values |
| `shippingPrice` | Shipping price when Depop exposes it |
| `size`, `sizes` | Size labels |
| `condition` | Depop condition label |
| `colors` | Color labels |
| `category`, `categoryPath`, `gender` | Marketplace category signals |
| `likeCount` | Public like count when available |
| `sellerUsername` | Seller handle inferred from the product slug |
| `sellerRating`, `sellerReviewCount`, `sellerItemsSold` | Seller signals from the product page |
| `imageUrl`, `imageUrls` | Main image and gallery URLs |
| `searchQuery` | Keyword that produced the record |
| `sourceType` | `search-api`, `browser-search`, or `product-url` |

### How it works

The actor first tries Depop's current public presentation search route because it is fast and returns clean listing objects. If Depop returns an anti-bot challenge or blocks the API route, the actor opens the public search page in a real browser and extracts the listings Depop renders there. Product detail enrichment opens each product page and reads the product JSON-LD plus public product metadata that Depop loads for the page.

This two-route design keeps simple runs fast while still giving the actor a verified fallback when Depop changes its edge behavior. The actor records which route was used in `RUN_SUMMARY` and in the dataset field `sourceType`.

### Input

#### Search mode

Use `mode: "search"` with `searchQueries`.

```json
{
  "mode": "search",
  "searchQueries": ["vintage levis", "carhartt jacket"],
  "country": "us",
  "maxItems": 10,
  "maxPages": 1,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

`maxPages` controls how many search API pages are attempted per keyword when the lightweight API route is available. Each page is about 24 listings. Defaults are intentionally small so Apify health checks and first runs finish quickly. If Depop challenges the API route, browser fallback returns the listings that can be verified from the rendered page instead of claiming pagination that did not work.

Residential proxy is enabled by default because Depop commonly blocks Apify cloud datacenter traffic. You can disable proxy for local tests or fixed product URL runs when Depop is reachable without it.

#### Product URL mode

Use `mode: "productUrls"` with direct Depop product URLs.

```json
{
  "mode": "productUrls",
  "productUrls": [
    "https://www.depop.com/products/redheadthreadf-vintage-y2k-levis-501-jeans-1a85/"
  ],
  "fetchDetails": true
}
```

Product URL mode is useful for monitoring known items, enriching URLs collected elsewhere, or rerunning a fixed list for price and availability changes.

### Pricing

This actor uses pay per event pricing.

- Actor start: `$0.00005` per run, scaled by memory.
- Listing scraped: `$0.005` per Depop listing returned.

The actor prints an upfront cost cap based on `maxItems`. For example, `maxItems: 25` caps listing-event charges at about `$0.125` plus the tiny start event. The actor also keeps an internal charge counter so it does not charge beyond the requested cap. Apify proxy usage is platform usage and may add separate proxy costs when residential proxy is enabled.

### Reliability behavior

Depop uses Cloudflare and bot-detection protection. The actor handles this in three ways:

1. It tries a lightweight HTTP search route first.
2. It falls back to a real browser for search pages if the API route is challenged.
3. It uses Apify Residential Proxy by default for cloud reliability.
4. It enriches products through browser-visible product metadata instead of relying on one brittle selector.

If Depop blocks every route and no usable listing can be verified, the actor fails honestly with an actionable status message. If a keyword has no listings or an input is invalid, the actor exits cleanly without charging listing events.

### MCP and AI agent use

Tool description draft:

Scrape public Depop marketplace listings by keyword or product URL. Use for resale price research, vintage sourcing, and brand monitoring. Do not use for private account data or seller messaging. Returns one row per listing with URL, title, price, brand, size, images, seller stats. $0.005/listing.

The input is intentionally small: pick a mode, provide keywords or product URLs, set a cap, and decide whether to enrich details. Dataset rows are flat and stable so agents can compare prices, summarize listings, or pass records into downstream tools.

### Limits

- Public data only.
- No login, buying, messaging, or seller admin actions.
- Deep pagination depends on Depop allowing the current search API route. Browser fallback is truthful and may return fewer listings than the requested cap if Depop blocks paginated API calls.
- Product details can change, sell out, or disappear between discovery and enrichment.

### Legal

Use this actor only for lawful purposes and respect Depop's terms, applicable privacy rules, and platform limits. The actor returns public marketplace data and does not bypass login-only areas or extract private account information.

# Actor input Schema

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

Choose how the actor finds Depop listings. Use 'search' to scrape public search results for one or more keywords, or 'productUrls' to enrich specific Depop product URLs. Defaults to 'search'. This is not a seller review scraper or a login-based shop manager.

## `searchQueries` (type: `array`):

Depop search terms to scrape in search mode, for example 'vintage levis' or 'y2k baby tee'. Each keyword is run separately and results are deduped by product URL. Defaults to 'vintage levis'. This is not a full-site crawl or authenticated saved search.

## `productUrls` (type: `array`):

Direct Depop product URLs to enrich in productUrls mode, for example 'https://www.depop.com/products/shopname-item-slug/'. Multiple URLs are supported and are deduped before scraping. Leave empty in search mode. This does not accept generic website URLs.

## `country` (type: `string`):

Country context for Depop search results and pricing, using lowercase ISO-like market codes such as 'us' or 'gb'. Defaults to 'us'. The country also informs the currency used by search requests. This is not a shipping destination filter.

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

Hard cap on the number of Depop listings returned and billed across the whole run. Defaults to 10 and can be set as low as 1 for a cheap test. The actor stops charging once this cap is reached. This is not a page count.

## `maxPages` (type: `integer`):

Maximum Depop search API pages to request per keyword when the lightweight API route is available. Each page is about 24 listings. Defaults to 1 so default runs finish quickly. If Depop challenges the API route, the actor falls back to the browser-loaded listings it can verify instead of pretending pagination worked.

## `fetchDetails` (type: `boolean`):

Open each product page to enrich listings with full title, description, image gallery, condition, colors, seller review count, items sold, and shipping signals. Defaults to true for richer records. Turn it off for faster keyword inventory checks. This does not log in or scrape private buyer data.

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

Apify proxy settings for Depop requests. Residential proxy is enabled by default because Depop commonly blocks Apify cloud datacenter traffic. The actor still tries the lightweight HTTP route first, then falls back to browser-rendered public listings. You can disable proxy for local tests or fixed product URLs if Depop is reachable without it.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "vintage levis",
    "carhartt jacket"
  ],
  "productUrls": [
    "https://www.depop.com/products/redheadthreadf-vintage-y2k-levis-501-jeans-1a85/"
  ],
  "country": "us",
  "maxItems": 10,
  "maxPages": 1,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items containing Depop product URLs, titles, prices, brands, sizes, conditions, image URLs, seller stats, source query, and scrape timestamp.

## `summary` (type: `string`):

Machine-readable run summary with mode, query counts, fallback route, item count, charge count, warnings, and status message.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQueries": [
        "vintage levis",
        "carhartt jacket"
    ],
    "productUrls": [
        "https://www.depop.com/products/redheadthreadf-vintage-y2k-levis-501-jeans-1a85/"
    ],
    "country": "us",
    "maxItems": 10,
    "maxPages": 1,
    "fetchDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/depop-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "searchQueries": [
        "vintage levis",
        "carhartt jacket",
    ],
    "productUrls": ["https://www.depop.com/products/redheadthreadf-vintage-y2k-levis-501-jeans-1a85/"],
    "country": "us",
    "maxItems": 10,
    "maxPages": 1,
    "fetchDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/depop-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchQueries": [
    "vintage levis",
    "carhartt jacket"
  ],
  "productUrls": [
    "https://www.depop.com/products/redheadthreadf-vintage-y2k-levis-501-jeans-1a85/"
  ],
  "country": "us",
  "maxItems": 10,
  "maxPages": 1,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/depop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Depop Scraper",
        "description": "Scrape public Depop listings by keyword or product URL with prices, brands, sizes, images, seller stats, and detail enrichment. MCP-ready.",
        "version": "0.1",
        "x-build-id": "ce5DLbwxh0LaYN6mK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~depop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-depop-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/khadinakbar~depop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-depop-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/khadinakbar~depop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-depop-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": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "search",
                            "productUrls"
                        ],
                        "type": "string",
                        "description": "Choose how the actor finds Depop listings. Use 'search' to scrape public search results for one or more keywords, or 'productUrls' to enrich specific Depop product URLs. Defaults to 'search'. This is not a seller review scraper or a login-based shop manager.",
                        "default": "search"
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Depop search terms to scrape in search mode, for example 'vintage levis' or 'y2k baby tee'. Each keyword is run separately and results are deduped by product URL. Defaults to 'vintage levis'. This is not a full-site crawl or authenticated saved search.",
                        "default": [
                            "vintage levis"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Depop product URLs to enrich in productUrls mode, for example 'https://www.depop.com/products/shopname-item-slug/'. Multiple URLs are supported and are deduped before scraping. Leave empty in search mode. This does not accept generic website URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Marketplace country",
                        "enum": [
                            "us",
                            "gb",
                            "au",
                            "ca",
                            "ie",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "nl",
                            "be",
                            "nz"
                        ],
                        "type": "string",
                        "description": "Country context for Depop search results and pricing, using lowercase ISO-like market codes such as 'us' or 'gb'. Defaults to 'us'. The country also informs the currency used by search requests. This is not a shipping destination filter.",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of Depop listings returned and billed across the whole run. Defaults to 10 and can be set as low as 1 for a cheap test. The actor stops charging once this cap is reached. This is not a page count.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum Depop search API pages to request per keyword when the lightweight API route is available. Each page is about 24 listings. Defaults to 1 so default runs finish quickly. If Depop challenges the API route, the actor falls back to the browser-loaded listings it can verify instead of pretending pagination worked.",
                        "default": 1
                    },
                    "fetchDetails": {
                        "title": "Fetch product details",
                        "type": "boolean",
                        "description": "Open each product page to enrich listings with full title, description, image gallery, condition, colors, seller review count, items sold, and shipping signals. Defaults to true for richer records. Turn it off for faster keyword inventory checks. This does not log in or scrape private buyer data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy settings for Depop requests. Residential proxy is enabled by default because Depop commonly blocks Apify cloud datacenter traffic. The actor still tries the lightweight HTTP route first, then falls back to browser-rendered public listings. You can disable proxy for local tests or fixed product URLs if Depop is reachable without it.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
