# Depop Scraper – Listings, Prices, Sellers & Demand (`yumitori/depop-market-intelligence`) Actor

Scrape Depop by keyword and get hundreds to thousands of real listings — price, discount, sold-status, condition, size, brand, colour, seller and live like-count — plus exact demand counts and seller stats (followers, rating, items sold). No proxies, no browser, no login.

- **URL**: https://apify.com/yumitori/depop-market-intelligence.md
- **Developed by:** [Yakugusa Yumitori](https://apify.com/yumitori) (community)
- **Categories:** E-commerce, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 – Resale Listings, Prices & Sellers

#### Type a keyword → get hundreds to thousands of real Depop listings with price, sold-status, condition, size, brand, likes + exact demand counts and seller stats.

## ⚡ No proxies. No browser. No setup.

Most Depop scrapers run a stealth **headless browser** (Camoufox / Playwright /
Puppeteer) and make **you** bring and configure residential proxies — slow, expensive,
fragile, and fiddly to set up. **This one doesn't.** Just type a keyword and run:

| | **This actor** | Typical Depop scrapers |
|---|---|---|
| **Proxy setup** | ✅ **None — works out of the box** | ❌ You must supply & configure proxies |
| **Engine** | ✅ Lightweight (no browser) | ❌ Headless browser (Camoufox/Playwright) |
| **Speed** | ✅ Hundreds of listings in seconds | ❌ Browser pages load one at a time |
| **Cost per run** | ✅ Low (no browser CPU/RAM) | ❌ High (heavy browser containers) |
| **Demand data** | ✅ Exact live market counts | ❌ Listings only |
| **Seller stats** | ✅ Followers / rating / items sold | ❌ Rarely included |
| **Reliability** | ✅ No captchas, no browser flakiness | ❌ Breaks when the page UI changes |

**Bottom line:** more data, faster and cheaper, with zero configuration — captured live
from Depop, never estimated.

---

### 🛍️ What you get per listing

| Field | Example |
|---|---|
| `price` / `original_price` / `discount_pct` | `50.00` / `170.00` / `71` |
| `brand` | `Carhartt` |
| `condition` | `used_excellent` |
| `sizes` | `["L"]` |
| `colours` | `["navy","blue"]` |
| `like_count` | `277` ← per-listing demand signal |
| `status` | `ONSALE` / `SOLD` |
| `seller` + `url` | `@mila_mae` · link |
| `category` / `department` / `location` | `Outerwear` / `Menswear` / `Lake Stevens, US` |
| `photo` | image thumbnail |

**Optional seller enrichment** adds `seller_followers`, `seller_rating`,
`seller_reviews`, `seller_items_sold`, `seller_verified` to every listing — and a
dedicated **Sellers** tab.

Plus a per-keyword **run summary** (Key-Value store → `SUMMARY`): live demand total,
department split, price min/median/max, % reduced, and top brands.

---

### 🎯 Best features

- **Zero proxy setup** — it just works. No residential proxy account, no config.
- **Live demand counts** — the *exact* number of listings for your keyword, split by
  department. Real market size, not a guess.
- **Per-listing likes** — the clearest demand signal Depop exposes. Sort by it to see
  what's actually selling.
- **Seller intelligence** — followers, rating, reviews and items-sold for the sellers
  behind every listing.
- **Depth is a dial** — *Light* pulls a fast few-hundred sample; *Deep* pulls a few
  thousand. You choose coverage vs. speed.
- **Captured live** — every field is read from Depop at run time, never modelled.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array | — | Keywords to harvest, e.g. `"carhartt jacket"`, `"y2k baby tee"`. |
| `depth` | select | `light` | `light` ≈ a few hundred listings · `deep` ≈ a few thousand. |
| `maxItemsPerTerm` | integer | `500` | Cap on listings kept per keyword. |
| `enrichSellers` | boolean | `false` | Add seller followers / rating / items-sold (Sellers tab). |
| `country` | string | `us` | Market for demand counts & pricing (ISO-2). |
| `startUrls` | array | — | Depop search URLs (harvested like keywords) or shop URLs. |
| `shopNames` | array | — | Seller handles, e.g. `"shadyvtg"` — pulls their stats directly. |

**Minimal — just type a keyword:**

```json
{
  "searchTerms": ["carhartt jacket"]
}
````

**Full example:**

```json
{
  "searchTerms": ["carhartt jacket", "y2k baby tee"],
  "depth": "light",
  "maxItemsPerTerm": 500,
  "enrichSellers": true,
  "country": "us"
}
```

#### Coverage depth

| Depth | Listings / keyword |
|---|---|
| **Light** | a few hundred |
| **Deep** | a few thousand |

For niche keywords, *Deep* approaches full-market coverage. For huge keywords it
returns a deep, deduped, representative sample.

***

### Output

Results land in two dataset views — **🛍️ Listings** and **🏪 Sellers** — plus a
per-keyword **run summary** in the Key-Value store. Every record is clean JSON, ready
for the API, MCP, or any downstream tool.

#### 🛍️ A listing (keyword / search-URL run)

Every listing is a complete record — here's one in full (`enrichSellers` on adds the
`seller_*` fields):

```json
{
  "id": 774289895,
  "url": "https://www.depop.com/products/chow_picky-vintage-carhartt-jacket-very-high-8a0b/",
  "photo": "https://media-photos.depop.com/b1/452092653/3909731495_…/P0.jpg",
  "brand": "Carhartt",
  "price": 50.0,
  "original_price": 170.0,
  "currency": "USD",
  "is_reduced": true,
  "discount_pct": 71,
  "status": "ONSALE",
  "condition": "used_good",
  "sizes": ["M"],
  "colours": ["navy", "blue"],
  "like_count": 61,
  "category": "Outerwear",
  "department": "Menswear",
  "product_type": "jackets",
  "description": "Vintage carhartt jacket very high quality and nice fade #90s #sick #workwear",
  "location": "Lake Stevens, United States",
  "country": "US",
  "username": "chow_picky",
  "search_term": "carhartt jacket",
  "seller": "chow_picks",
  "seller_followers": 27,
  "seller_rating": 5.0,
  "seller_reviews": 4,
  "seller_items_sold": 26,
  "seller_verified": false
}
```

#### 🏪 A seller (shop-URL / `shopNames` run)

```json
{
  "record_type": "seller",
  "seller": "shadyvtg",
  "seller_followers": 3053,
  "seller_rating": 3.95,
  "seller_reviews": 1674,
  "seller_items_sold": 10073,
  "seller_verified": true,
  "seller_url": "https://www.depop.com/shadyvtg/"
}
```

#### 📊 Run summary (Key-Value store → `SUMMARY`)

One entry per keyword — the market at a glance:

```json
{
  "keyword": "carhartt jacket",
  "demand_total": 69514,
  "departments": { "menswear": 60362, "womenswear": 7604, "kidswear": 1442, "everything_else": 106 },
  "harvested": 500,
  "price_min": 8.0,
  "price_median": 62.0,
  "price_max": 480.0,
  "reduced_count": 168,
  "top_brands": { "Carhartt": 451, "Carhartt WIP": 15, "Dickies": 13, "Nike": 6 }
}
```

***

### Use cases

- **Resellers & vintage dealers** — price your inventory against the live market (median
  - distribution by condition and size); see which brands and styles get the most likes.
- **Sourcing** — find high-demand, under-supplied niches before you buy stock.
- **Brands & brand protection** — monitor the secondhand volume and pricing of your label,
  spot grey-market activity, and gauge brand health on the resale market.
- **Market researchers & analysts** — measure demand via listing volume + engagement,
  benchmark resale prices against retail, and build datasets for fashion/circular-economy
  research.
- **Competitor analysis** — see who the top sellers are for any keyword and how their
  catalogs are priced.

***

### Good to know — results mirror Depop's own search

Your results are **exactly what Depop returns** for that keyword — faithful and
unfiltered. So you may see listings whose `brand` isn't the literal word you typed.
That's expected and correct:

- **Style & aesthetic keywords aren't brands** — searching `y2k`, `vintage`,
  `streetwear` or `cottagecore` returns *every* brand tagged that way (American Vintage,
  Mossimo, Southpole…) plus lots of **`Other`** (unbranded thrift/vintage — which is most
  of that market). That spread *is* the real picture for a style search.
- **Sub-brands & parent brands** — e.g. searching `jordan` also returns `Nike`-branded
  listings, because Air Jordan is a Nike line and sellers tag it either way. Searching
  `carhartt` returns `Carhartt WIP` too.
- **Keyword in the title** — Depop matches your term against titles, tags and
  descriptions, so a listing that *mentions* your keyword can carry a different brand.

This is what you want for **accurate market data** — if we silently dropped those, your
price and demand numbers would be wrong (often a large share of a model's market is
tagged under the parent brand).

**Want just one exact brand?** Everything you need is already in the data — filter it
in one click:

1. Open the **Storage → Dataset** tab (or export to CSV / Google Sheets).
2. Filter or sort by the **`brand`** column (e.g. keep only `brand = "Jordan"`).
3. The `top_brands` block in the run **summary** shows the full brand breakdown so you
   know what's in there before you filter.

***

### FAQ

**Is scraping Depop legal?**
This actor only collects **public** listing and shop data — pages anyone can view without
logging in — and never bypasses access controls or touches private/account data. That's
the lower-risk category, but you're responsible for using the data in line with Depop's
Terms and any privacy rules (GDPR / CCPA) that apply to you.

**Do I need a Depop login or account?**
No. Everything comes from public pages — no login, no cookies, no account.

**How fresh is the data?**
Every field is read from Depop **live at run time** — never cached or estimated. Depop
has no fixed refresh schedule, so you set the cadence: run it on the Apify **scheduler**
(e.g. daily for price/inventory tracking, weekly for trends).

**Can I get sold items and seller stats?**
Yes — to the extent Depop shows them publicly, which this actor reads directly. Each
listing carries its **status** (`ONSALE` / `SOLD`), and seller enrichment pulls
**followers, rating, reviews and items-sold** from public shop pages. Most tools can't
reliably surface these — we read them straight off the page.

**Which markets does it cover?**
Set the `country` input (ISO-2, e.g. `us`, `gb`, `au`) — demand counts and pricing
reflect that market.

***

### Notes

- Public Depop data only — no login, no personal/private data, no account access.
- Junk/placeholder listings (e.g. "ISO" posts, sentinel prices) are filtered out.
- Prices are in the market's currency (set by `country`).

# Actor input Schema

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

Keywords to harvest, e.g. "carhartt jacket", "y2k baby tee", "stussy". Each returns deduped active listings with full attributes + live demand counts.

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

Paste Depop URLs instead of (or with) keywords. A search URL (depop.com/search/?q=…) is harvested like a keyword. A shop URL (depop.com/username) — or a product URL (depop.com/products/username-…) — returns that seller's public stats (followers, rating, items sold).

## `shopNames` (type: `array`):

Seller usernames to pull public stats for (followers, rating, reviews, items sold). e.g. "shadyvtg". One billed record each.

## `depth` (type: `string`):

Light ≈ a few hundred listings/keyword in ~45s (price × sort × colour). Deep ≈ a few thousand/keyword in ~2–3 min (full price × colour cross-product). Depth is a cost/coverage dial.

## `maxItemsPerTerm` (type: `integer`):

Hard cap on deduped listings kept per keyword (after junk-filtering). Each kept listing is a billed event.

## `enrichSellers` (type: `boolean`):

Add the seller's followers / rating / reviews / items-sold to every listing (one extra page per unique seller, cached). Off = faster, listings only.

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

Country context for demand counts and pricing (ISO-2, e.g. us, gb, au).

## Actor input object example

```json
{
  "searchTerms": [
    "carhartt jacket"
  ],
  "startUrls": [],
  "shopNames": [],
  "depth": "light",
  "maxItemsPerTerm": 500,
  "enrichSellers": false,
  "country": "us"
}
```

# Actor output Schema

## `listings` (type: `string`):

All harvested listings and seller records.

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

Per-keyword demand, price stats, top brands.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchTerms": [
        "carhartt jacket"
    ],
    "startUrls": [],
    "shopNames": []
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchTerms": ["carhartt jacket"],
    "startUrls": [],
    "shopNames": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "carhartt jacket"
  ],
  "startUrls": [],
  "shopNames": []
}' |
apify call yumitori/depop-market-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Depop Scraper – Listings, Prices, Sellers & Demand",
        "description": "Scrape Depop by keyword and get hundreds to thousands of real listings — price, discount, sold-status, condition, size, brand, colour, seller and live like-count — plus exact demand counts and seller stats (followers, rating, items sold). No proxies, no browser, no login.",
        "version": "0.1",
        "x-build-id": "f7v3lRigoxCPERZWj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yumitori~depop-market-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yumitori-depop-market-intelligence",
                "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/yumitori~depop-market-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-yumitori-depop-market-intelligence",
                "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/yumitori~depop-market-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-yumitori-depop-market-intelligence",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search keywords",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keywords to harvest, e.g. \"carhartt jacket\", \"y2k baby tee\", \"stussy\". Each returns deduped active listings with full attributes + live demand counts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Depop URLs (search / shop / product)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste Depop URLs instead of (or with) keywords. A search URL (depop.com/search/?q=…) is harvested like a keyword. A shop URL (depop.com/username) — or a product URL (depop.com/products/username-…) — returns that seller's public stats (followers, rating, items sold).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "shopNames": {
                        "title": "Shop names / @handles",
                        "type": "array",
                        "description": "Seller usernames to pull public stats for (followers, rating, reviews, items sold). e.g. \"shadyvtg\". One billed record each.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "depth": {
                        "title": "Coverage depth",
                        "enum": [
                            "light",
                            "deep"
                        ],
                        "type": "string",
                        "description": "Light ≈ a few hundred listings/keyword in ~45s (price × sort × colour). Deep ≈ a few thousand/keyword in ~2–3 min (full price × colour cross-product). Depth is a cost/coverage dial.",
                        "default": "light"
                    },
                    "maxItemsPerTerm": {
                        "title": "Max listings per keyword",
                        "minimum": 10,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on deduped listings kept per keyword (after junk-filtering). Each kept listing is a billed event.",
                        "default": 500
                    },
                    "enrichSellers": {
                        "title": "Enrich with seller stats",
                        "type": "boolean",
                        "description": "Add the seller's followers / rating / reviews / items-sold to every listing (one extra page per unique seller, cached). Off = faster, listings only.",
                        "default": false
                    },
                    "country": {
                        "title": "Market (country)",
                        "type": "string",
                        "description": "Country context for demand counts and pricing (ISO-2, e.g. us, gb, au).",
                        "default": "us"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
