# Vinted Scraper — EU Second-Hand Products & Prices (`haketa/vinted-scraper`) Actor

Scrape Vinted, Europe largest second-hand fashion marketplace. Extract products with price, brand, size, condition, seller info and images. Search by keyword across all EU markets. Pure HTTP, no proxy required.

- **URL**: https://apify.com/haketa/vinted-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 60.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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

## Vinted Scraper — EU Second-Hand Fashion Products, Prices & Brands

Scrape **Vinted**, Europe's largest second-hand fashion marketplace with 100M+ items across 26 countries. Extract products with **price, brand, size, condition, seller information, and images**. Search by keyword or paste catalog URLs directly.

**No proxy, no login, no browser required.** Vinted is fully server-rendered — pure HTTP extraction makes this the cheapest Vinted scraper on Apify. Compatible with all 26 Vinted markets including France, Germany, Italy, Spain, Netherlands, Belgium, Poland, and the US.

---

### ⚡ Quick Start

```json
{
    "query": "nike",
    "maxItems": 50
}
````

👉 50 Nike products with price, brand, size, condition, and images. Takes ~10 seconds. No proxy configuration needed.

#### Three Ways to Use

| Mode | Input | Best For |
|------|-------|----------|
| **Keyword Search** | `"query": "nike"` | Discovering products by brand or item type |
| **Start URLs** | Paste Vinted catalog URL | Pre-filtered searches with specific criteria |
| **Direct Item URLs** | Paste Vinted item links | Tracking specific products over time |

***

### Why This Scraper?

#### Cheapest on Apify

With **zero proxy cost** (Vinted serves full HTML from datacenter IPs), we can offer the lowest price per result of any Vinted scraper. No browser rendering, no residential proxy fees, no login requirements — pure HTTP extraction at maximum speed.

#### Rich Product Data

Every listing on Vinted requires sellers to declare **brand, size, and condition** — these come as structured fields. We parse them directly from the server-rendered HTML:

- **`condition`**: New, New with tags, New without tags, Very good, Good, Satisfactory
- **`brand`**: Nike, Zara, Adidas, Levi's, H\&M, Gucci, and thousands more
- **`size`**: XS through XXL, plus EU shoe sizes (36-46) and numeric sizes

#### All 26 Markets

Vinted operates across 26 European countries and the US. The vinted.com domain aggregates listings from all markets. One query searches everything — no need to switch between regional domains.

***

### Data Fields

| Category | Field | Description |
|----------|-------|-------------|
| **Identity** | `productId` | Vinted item ID |
| | `title` | Cleaned product title (brand/condition/size removed) |
| | `url` | Direct link to item page |
| **Price** | `price` | Numeric price in EUR |
| | `priceFormatted` | Formatted display (e.g. "€25.00") |
| | `currency` | Currency code (EUR) |
| **Product** | `brand` | Brand name (Nike, Zara, Adidas...) |
| | `size` | Size (S, M, L, XL, 38, 42...) |
| | `condition` | New, Very good, Good, Satisfactory |
| **Seller** | `sellerName` | Seller username (from detail page) |
| | `sellerRating` | Seller rating score (from detail page) |
| **Media** | `imageUrl` | Primary product image URL |
| | `images` | Full image gallery (JSON array, from detail page) |
| **Content** | `description` | Product description (from detail page) |
| **Meta** | `searchQuery` | Search keyword used |
| | `scrapedAt` | ISO-8601 scrape timestamp |

***

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `query` | string | `nike` | Search keyword. English works well. Examples: nike, zara, levis, adidas, dress, shoes, bag, vintage |
| `startUrls` | array | `[]` | Vinted catalog or product URLs. Overrides query |
| `includeDetails` | boolean | `true` | Visit product pages for full description, all images, and seller info. Slower per product but much richer |
| `maxItems` | integer | 100 | Maximum products to scrape. 0 = no limit |
| `maxPages` | integer | 3 | Search result pages. ~50-100 products per page |
| `requestDelay` | integer | 600 | Delay between detail page requests in ms |
| `maxConcurrency` | integer | 8 | Parallel detail page requests. Keep 6-10 for best results |
| `proxyConfiguration` | proxy | Off | Not needed — Vinted is accessible from datacenter IPs |

***

### Example Output

```json
{
    "productId": "9236277906",
    "title": "Nike zip up lightweight hoodie",
    "url": "https://www.vinted.com/items/9236277906-nike-zip-up-lightweight-hoodie",
    "price": "25.00",
    "priceFormatted": "€25.00",
    "currency": "EUR",
    "brand": "Nike",
    "size": "M",
    "condition": "Very good",
    "imageUrl": "https://images1.vinted.net/t/06_00c10_Y8Kj2hT3x1oP7mN5sQ9r.jpg",
    "images": "[\"https://images1.vinted.net/t/06_00c10_Y8Kj2hT3x1oP7mN5sQ9r.jpg\",\"https://images2.vinted.net/t/06_00c10_bR4wL8vF2nE6kJ1aW3xS.jpg\"]",
    "description": "Nike zip up lightweight hoodie. Worn a few times, still in great condition. No stains or tears.",
    "sellerName": "fashion_finds_paris",
    "sellerRating": "4.8",
    "searchQuery": "nike",
    "scrapedAt": "2026-06-23T14:00:00.000Z"
}
```

***

### Use Cases

#### 1. Reseller Sourcing

Find underpriced branded items across Vinted's 26 markets. Compare prices by brand, size, and condition to identify arbitrage opportunities. Buy low in one market, sell high in another.

#### 2. Brand Market Analysis

Track pricing trends by brand across Europe. Analyze average prices for specific brands, sizes, and conditions. Monitor discount depth and inventory velocity.

#### 3. Fashion Trend Monitoring

Identify which brands and styles are trending by tracking listing volume over time. Spot emerging brands before they hit mainstream retail.

#### 4. Competitive Seller Intelligence

Monitor competitor seller pricing strategies. Track which sellers dominate specific brand or category searches. Analyze seller rating distribution.

#### 5. Sustainability & Circular Economy Research

Quantify the second-hand fashion market. Track how many items are resold vs. new. Measure the environmental impact of fashion reuse.

#### 6. E-Commerce Catalog Enrichment

Feed structured product data (brand, size, condition, images) into your own catalog system, price comparison engine, or market intelligence dashboard.

***

### Performance

| Mode | Speed | Memory | Proxy |
|------|-------|--------|-------|
| Search only (`includeDetails: false`) | ~50-100 products/sec | 256 MB | Not needed |
| Search + details (`includeDetails: true`) | ~10-20 products/sec | 512 MB | Not needed |

**Typical cost**: 100 products in ~10-15 seconds. Zero proxy data transfer cost. Minimal CU consumption.

***

### Tips & Best Practices

- **Search in English** — Vinted's search works well with English brand names. "nike", "adidas", "zara", "levis" all return excellent results
- **Start broad, then narrow** — Run a search for a brand first (`"query": "nike"`), then filter by size or condition in your downstream analysis
- **Use list-only mode for speed** — `includeDetails: false` scans 100 products in ~2 seconds. Enable details only for products you're interested in
- **Combine with arbitrage analysis** — Export data to CSV, compare prices across sizes and conditions to find the best deals
- **Schedule for trend monitoring** — Weekly runs on the same query track price changes and new listings over time

***

### Integration

#### JavaScript / TypeScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('haketa/vinted-scraper').call({
    query: 'nike',
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} Nike products`);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient(token='YOUR_TOKEN')
run = client.actor('haketa/vinted-scraper').call(run_input={
    'query': 'nike',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call haketa/vinted-scraper --input '{"query":"nike","maxItems":100}'
```

***

### FAQ

**Q: Do I need a proxy?**
A: No. Vinted is fully server-rendered and accessible from any IP address. Zero proxy cost — this is why we can offer the lowest prices.

**Q: Which countries are covered?**
A: All 26 Vinted markets (France, Germany, Italy, Spain, Netherlands, Belgium, Poland, Portugal, Austria, Czech Republic, Slovakia, Hungary, Romania, Sweden, Luxembourg, Lithuania, Finland, Greece, Croatia, Slovenia, Ireland, UK, USA, Canada, and more). The vinted.com domain aggregates all markets.

**Q: Why are prices in EUR?**
A: Vinted.com displays all prices in EUR as the default currency. Other regional domains show local currency.

**Q: Is the condition field reliable?**
A: Yes. Vinted requires every seller to declare item condition from a fixed list: New, New with tags, New without tags, Very good, Good, Satisfactory. This is a mandatory field.

**Q: Can I search by size directly?**
A: The search query supports free text. Try queries like "nike size M", "zara dress S", or "adidas 42" for size-specific results. The `size` field is also parsed in the output.

**Q: How many products can I scrape?**
A: Set `maxItems: 0` for unlimited. Vinted paginates deeply — hundreds of pages per search query are available. Use `maxPages` to control depth.

**Q: Are seller names and ratings available?**
A: Include `includeDetails: true` to visit each product page for seller username and rating. In list-only mode, only product data is returned.

***

### Known Limitations

- **Seller data requires details**: `sellerName` and `sellerRating` are only available when `includeDetails: true`
- **Catalog pages are large**: Vinted returns ~8MB per search page. The scraper handles this efficiently with raw regex parsing
- **Currency varies by domain**: vinted.com shows EUR. Regional domains (vinted.fr, vinted.de) show local currency
- **No API**: Vinted does not offer a public API. This scraper extracts data from server-rendered HTML pages

***

### Legal & Responsible Use

This actor extracts publicly available product listings from Vinted. Users are responsible for complying with Vinted's Terms of Service and applicable EU regulations (GDPR, Digital Services Act). Data is intended for legitimate market research, price analysis, and business intelligence.

***

*The cheapest Vinted scraper on Apify — zero proxy cost, pure HTTP, all 26 EU markets, rich product data with brand, size, and condition.*

# Actor input Schema

## `query` (type: `string`):

Product keyword. Examples: nike, zara, levis, dress, shoes, bag

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

Vinted catalog or product URLs.

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

Visit product pages for full description, all images, seller info.

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

Maximum products. 0 = no limit.

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

Search result pages.

## `requestDelay` (type: `integer`):

Delay between requests.

## `maxConcurrency` (type: `integer`):

Parallel detail requests.

## Actor input object example

```json
{
  "query": "nike",
  "startUrls": [],
  "includeDetails": false,
  "maxItems": 15,
  "maxPages": 1,
  "requestDelay": 300,
  "maxConcurrency": 8
}
```

# Actor output Schema

## `productId` (type: `string`):

No description

## `title` (type: `string`):

No description

## `url` (type: `string`):

No description

## `price` (type: `string`):

No description

## `priceFormatted` (type: `string`):

No description

## `currency` (type: `string`):

No description

## `brand` (type: `string`):

No description

## `size` (type: `string`):

No description

## `condition` (type: `string`):

No description

## `sellerName` (type: `string`):

No description

## `sellerRating` (type: `string`):

No description

## `imageUrl` (type: `string`):

No description

## `images` (type: `string`):

No description

## `description` (type: `string`):

No description

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

No description

## `scrapedAt` (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 = {
    "query": "nike",
    "startUrls": [],
    "maxItems": 15,
    "maxPages": 1,
    "requestDelay": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/vinted-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 = {
    "query": "nike",
    "startUrls": [],
    "maxItems": 15,
    "maxPages": 1,
    "requestDelay": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/vinted-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 '{
  "query": "nike",
  "startUrls": [],
  "maxItems": 15,
  "maxPages": 1,
  "requestDelay": 300
}' |
apify call haketa/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper — EU Second-Hand Products & Prices",
        "description": "Scrape Vinted, Europe largest second-hand fashion marketplace. Extract products with price, brand, size, condition, seller info and images. Search by keyword across all EU markets. Pure HTTP, no proxy required.",
        "version": "0.1",
        "x-build-id": "PtvN27wjbFWGe6Vb1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-vinted-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/haketa~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-vinted-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/haketa~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-vinted-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Product keyword. Examples: nike, zara, levis, dress, shoes, bag"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Vinted catalog or product URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeDetails": {
                        "title": "Include product details",
                        "type": "boolean",
                        "description": "Visit product pages for full description, all images, seller info.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum products. 0 = no limit.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Search result pages.",
                        "default": 3
                    },
                    "requestDelay": {
                        "title": "Request delay (ms)",
                        "minimum": 300,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between requests.",
                        "default": 600
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Parallel detail requests.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
