# ThredUp Scraper | Secondhand Clothing Listings (`parseforge/thredup-scraper`) Actor

Scrape ThredUp secondhand fashion listings with brand, size, condition, original price, sale price, photos, and seller info. Monitor inventory, track resale prices, and analyze the thrift apparel market for retail intelligence, reselling, and competitive research projects.

- **URL**: https://apify.com/parseforge/thredup-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 👗 ThredUp Scraper

> 🚀 **Export secondhand clothing listings from ThredUp in seconds.** Search by keyword, filter by department, and get structured data including brand, size, condition, price, and image URL.

> 🕒 **Last updated:** 2026-05-21 - **📊 16 fields** per record - **Up to 1,000,000 items** - **US coverage**

ThredUp is one of the world's largest online resale platforms for secondhand and thrift clothing. This scraper connects directly to ThredUp's GraphQL API to extract real-time product listings from their database of millions of items. No login required. Data is scraped live on every run.

ThredUp lists items from thousands of brands across women's, men's, and kids' categories. Every item includes brand, condition rating (Like New, Gently Used), price, original MSRP, discount percentage, and product images.

### Target Audience / Use Cases

| User Type | Use Case |
|-----------|----------|
| Resellers | Monitor ThredUp for high-value items below market price |
| Fashion researchers | Analyze secondhand market pricing and brand trends |
| Price comparison tools | Compare resale prices across platforms |
| Sustainability trackers | Measure secondhand fashion supply and demand |
| Bargain hunters | Find specific brands or styles at thrift prices |
| Data scientists | Build recommender systems using resale data |

### 📋 What the ThredUp Scraper does

- Searches ThredUp's full inventory using any keyword or phrase
- Filters results by department (Women, Men, Kids)
- Extracts brand, size, condition, price, discount vs. MSRP, and product images
- Paginates through all result pages automatically
- Returns real-time data - no cached results
- Exports to JSON, CSV, Excel, and XML via Apify dataset

> 💡 **Why it matters:** ThredUp lists over 35,000 new items per day. Monitoring these listings helps resellers spot underpriced inventory, researchers track fast fashion secondhand volumes, and savvy shoppers find deep discounts on designer brands.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | string | Keyword to search (e.g. "dresses", "Nike sneakers", "vintage Levi") | `dresses` |
| `maxItems` | number | Max items to return. Free: 10, Paid: up to 1,000,000 | `10` |
| `department` | select | Filter by department: All, Women, Kids, Men | All |

#### Example Input - Keyword Search

```json
{
  "searchQuery": "dresses",
  "maxItems": 100
}
````

#### Example Input - Department Filter

```json
{
  "searchQuery": "Nike",
  "department": "men",
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** ThredUp's search covers their full live inventory. Results vary by day as items sell and new ones are listed. For consistent monitoring, schedule this actor to run daily.

### 📊 Output

Each item returned contains these fields:

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Primary product image (xlarge) |
| 📝 `title` | string | Product title |
| 🏷️ `brand` | string | Brand name |
| 📐 `size` | string | Item size (S, M, L, XL, 12, etc.) |
| 🎨 `color` | string/null | Item color (not available in ThredUp's search API) |
| ⭐ `condition` | string | Condition label (Like New, Gently Used, Moderate Use) |
| 💵 `price` | number | ThredUp listing price in USD |
| 🏷️ `originalPrice` | number | ThredUp's original listing price |
| 📉 `discount` | number | Discount % off MSRP |
| 🔗 `url` | string | Product page URL |
| 🆔 `id` | number | ThredUp item ID |
| 📁 `category` | string | Category (Casual Dress, Cocktail Dress, etc.) |
| ✨ `isNewWithTags` | boolean | True if item is new with original tags |
| 👥 `department` | string | Department (women, men, kids) |
| 🕐 `scrapedAt` | string | ISO timestamp of scrape |
| ❌ `error` | string/null | Error message if scraping failed |

#### Sample Records

```json
[
  {
    "imageUrl": "https://cf-assets-thredup.thredup.com/assets/875989183/xlarge.jpg",
    "title": "Michael Michael Kors Casual Dress",
    "brand": "MICHAEL Michael Kors",
    "size": "XL",
    "color": null,
    "condition": "Like New",
    "price": 64.99,
    "originalPrice": 59.74,
    "discount": 71,
    "url": "https://www.thredup.com/product/219448135",
    "id": 219448135,
    "category": "Casual Dress",
    "isNewWithTags": false,
    "department": "X",
    "scrapedAt": "2026-05-22T01:27:52.691Z",
    "error": null
  },
  {
    "imageUrl": "https://cf-assets-thredup.thredup.com/assets/862802311/xlarge.jpg",
    "title": "Lush Casual Dress",
    "brand": "Lush",
    "size": "L",
    "color": null,
    "condition": "Gently Used",
    "price": 28.99,
    "originalPrice": 25.74,
    "discount": 70,
    "url": "https://www.thredup.com/product/217138533",
    "id": 217138533,
    "category": "Casual Dress",
    "isNewWithTags": false,
    "department": "juniors",
    "scrapedAt": "2026-05-22T01:27:52.691Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- 🎯 **Direct API access** - Hits ThredUp's internal GraphQL API for fast, complete data
- ⚡ **Fast extraction** - Fetches 40 items per request with parallel-ready design
- 🔁 **Live inventory** - Always reflects current ThredUp listings in real time
- 📦 **Structured output** - Clean, typed fields ready for analysis or import
- 🛡️ **Cloudflare bypass** - Uses residential proxies and browser-grade TLS fingerprinting
- 🆓 **No login needed** - Works with ThredUp's public search, no account required

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Generic scraper |
|---------|-----------|-----------------|-----------------|
| Items per run | Up to 1,000,000 | ~50 | ~100 |
| Data freshness | Real-time | Real-time | Variable |
| API-level access | Yes | No | No |
| Structured output | Yes | No | Partial |
| Cloudflare bypass | Yes | N/A | Often fails |
| Export formats | JSON/CSV/Excel/XML | None | Limited |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 in free credits
2. Open the ThredUp Scraper actor page
3. Enter your search query (e.g. "dresses", "Nike shoes", "vintage Levi")
4. Optionally select a department filter
5. Set `maxItems` to limit results (free users: up to 10)
6. Click **Start** and wait for the run to complete
7. Download your data as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### Resale and Arbitrage

ThredUp often lists designer items significantly below market value. Export listings for brands like Lululemon, Free People, or Michael Kors and cross-reference with eBay or Poshmark prices to identify profitable flip opportunities.

#### Market Research and Trend Analysis

Track which categories, brands, and sizes have the most inventory on ThredUp. Combine with pricing data to understand the secondhand market by segment. Useful for fashion brands evaluating their resale footprint.

#### Sustainability Reporting

Organizations measuring circular economy impact can extract category and volume data to show how much clothing is re-circulating through platforms like ThredUp rather than going to landfill.

#### Price Intelligence

Retailers and brands can monitor ThredUp to understand at what price their products resell in the secondhand market. This informs original pricing strategy and brand perception in the circular economy.

### 🔌 Automating ThredUp Scraper

Connect the scraper to your favorite tools without writing code:

- **Make (Integromat)** - Trigger the actor on a schedule and push data to Google Sheets, Airtable, or Slack
- **Zapier** - Connect with 5,000+ apps. Send new items to a spreadsheet or email alert
- **Slack** - Get daily digests of new ThredUp listings matching your search
- **Google Sheets** - Export all fields directly into a spreadsheet for analysis
- **Webhook** - POST results to your own API or database as items are collected

### 🌟 Beyond business use cases

#### Academic Research

Fashion and sustainability researchers can analyze ThredUp's secondhand supply to understand fast fashion's environmental impact, consumer behavior in circular economies, and resale value depreciation curves by brand.

#### Personal Shopping Assistant

Build a personal alert system: run the scraper daily on your favorite brands or sizes and get notified when new items appear below a price threshold.

#### Non-Profit Impact Tracking

Organizations focused on clothing access can track availability and pricing of essential clothing categories in the secondhand market to inform donation drives and distribution programs.

#### Creative Projects and Data Art

Visualize secondhand fashion trends: map brand frequency, price distributions, and condition ratings as interactive data visualizations. The structured output feeds directly into D3.js, Tableau, or Python notebooks.

### 🤖 Ask an AI assistant about this scraper

You can ask Claude or ChatGPT questions like:

- "How do I filter ThredUp results by brand using this scraper?"
- "How do I find the best deals by comparing price vs. originalPrice?"
- "How can I schedule this to run daily and alert me to new listings?"

### ❓ Frequently Asked Questions

**❓ Does this require a ThredUp account?**
No. The scraper uses ThredUp's public search API. No login or account needed.

**❓ How many items can I scrape?**
Free users get up to 10 items per run. Paid users can scrape up to 1,000,000 items per run.

**❓ How fresh is the data?**
All data is scraped live from ThredUp's API at the time of the run. Results reflect current inventory.

**❓ Why is the color field null?**
ThredUp does not expose color information in their search API listing results. Color is only available on individual product detail pages, which requires additional requests.

**❓ Can I search for specific brands?**
Yes. Just set `searchQuery` to a brand name like "Lululemon" or "Michael Kors". ThredUp's search covers brand names, item names, and descriptions.

**❓ What does the condition field mean?**
ThredUp uses a quality rating system: Q1 = Like New (may include NWT), Q2 = Gently Used, Q3 = Moderate Use, Q4 = Heavy Use. This scraper maps those codes to readable labels.

**❓ Can I filter by price range?**
The current version scrapes all price ranges. Results are ordered by ThredUp's default relevance ranking. You can filter by price range after export.

**❓ How do I find "New With Tags" items only?**
Export all results and filter by `isNewWithTags: true` in your spreadsheet or code.

**❓ Does the scraper work with pagination?**
Yes. The scraper automatically paginates through all result pages until it reaches your `maxItems` limit or exhausts the results.

**❓ What image size is returned?**
The `imageUrl` field links to the `xlarge` size image hosted on ThredUp's CDN. These are high-resolution product photos.

**❓ Can I scrape men's or kids' clothing?**
Yes. Set the `department` filter to "men" or "kids" to restrict results to those sections.

**❓ Is the scraper affected when ThredUp updates their site?**
The scraper uses ThredUp's GraphQL API which is more stable than HTML scraping. Minor site changes rarely affect it.

### 🔌 Integrate with any app

Connect your ThredUp data to 500+ apps via Apify integrations:

- Google Sheets - Airtable - Notion - Slack
- Make (Integromat) - Zapier - n8n - Monday.com
- BigQuery - Snowflake - PostgreSQL - MongoDB
- Webhooks - REST API - Python - Node.js

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Vinted Scraper](https://apify.com/parseforge/vinted-scraper) | Scrape listings from Vinted secondhand marketplace |
| [Depop Scraper](https://apify.com/parseforge/depop-scraper) | Extract Depop vintage and streetwear listings |
| [Backmarket Scraper](https://apify.com/parseforge/backmarket-scraper) | Scrape refurbished electronics from Backmarket |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering 100+ platforms across ecommerce, jobs, real estate, and more.

***

*Disclaimer: This actor is an independent tool not affiliated with ThredUp. Use in accordance with ThredUp's terms of service. Data is provided for informational purposes only. ParseForge is not responsible for how extracted data is used.*

# Actor input Schema

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

Keyword to search for (e.g. 'dresses', 'Nike sneakers', 'vintage Levi jeans')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `department` (type: `string`):

Filter by department

## Actor input object example

```json
{
  "searchQuery": "dresses",
  "maxItems": 10,
  "department": ""
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "dresses",
    "maxItems": 10
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchQuery": "dresses",
    "maxItems": 10,
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQuery": "dresses",
  "maxItems": 10
}' |
apify call parseforge/thredup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ThredUp Scraper | Secondhand Clothing Listings",
        "description": "Scrape ThredUp secondhand fashion listings with brand, size, condition, original price, sale price, photos, and seller info. Monitor inventory, track resale prices, and analyze the thrift apparel market for retail intelligence, reselling, and competitive research projects.",
        "version": "0.1",
        "x-build-id": "UVa7X6beiJuTOHHBo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~thredup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-thredup-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/parseforge~thredup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-thredup-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/parseforge~thredup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-thredup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for (e.g. 'dresses', 'Nike sneakers', 'vintage Levi jeans')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "department": {
                        "title": "Department",
                        "enum": [
                            "",
                            "women",
                            "kids",
                            "men"
                        ],
                        "type": "string",
                        "description": "Filter by department",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
