# Vinted Scraper — Listings & Item Details (`khadinakbar/vinted-scraper`) Actor

Scrape public Vinted listings by search or catalog/item URL for resale sourcing, price research, and market analysis. Returns prices, images, size, condition, and seller fields when public. Not for private accounts or buying automation. $0.005 per saved listing plus platform usage.

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

## Pricing

from $5.00 / 1,000 vinted 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.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 — Listings, Prices & Item Details

**Vinted Scraper** extracts public secondhand-marketplace listings from Vinted search pages, catalog URLs, and direct item URLs. It returns a clean dataset with prices, brands, sizes, conditions, public image URLs, and public seller fields when Vinted displays them. Use it for resale sourcing, price benchmarking, stock snapshots, and secondhand-fashion market research. It is designed for structured exports and AI-agent workflows, not browser automation of purchases or private accounts.

### When to use this actor

Use this actor when you need current public Vinted inventory in a reproducible JSON, CSV, Excel, or API dataset. A reseller can search a brand and compare visible item prices before sourcing. A market analyst can run the same query across supported Vinted markets and retain the scrape timestamp with each result. A price-monitoring workflow can pass a public Vinted catalog URL or a specific listing URL into a scheduled task.

Use a different tool when you need private messages, account management, payment, checkout, or data that is not shown publicly on Vinted pages. This actor neither logs in nor asks for cookies. It only processes public pages and never sends offers or interacts with sellers.

### What data can I extract?

Every saved row has a stable, flat shape that works cleanly in spreadsheets and MCP clients. Fields may be `null` only when Vinted does not expose them on the public page at that moment.

| Field | Description |
| --- | --- |
| `itemId`, `itemUrl`, `title` | Public Vinted item identity and canonical page URL |
| `brand`, `size`, `condition`, `color` | Public product attributes |
| `price`, `currency`, `buyerProtectionPrice` | Displayed item price and total including Buyer Protection when shown |
| `imageUrls` | Public item image URLs from the detail page |
| `sellerUsername`, `sellerUrl` | Public seller fields when displayed |
| `uploadedAtText`, `market`, `scrapedAt` | Timing, marketplace, and provenance fields |

The actor also writes `OUTPUT` and `RUN_SUMMARY` to the default key-value store. These records explain whether the run completed, was partial, had a valid empty result, rejected bad input, or could not reach Vinted. They are useful for scheduled automations that need an honest machine-readable status.

### Pricing

This actor uses **Pay per event + usage**. It charges **$0.005 for each validated listing saved to the dataset**, plus a $0.00005 actor-start event. Apify platform usage—such as compute and residential proxy traffic—is passed through separately by Apify.

The `maxItems` input is a hard billing cap for listing events. A default run with `maxItems: 10` can create up to **$0.050** in listing-event charges, plus the actor-start event and platform usage. The actor logs this cap before scraping and will not save or charge more listings than the requested limit.

### How to scrape Vinted by keyword

Choose `search` mode, enter one or more search terms, select a market, and keep the default `maxItems` value for a small proof run. Vinted Scraper opens the public catalog in a consistent browser session with a matching residential proxy country. It then reads public listing cards and, by default, visits each selected item page to enrich attributes and image URLs.

```json
{
  "mode": "search",
  "searchQueries": ["levis 501", "carhartt jacket"],
  "market": "uk",
  "maxItems": 20,
  "maxPages": 2,
  "enrichDetails": true
}
````

Set `enrichDetails` to `false` when you only need faster price and listing-card snapshots. The record still includes public title, brand, size, condition, price, market, and scrape time whenever Vinted provides them.

### How to scrape a catalog or item URL

Choose `urls` mode and pass public Vinted catalog or item URLs in `startUrls`. A catalog URL can preserve a filter combination you already built in Vinted. A direct `/items/…` URL returns one enriched item record. Invalid hosts and non-Vinted URLs finish as `INVALID_INPUT` with a fix suggestion rather than silently failing.

```json
{
  "mode": "urls",
  "startUrls": [
    "https://www.vinted.co.uk/catalog?search_text=levis%20501",
    "https://www.vinted.co.uk/items/9400175531-levis-501-navy-w-34-l-32"
  ],
  "market": "uk",
  "maxItems": 10,
  "enrichDetails": true
}
```

### API examples

JavaScript with the Apify client:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/vinted-scraper').call({
  mode: 'search',
  searchQueries: ['vintage barbour jacket'],
  market: 'uk',
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python with the Apify client:

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('khadinakbar/vinted-scraper').call(run_input={
    'mode': 'search',
    'searchQueries': ['vintage barbour jacket'],
    'market': 'uk',
    'maxItems': 10,
})
items = list(client.dataset(run['defaultDatasetId']).iterate_items())
print(items)
```

### Reliable, transparent outcomes

The actor uses a real browser because Vinted may reject synthetic catalog API calls. It maintains a single browser and residential proxy session per run so catalog and detail pages see consistent context. Search-card data is saved if optional detail enrichment fails, so useful public records are preserved as `PARTIAL` instead of discarded. If Vinted successfully processes a valid query but finds no matches, the actor returns `VALID_EMPTY`. If every requested public route fails before any record is saved, it returns `UPSTREAM_FAILED` rather than pretending an empty dataset is a success.

### Related marketplace tools

For adjacent resale and e-commerce workflows, see the [Depop Scraper](https://apify.com/khadinakbar/depop-scraper), [Amazon Product Scraper](https://apify.com/khadinakbar/amazon-product-scraper), [Wayfair Scraper](https://apify.com/khadinakbar/wayfair-scraper), and [Facebook Marketplace Scraper](https://apify.com/khadinakbar/facebook-marketplace-scraper). These are separate sources with different public data contracts; combine their datasets only after normalizing marketplace and currency fields.

### FAQ

#### Does Vinted Scraper require a Vinted account?

No. It only visits public Vinted catalog and item pages and does not log in, use cookies supplied by you, or access private data.

#### Why are some fields null?

Vinted controls which attributes appear on each public listing. A null field truthfully means it was absent or unavailable in the public page rendered during that run; the actor never invents data to fill it.

#### Can I use it for price monitoring?

Yes. Save a Vinted catalog URL as an Apify task and schedule it. Include `scrapedAt`, `itemId`, `price`, and `market` in your downstream comparison so you can identify new or changed listings without assuming a listing disappeared because of ranking changes.

#### Is scraping Vinted allowed?

You are responsible for ensuring your use complies with Vinted’s terms, applicable law, and data-protection obligations. Use the actor only for legitimate purposes, do not collect private data, and do not overload Vinted.

#### How do I report an issue?

Share the Apify run ID, the public input URL or non-sensitive query, and the affected output field. This lets us reproduce a public-page issue without requesting account credentials.

# Actor input Schema

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

Choose how Vinted targets are supplied. Use 'search' for one or more public Vinted search terms, or 'urls' for public catalog and item pages. Search defaults to a small Levis example; URLs mode requires startUrls. This is not a mode for private accounts, checkout, or seller messaging.

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

Public Vinted catalog terms to search, such as 'levis 501' or 'vintage carhartt jacket'. Each term is run separately and duplicate items are removed across the run. Defaults to 'levis 501' for a small working example. This is not a saved-search, alert, or authenticated inventory query.

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

Public Vinted catalog or item URLs to scrape, for example 'https://www.vinted.co.uk/catalog?search\_text=levis%20501' or a URL containing '/items/123'. Catalog URLs return listings and item URLs return one detailed record. Leave empty in search mode unless you want to combine targets. This does not accept non-Vinted pages, seller inboxes, or checkout URLs.

## `market` (type: `string`):

Select the Vinted market used to construct keyword-search URLs and request a matching residential proxy country. For example, choose 'uk' for Vinted UK or 'fr' for Vinted France. Defaults to 'uk'; direct URLs retain their own Vinted hostname. This is not a shipping destination or currency-conversion setting.

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

Hard cap for validated Vinted records saved and billed across the entire run. For example, set 10 for a low-cost proof run or 100 for wider market research. Defaults to 10 and the actor refuses to charge beyond this cap. This is not a page count or a request-concurrency setting.

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

Maximum public catalog pages to load for each search keyword. For example, use 1 for the fast default run or 3 to inspect a broader result set. Defaults to 1 and stops earlier when maxItems is reached. This does not apply to direct item URLs and does not bypass Vinted restrictions.

## `enrichDetails` (type: `boolean`):

Open each public item page to add photo URLs, buyer-protection price, colour, upload time, and public seller fields when Vinted displays them. For example, enable it for resale due diligence and disable it for faster price snapshots. Defaults to true for a richer record. This does not reveal private seller information or contact details.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "levis 501",
    "carhartt jacket"
  ],
  "startUrls": [
    "https://www.vinted.co.uk/catalog?search_text=levis%20501"
  ],
  "market": "uk",
  "maxItems": 10,
  "maxPages": 1,
  "enrichDetails": true
}
```

# Actor output Schema

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

Validated public Vinted listing and item-detail records.

## `output` (type: `string`):

Compact terminal outcome, counts, and warnings.

## `runSummary` (type: `string`):

Detailed run diagnostics and billing counters.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQueries": [
        "levis 501",
        "carhartt jacket"
    ],
    "startUrls": [
        "https://www.vinted.co.uk/catalog?search_text=levis%20501"
    ],
    "market": "uk",
    "maxItems": 10,
    "maxPages": 1,
    "enrichDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "mode": "search",
    "searchQueries": [
        "levis 501",
        "carhartt jacket",
    ],
    "startUrls": ["https://www.vinted.co.uk/catalog?search_text=levis%20501"],
    "market": "uk",
    "maxItems": 10,
    "maxPages": 1,
    "enrichDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "mode": "search",
  "searchQueries": [
    "levis 501",
    "carhartt jacket"
  ],
  "startUrls": [
    "https://www.vinted.co.uk/catalog?search_text=levis%20501"
  ],
  "market": "uk",
  "maxItems": 10,
  "maxPages": 1,
  "enrichDetails": true
}' |
apify call khadinakbar/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper — Listings & Item Details",
        "description": "Scrape public Vinted listings by search or catalog/item URL for resale sourcing, price research, and market analysis. Returns prices, images, size, condition, and seller fields when public. Not for private accounts or buying automation. $0.005 per saved listing plus platform usage.",
        "version": "1.0",
        "x-build-id": "vdfAD8BYIneysJGi3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "search",
                            "urls"
                        ],
                        "type": "string",
                        "description": "Choose how Vinted targets are supplied. Use 'search' for one or more public Vinted search terms, or 'urls' for public catalog and item pages. Search defaults to a small Levis example; URLs mode requires startUrls. This is not a mode for private accounts, checkout, or seller messaging.",
                        "default": "search"
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Public Vinted catalog terms to search, such as 'levis 501' or 'vintage carhartt jacket'. Each term is run separately and duplicate items are removed across the run. Defaults to 'levis 501' for a small working example. This is not a saved-search, alert, or authenticated inventory query.",
                        "default": [
                            "levis 501"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Catalog or item URLs",
                        "type": "array",
                        "description": "Public Vinted catalog or item URLs to scrape, for example 'https://www.vinted.co.uk/catalog?search_text=levis%20501' or a URL containing '/items/123'. Catalog URLs return listings and item URLs return one detailed record. Leave empty in search mode unless you want to combine targets. This does not accept non-Vinted pages, seller inboxes, or checkout URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "market": {
                        "title": "Vinted market",
                        "enum": [
                            "uk",
                            "fr",
                            "de",
                            "it",
                            "es",
                            "nl",
                            "pl",
                            "pt",
                            "be",
                            "at",
                            "us"
                        ],
                        "type": "string",
                        "description": "Select the Vinted market used to construct keyword-search URLs and request a matching residential proxy country. For example, choose 'uk' for Vinted UK or 'fr' for Vinted France. Defaults to 'uk'; direct URLs retain their own Vinted hostname. This is not a shipping destination or currency-conversion setting.",
                        "default": "uk"
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap for validated Vinted records saved and billed across the entire run. For example, set 10 for a low-cost proof run or 100 for wider market research. Defaults to 10 and the actor refuses to charge beyond this cap. This is not a page count or a request-concurrency setting.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum public catalog pages to load for each search keyword. For example, use 1 for the fast default run or 3 to inspect a broader result set. Defaults to 1 and stops earlier when maxItems is reached. This does not apply to direct item URLs and does not bypass Vinted restrictions.",
                        "default": 1
                    },
                    "enrichDetails": {
                        "title": "Enrich item details",
                        "type": "boolean",
                        "description": "Open each public item page to add photo URLs, buyer-protection price, colour, upload time, and public seller fields when Vinted displays them. For example, enable it for resale due diligence and disable it for faster price snapshots. Defaults to true for a richer record. This does not reveal private seller information or contact details.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```