# Vinted Scraper | Secondhand Fashion Listings (`parseforge/vinted-scraper`) Actor

Scrape Vinted listings for clothing, shoes, bags, and accessories with title, brand, size, condition, price, seller, photos, favorites, and stats. Monitor secondhand fashion prices across countries for resale arbitrage, market research, and competitive intelligence projects.

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

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

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

## 👗 Vinted Scraper

> 🚀 **Export Vinted secondhand fashion listings in seconds.** Search by keyword and collect structured data on thousands of pre-loved clothing items - titles, brands, sizes, prices, conditions, and more.

> 🕒 **Last updated:** 2026-05-21 - **📊 10 fields** per record - **Thousands of listings per search** - **Global Vinted marketplace**

The Vinted Scraper lets you extract secondhand clothing and fashion listings from [Vinted](https://www.vinted.com) at scale. Whether you are tracking resale prices, researching fashion trends, building a marketplace tool, or sourcing vintage clothing, this actor gives you clean structured data from Vinted's catalog - no account required.

Vinted is one of Europe's largest secondhand fashion platforms, with millions of listings across clothing, shoes, accessories, and more. This scraper connects to Vinted's live catalog and returns real-time results for any search query you specify.

**Coverage:** Vinted.com (US marketplace). Supports keyword search across all categories. Returns up to 1,000,000 items per run (paid users). Each item includes image, title, brand, size, condition, price, seller username, category, color, and view/favorite counts.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Resellers & thrifters | Track pricing trends for specific brands or items |
| Fashion researchers | Analyze secondhand market supply and demand |
| Price comparison tools | Build databases of pre-loved fashion items |
| E-commerce entrepreneurs | Source inventory leads from Vinted listings |
| Data scientists | Train pricing or condition classification models |
| Vintage clothing buyers | Monitor new listings for specific search terms |

### 📋 What the Vinted Scraper does

- Searches Vinted's live catalog by keyword (e.g. "vintage Levi's", "Nike Air Max", "90s windbreaker")
- Collects listing title, brand, size, condition, price, currency, and seller username
- Extracts category and color from each item detail page
- Returns view count and favorite count per listing
- Paginates automatically to collect up to 1,000,000 results
- Supports price range filtering, brand ID filtering, size ID filtering, and sort order
- Respects free/paid user tiers - free users get 10 items as a preview

> 💡 **Why it matters:** Vinted listings are not indexed in bulk anywhere else. This scraper gives you real-time access to Vinted's full secondhand catalog for research, resale intelligence, or building fashion data pipelines.

### 🎬 Full Demo

_🚧 Coming soon_

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `searchText` | String | Yes | Keyword to search (e.g. "vintage jacket", "Nike sneakers") |
| `maxItems` | Integer | No | Max listings to collect. Free: 10. Paid: up to 1,000,000. |
| `priceFrom` | Number | No | Minimum price filter |
| `priceTo` | Number | No | Maximum price filter |
| `order` | Select | No | Sort order: newest_first, price_low_to_high, price_high_to_low, relevance |
| `brandIds` | String | No | Comma-separated Vinted brand IDs (find via URL params on Vinted) |
| `sizeIds` | String | No | Comma-separated Vinted size IDs |

**Example - Basic search:**
```json
{
    "searchText": "vintage jacket",
    "maxItems": 100
}
````

**Example - Filtered search:**

```json
{
    "searchText": "Levi's jeans",
    "maxItems": 500,
    "priceFrom": 5,
    "priceTo": 50,
    "order": "price_low_to_high"
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 items per run as a preview. Upgrade to a paid Apify plan to unlock up to 1,000,000 items. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)

### 📊 Output

Each record contains the following fields:

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | String | Main product image URL |
| 📝 `title` | String | Listing title |
| 🔗 `url` | String | Direct link to the Vinted listing |
| 🔢 `id` | Integer | Vinted listing ID |
| 🏷️ `brand` | String | Item brand |
| 📏 `size` | String | Size label |
| ✅ `condition` | String | Item condition (e.g. "Very good", "New without tags") |
| 💰 `price` | Number | Listing price |
| 💱 `currency` | String | Currency code (e.g. USD, EUR) |
| 👤 `seller` | String | Seller username |
| 🗂️ `category` | String | Item category (e.g. "Women Denim jackets") |
| 🎨 `color` | String | Item color |
| 👁️ `views` | Integer | Number of views |
| ❤️ `favorites` | Integer | Number of users who favorited the item |
| 🕒 `scrapedAt` | String | ISO timestamp of scrape |
| ❌ `error` | String | Error message (only present if scraping failed) |

**Sample records:**

```json
[
  {
    "imageUrl": "https://images1.vinted.net/t/01_012d2_W6iHqTRWA4m7efjEm8ubtz15/f800/1779412282.jpeg?s=e15cf03d3f46a35d1f686042ae9c6cc264a32f46",
    "title": "Vintage NorthStyle Long Denim Jacket Acid Wash Oversized Jean Coat L",
    "url": "https://www.vinted.com/items/8976876491-vintage-northstyle-long-denim-jacket-acid-wash-oversized-jean-coat-l",
    "id": 8976876491,
    "brand": "north style",
    "size": "L / US 12-14",
    "condition": "New without tags",
    "price": 35,
    "currency": "USD",
    "seller": "brisaa",
    "category": "Women Denim jackets",
    "color": "Blue",
    "views": 0,
    "favorites": 0,
    "scrapedAt": "2026-05-22T01:15:54.898Z"
  },
  {
    "imageUrl": "https://images1.vinted.net/t/05_0184f_vwfP9AnNjJuN6Eo7nbdNvY1K/f800/1779412206.jpeg?s=3fc565b7808f3567ae7fd522f0ea98afc8e78f3f",
    "title": "Vintage 90s Y2K Plaid windbreaker Page & Tuttle size Large",
    "url": "https://www.vinted.com/items/8976875823-vintage-90s-y2k-plaid-windbreaker-page-tuttle-size-large",
    "id": 8976875823,
    "brand": "American Vintage",
    "size": "L",
    "condition": "Very good",
    "price": 14,
    "currency": "USD",
    "seller": "sneakersaf",
    "category": "Men Windbreakers",
    "color": "Gray",
    "views": 0,
    "favorites": 0,
    "scrapedAt": "2026-05-22T01:15:58.098Z"
  },
  {
    "imageUrl": "https://images1.vinted.net/t/05_01746_RpJTanWpTkRrW3BsoMxArtsC/f800/1779412386.jpeg?s=7a8cf05354c6117bd3601501f8f87fe100e192ef",
    "title": "Vintage Men's suite jacket",
    "url": "https://www.vinted.com/items/8976877397-vintage-mens-suite-jacket",
    "id": 8976877397,
    "brand": "Bert pulitzer",
    "size": "50L",
    "condition": "Very good",
    "price": 20,
    "currency": "USD",
    "seller": "jlc7472",
    "category": "Men Suit jackets & blazers",
    "color": "Gray",
    "views": 0,
    "favorites": 0,
    "scrapedAt": "2026-05-22T01:15:46.812Z"
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🛡️ Residential proxy support | Bypasses Vinted's DataDome bot protection reliably |
| 🌐 Real-time data | Live catalog data, not cached or stale |
| 🎨 Color + category extraction | Richer data via detail page scraping |
| 📊 Scalable pagination | Collects thousands of listings per run |
| 🔍 Flexible search | Keyword, price range, brand, size, and sort filters |
| 🆓 Free preview | 10 items free - no payment required to try |
| ⚡ Fast cloud runs | Runs on Apify's infrastructure, no local setup |
| 💾 Multiple export formats | Download as JSON, CSV, Excel, XML |

### 📈 How it compares to alternatives

| Feature | Vinted Scraper (ParseForge) | Manual browsing | Other scrapers |
|---|---|---|---|
| Bulk export | Up to 1,000,000 items | Not possible | Varies |
| Structured output | JSON, CSV, Excel, XML | Copy-paste only | Varies |
| Bot protection bypass | Residential proxy + camoufox | N/A | Often fails |
| Category + color | Yes (detail page) | Yes (manual) | Rarely |
| Pagination | Automatic | Manual | Sometimes |
| No login required | Yes | Yes | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Open the [Vinted Scraper](https://apify.com/parseforge/vinted-scraper) on Apify Store
3. Enter your `searchText` (e.g. "vintage Levi's", "Nike Air Force 1")
4. Set `maxItems` (10 for free preview, up to 1,000,000 for paid)
5. Click **Start** and download results as JSON, CSV, or Excel when done

### 💼 Business use cases

#### Resale Price Intelligence

Track going prices for specific brands, sizes, or conditions on Vinted. Build a pricing database to inform your own listing prices or identify underpriced inventory to flip.

#### Fashion Trend Research

Analyze which brands, categories, and styles are most listed on Vinted. Understand supply trends in secondhand fashion by monitoring listing volumes over time.

#### Inventory Sourcing

Automatically monitor new Vinted listings matching your criteria. Export daily snapshots to find items to purchase for resale or personal collection.

#### Marketplace Analytics

Build a data pipeline combining Vinted data with other resale platforms (Depop, ThredUp) to compare pricing and availability across the secondhand fashion market.

### 🔌 Automating Vinted Scraper

Connect the Vinted Scraper to your favorite tools using Apify integrations:

- **Make (Integromat):** Trigger a Vinted scrape and send results to Google Sheets or Airtable
- **Zapier:** Auto-export new listings to Slack, Notion, or email
- **Webhooks:** Push dataset items to your own API when a run completes
- **Apify API:** Schedule daily runs and fetch results programmatically
- **Google Sheets integration:** Sync Vinted data directly to a spreadsheet

### 🌟 Beyond business use cases

#### Academic Research

Study secondhand fashion consumption patterns, pricing behavior, and circular economy dynamics using real marketplace data.

#### Personal Wardrobing

Build a wishlist monitor - run the scraper on specific search terms weekly to catch new listings matching your style preferences.

#### Non-profit / Sustainability

Analyze the volume of pre-loved clothing available to quantify the secondhand fashion market's environmental impact.

#### Machine Learning

Train models for condition classification, price prediction, or image-based fashion recognition using Vinted's diverse, real-world dataset.

### 🤖 Ask an AI assistant about this scraper

Want to know what you can do with this data? Ask an AI assistant:

- "How can I use Vinted scraper data to build a price tracker?"
- "What fields does the Vinted Scraper return and how do I filter by brand?"
- "How do I schedule the Vinted Scraper to run daily and export to Google Sheets?"

### ❓ Frequently Asked Questions

**❓ Does this scraper require a Vinted account?**
No. The Vinted Scraper only collects publicly visible listings - no login or account is needed.

**❓ How many listings can I collect per run?**
Free users can collect up to 10 items as a preview. Paid Apify users can collect up to 1,000,000 items per run.

**❓ How do I search for a specific brand?**
Use the `searchText` field (e.g. "Levi's denim jacket"). For brand ID filtering, find the brand\_id from Vinted's URL parameters when browsing by brand.

**❓ Can I filter by price?**
Yes. Use `priceFrom` and `priceTo` to set minimum and maximum price filters.

**❓ What sort orders are available?**
You can sort by newest first, price low to high, price high to low, or relevance.

**❓ Why are some items missing color or category?**
Category and color are extracted from each item's detail page. If the seller didn't fill in these fields, they will be null.

**❓ How fresh is the data?**
All data is collected in real-time from Vinted's live catalog when you run the actor. There is no caching.

**❓ Can I export to Excel or CSV?**
Yes. Apify automatically makes your dataset available in JSON, CSV, Excel, and XML formats.

**❓ Does this work for Vinted.fr, Vinted.de, and other regional sites?**
This actor scrapes the Vinted.com (US) marketplace. Regional marketplaces may return different inventory.

**❓ What if Vinted changes their website?**
The ParseForge team monitors actors regularly. If Vinted changes their structure, we update the scraper. [Contact us](https://tally.so/r/BzdKgA) if you notice issues.

**❓ Is there a rate limit?**
The actor uses residential proxies and human-like browsing to stay within acceptable usage. For very large runs, Apify's infrastructure handles concurrency automatically.

**❓ How do I integrate this with my own app?**
Use the [Apify API](https://docs.apify.com/api/v2) to trigger runs and fetch results programmatically. Webhooks let you receive data as soon as a run completes.

### 🔌 Integrate with any app

Download your Vinted dataset in multiple formats:

- **JSON** - for developers and APIs
- **CSV** - for spreadsheets and databases
- **Excel** - for business analysts
- **XML** - for legacy system integrations

Connect via:

- Apify API (REST)
- Make (Integromat)
- Zapier
- n8n
- Webhooks
- Google Sheets (native integration)
- Slack notifications
- Airtable sync

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Depop Scraper](https://apify.com/parseforge/depop-scraper) | Scrape secondhand fashion listings from Depop |
| [Discogs Scraper](https://apify.com/parseforge/discogs-scraper) | Scrape vinyl records and music marketplace listings |
| [ThredUp Scraper](https://apify.com/parseforge/thredup-scraper) | Export secondhand clothing from ThredUp |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering fashion, music, vehicles, jobs, real estate, and more.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or associated with Vinted. Only publicly available data is collected. Use responsibly and in accordance with Vinted's terms of service.

# Actor input Schema

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

Keyword to search for (e.g. 'vintage jacket', 'Nike sneakers')

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

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

## `priceFrom` (type: `number`):

Minimum price filter (in the site's local currency)

## `priceTo` (type: `number`):

Maximum price filter (in the site's local currency)

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

Sort order for results

## `brandIds` (type: `string`):

Comma-separated Vinted brand IDs to filter by (e.g. '53,14'). Find IDs via Vinted's brand filter URL params.

## `sizeIds` (type: `string`):

Comma-separated Vinted size IDs to filter by (e.g. '1,2,3'). Find IDs via Vinted's size filter URL params.

## Actor input object example

```json
{
  "searchText": "vintage jacket",
  "maxItems": 10,
  "order": "newest_first"
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchText": "vintage jacket",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "searchText": "vintage jacket",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "searchText": "vintage jacket",
  "maxItems": 10
}' |
apify call parseforge/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper | Secondhand Fashion Listings",
        "description": "Scrape Vinted listings for clothing, shoes, bags, and accessories with title, brand, size, condition, price, seller, photos, favorites, and stats. Monitor secondhand fashion prices across countries for resale arbitrage, market research, and competitive intelligence projects.",
        "version": "0.1",
        "x-build-id": "XvqvwYPXO07JjCdEA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "required": [
                    "searchText"
                ],
                "properties": {
                    "searchText": {
                        "title": "Search Text",
                        "type": "string",
                        "description": "Keyword to search for (e.g. 'vintage jacket', 'Nike sneakers')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "priceFrom": {
                        "title": "Min Price",
                        "type": "number",
                        "description": "Minimum price filter (in the site's local currency)"
                    },
                    "priceTo": {
                        "title": "Max Price",
                        "type": "number",
                        "description": "Maximum price filter (in the site's local currency)"
                    },
                    "order": {
                        "title": "Sort Order",
                        "enum": [
                            "newest_first",
                            "price_low_to_high",
                            "price_high_to_low",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for results",
                        "default": "newest_first"
                    },
                    "brandIds": {
                        "title": "Brand IDs",
                        "type": "string",
                        "description": "Comma-separated Vinted brand IDs to filter by (e.g. '53,14'). Find IDs via Vinted's brand filter URL params."
                    },
                    "sizeIds": {
                        "title": "Size IDs",
                        "type": "string",
                        "description": "Comma-separated Vinted size IDs to filter by (e.g. '1,2,3'). Find IDs via Vinted's size filter URL params."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
