# Vinted Search Scraper for Listings & Price Monitoring (`fetch_cat/vinted-search-scraper`) Actor

Scrape public Vinted search listings by keyword, brand, category, price, country domain, and sort order; export prices, photos, URLs, and seller fields.

- **URL**: https://apify.com/fetch\_cat/vinted-search-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 listing saveds

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 Search Scraper

Extract structured Vinted marketplace listings by keyword, price range, category, brand, and country domain. Use it to monitor resale prices, discover inventory opportunities, and export listing data for analysis without manually copying product cards from Vinted.

### What does Vinted Search Scraper do?

Vinted Search Scraper turns public Vinted search results into clean dataset rows. You provide a search phrase such as `nike sneakers`, choose how many listings you need, and optionally add filters like price range, brand IDs, category IDs, sort order, and country marketplace domain.

Each saved row contains listing title, price, currency, brand, size, condition, listing URL, photo URLs, seller details, favorites, views when available, and the search query that produced the row.

### Who is it for?

- 🛍️ **Resale sellers** tracking market prices before sourcing inventory.
- 📈 **Marketplace analysts** comparing price levels across brands and categories.
- 🧾 **Ecommerce teams** collecting product intelligence from second-hand fashion listings.
- 🔔 **Deal monitors** watching new items for arbitrage or trend detection.
- 🧪 **Data teams** building clean Vinted datasets for dashboards, alerts, and research.

### Why use this actor?

- ✅ Structured output instead of manual copy-paste.
- ✅ Supports keyword, price, brand, catalog, country domain, and sort inputs.
- ✅ Saves normalized Vinted listing URLs and image URLs.
- ✅ Includes seller fields when available.
- ✅ Handles empty searches gracefully.
- ✅ Designed for small checks and larger marketplace exports.

### Data you can extract

| Field | Description |
| --- | --- |
| `id` | Vinted listing ID |
| `title` | Listing title |
| `priceAmount` | Item price as a number |
| `currency` | Marketplace currency code |
| `brandTitle` | Brand displayed by Vinted |
| `sizeTitle` | Size label when available |
| `status` | Item condition |
| `url` | Absolute listing URL |
| `path` | Vinted listing path |
| `photoUrls` | Listing image URLs |
| `sellerId` | Seller ID when seller output is enabled |
| `sellerLogin` | Seller username |
| `sellerProfileUrl` | Seller profile URL |
| `favoriteCount` | Favorite count when exposed |
| `viewCount` | View count when exposed |
| `scrapedAt` | ISO timestamp of the scrape |
| `searchText` | Search phrase used for the run |

### How much does it cost to scrape Vinted listings?

The actor uses pay-per-event pricing. There is a small start event and a per-listing event for each Vinted listing saved to the dataset. Keep `maxItems` low for testing, then increase it once your filters return the listings you need.

Final tiered pricing is set on the Apify platform after cloud cost validation. The input prefill uses a small run so your first test stays inexpensive.

### Quick start

1. Open the actor on Apify.
2. Enter a search phrase, for example `nike sneakers`.
3. Set `maxItems` to the number of listings you want.
4. Choose a Vinted domain such as `www.vinted.com`, `www.vinted.fr`, or `www.vinted.de`.
5. Add optional price, brand, category, or sort filters.
6. Start the run.
7. Download results as JSON, CSV, Excel, XML, or through the Apify API.

### Input overview

```json
{
  "searchText": "nike sneakers",
  "maxItems": 30,
  "domain": "www.vinted.com",
  "priceMin": 5,
  "priceMax": 80,
  "order": "relevance",
  "includeSeller": true
}
````

### Required input

`searchText` is required. Use the same phrase you would type into Vinted search, such as a brand, item type, model, color, or style.

### Optional filters

- 🔢 `maxItems` controls the maximum number of listings saved.
- 🌍 `domain` selects the Vinted marketplace domain.
- 💰 `priceMin` and `priceMax` limit by item price.
- 🏷️ `brandIds` filters by Vinted brand IDs.
- 🧭 `catalogIds` filters by Vinted catalog/category IDs.
- ↕️ `order` sorts by relevance, newest first, low price, or high price.
- 👤 `includeSeller` includes seller ID, login, and profile URL.

### Output example

```json
{
  "id": 9207913777,
  "title": "Nike sneakers",
  "priceAmount": 13,
  "currency": "USD",
  "brandTitle": "Nike",
  "sizeTitle": "11",
  "status": "Very good",
  "url": "https://www.vinted.com/items/9207913777-nike-sneakers",
  "photoUrls": ["https://images1.vinted.net/example.jpeg"],
  "sellerLogin": "sellername",
  "favoriteCount": 3,
  "viewCount": 0,
  "scrapedAt": "2026-06-19T06:33:36.329Z",
  "searchText": "nike sneakers"
}
```

### Tips for better results

- Start with `maxItems` around 30 to confirm your filters.
- Use specific queries such as `carhartt jacket` instead of only `jacket`.
- Add price filters when you need comparable listings.
- Use country domains to match the market you care about.
- If a query returns no rows, test it in Vinted manually and broaden the phrase.

### Country and marketplace domains

The `domain` field lets you choose a public Vinted marketplace domain. Examples include:

- `www.vinted.com`
- `www.vinted.fr`
- `www.vinted.de`
- `www.vinted.co.uk`
- `www.vinted.it`
- `www.vinted.es`

Use the marketplace where your target buyers or sellers are active.

### Brand and category IDs

Vinted brand and catalog filters use numeric IDs. If you already know the IDs from Vinted URLs or internal workflows, pass them in `brandIds` or `catalogIds`. If you do not know the IDs, start with keyword and price filters first.

### Integrations

Connect the actor to your workflow with:

- 📊 Google Sheets or Excel exports for price monitoring.
- 🧱 Apify datasets for scheduled marketplace snapshots.
- 🔔 Webhooks that notify your system when a run finishes.
- 🧮 BI tools that ingest dataset API URLs.
- 🛒 Inventory research pipelines for resale sourcing decisions.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/vinted-search-scraper').call({
  searchText: 'nike sneakers',
  maxItems: 30,
  domain: 'www.vinted.com'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("fetch_cat/vinted-search-scraper").call(run_input={
    "searchText": "nike sneakers",
    "maxItems": 30,
    "domain": "www.vinted.com",
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~vinted-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchText":"nike sneakers","maxItems":30,"domain":"www.vinted.com"}'
```

### MCP usage

Use this actor from Apify MCP tools in Claude Code or Claude Desktop by enabling the hosted Apify MCP server.

Claude Code quick add:

```bash
claude mcp add apify-vinted "https://mcp.apify.com/?tools=fetch_cat/vinted-search-scraper"
```

Claude Desktop or other MCP clients can use this JSON configuration:

```json
{
  "mcpServers": {
    "apify-vinted": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/vinted-search-scraper"
    }
  }
}
```

Example prompts:

- "Run the Vinted Search Scraper for `nike sneakers` and summarize average prices."
- "Find 50 Vinted listings for vintage leather jackets under 80 EUR."
- "Export Vinted search results for Adidas hoodies and identify the lowest priced items."

### Scheduling

You can schedule recurring runs in Apify to track listings over time. Use a small `maxItems` for frequent checks and a larger `maxItems` for daily or weekly market snapshots.

### Troubleshooting

#### Why did my run return zero items?

The search phrase or filters may be too narrow, or the selected Vinted domain may not have matching public listings. Broaden the keyword, remove price filters, or try another country domain.

#### Why are some fields null?

Vinted does not expose every field for every listing. Size, condition, favorites, views, or seller fields may be missing on some rows.

#### Why should I keep the first run small?

Small tests help confirm your query and marketplace before you pay for a larger export. Increase `maxItems` after you verify that the output matches your needs.

### Legality and responsible use

This actor extracts publicly available marketplace listing information. Use the data responsibly, respect applicable laws, comply with Vinted terms, and avoid collecting personal data beyond what is necessary for your legitimate use case. Do not use exported data for spam, harassment, or decisions that require verified identity or consent.

### FAQ

#### Is this Vinted scraper legal to use?

It is designed for publicly available listing data, but you are responsible for confirming your use case complies with applicable laws, marketplace terms, and privacy obligations.

#### Does it require a Vinted login?

No. The actor uses public marketplace search pages and does not ask for account credentials.

#### Can I monitor a search every day?

Yes. Use Apify schedules with a small `maxItems` value for frequent checks, then increase the limit for deeper periodic exports.

### Related scrapers

You may also find these actors useful:

- https://apify.com/fetch\_cat/poshmark-sold-listings-scraper
- https://apify.com/fetch\_cat/craigslist-classifieds-scraper
- https://apify.com/fetch\_cat/ebay-scraper

### Changelog

#### 0.1

Initial Vinted search listing scraper with keyword search, pagination, price filters, domain selection, seller fields, and structured listing output.

### Support

If a run fails or returns unexpected data, share the run URL and input. Include the Vinted domain, search phrase, and filters so the issue can be reproduced.

### Limits

The actor is designed for public search-result exports. Very broad searches can produce many listings, so use `maxItems` to cap spend and runtime. Availability of fields depends on what Vinted exposes for each listing.

### Data quality notes

Prices are parsed as numbers when Vinted exposes a numeric amount. Photo URLs are returned as an array because listings can have multiple photos. Seller fields are optional and can be disabled with `includeSeller: false`.

### Example workflows

- Weekly price comparison for a resale niche.
- New inventory sourcing research by brand and price cap.
- Country-by-country marketplace snapshots.
- Lightweight competitor pricing research.
- Product trend tracking for second-hand fashion categories.

# Actor input Schema

## `searchText` (type: `string`):

Keyword or phrase to search on Vinted, for example brand, product type, or style.

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

Maximum number of Vinted listings to save.

## `domain` (type: `string`):

Public Vinted marketplace domain to search. Use a country domain such as www.vinted.com, www.vinted.fr, www.vinted.de, or www.vinted.co.uk.

## `priceMin` (type: `number`):

Optional minimum item price in the selected marketplace currency.

## `priceMax` (type: `number`):

Optional maximum item price in the selected marketplace currency.

## `brandIds` (type: `array`):

Optional Vinted brand IDs to filter by.

## `catalogIds` (type: `array`):

Optional Vinted catalog category IDs to filter by.

## `order` (type: `string`):

How Vinted should order the listings.

## `page` (type: `integer`):

Vinted result page to start from.

## `perPage` (type: `integer`):

Number of listings requested per Vinted page. Keep at or below 96.

## `includeSeller` (type: `boolean`):

Include seller ID, login, and profile URL when available.

## Actor input object example

```json
{
  "searchText": "nike sneakers",
  "maxItems": 20,
  "domain": "www.vinted.com",
  "order": "relevance",
  "page": 1,
  "perPage": 96,
  "includeSeller": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchText": "nike sneakers",
    "maxItems": 20,
    "domain": "www.vinted.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/vinted-search-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 = {
    "searchText": "nike sneakers",
    "maxItems": 20,
    "domain": "www.vinted.com",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/vinted-search-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 '{
  "searchText": "nike sneakers",
  "maxItems": 20,
  "domain": "www.vinted.com"
}' |
apify call fetch_cat/vinted-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Search Scraper for Listings & Price Monitoring",
        "description": "Scrape public Vinted search listings by keyword, brand, category, price, country domain, and sort order; export prices, photos, URLs, and seller fields.",
        "version": "0.1",
        "x-build-id": "rTs4qY202wAwse3XU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~vinted-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-vinted-search-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/fetch_cat~vinted-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-vinted-search-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/fetch_cat~vinted-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-vinted-search-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",
                "required": [
                    "searchText"
                ],
                "properties": {
                    "searchText": {
                        "title": "Search text",
                        "type": "string",
                        "description": "Keyword or phrase to search on Vinted, for example brand, product type, or style."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Vinted listings to save.",
                        "default": 50
                    },
                    "domain": {
                        "title": "Vinted domain",
                        "type": "string",
                        "description": "Public Vinted marketplace domain to search. Use a country domain such as www.vinted.com, www.vinted.fr, www.vinted.de, or www.vinted.co.uk.",
                        "default": "www.vinted.com"
                    },
                    "priceMin": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional minimum item price in the selected marketplace currency."
                    },
                    "priceMax": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional maximum item price in the selected marketplace currency."
                    },
                    "brandIds": {
                        "title": "Brand IDs",
                        "type": "array",
                        "description": "Optional Vinted brand IDs to filter by.",
                        "items": {
                            "type": "integer"
                        }
                    },
                    "catalogIds": {
                        "title": "Catalog/category IDs",
                        "type": "array",
                        "description": "Optional Vinted catalog category IDs to filter by.",
                        "items": {
                            "type": "integer"
                        }
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest_first",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "How Vinted should order the listings.",
                        "default": "relevance"
                    },
                    "page": {
                        "title": "Start page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Vinted result page to start from.",
                        "default": 1
                    },
                    "perPage": {
                        "title": "Listings per request",
                        "minimum": 1,
                        "maximum": 96,
                        "type": "integer",
                        "description": "Number of listings requested per Vinted page. Keep at or below 96.",
                        "default": 96
                    },
                    "includeSeller": {
                        "title": "Include seller fields",
                        "type": "boolean",
                        "description": "Include seller ID, login, and profile URL when available.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```