# Vinted Scraper (`sourabhbgp/vinted-scraper`) Actor

Scrape Vinted across all 26 EU and US markets in one actor. Four modes: keyword search with filters, full seller closets, item detail, and brand name to ID lookup. Every row carries net seller price after fees, favourites, views, and sold or reserved status. $1 per 1,000 results.

- **URL**: https://apify.com/sourabhbgp/vinted-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.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.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Vinted Scraper 🇬🇧🇫🇷🇩🇪🇮🇹🇪🇸🇳🇱🇵🇱🇺🇸 | Search, Seller Closets, Item Detail, Brand Catalog

Scrape Vinted across all 26 markets: keyword search with auto-resolved brand IDs, full seller closets, item detail with sold-state flags, and a brand-name lookup table. Works on 🇬🇧 United Kingdom, 🇫🇷 France, 🇩🇪 Germany, 🇮🇹 Italy, 🇪🇸 Spain, 🇳🇱 Netherlands, 🇵🇱 Poland, 🇺🇸 United States, and 18 more EU markets.

One actor, four modes, pay-per-result at **$1 per 1,000 records**. Paste a keyword, a member URL, or an item URL and run, no login, no proxy setup.

### What makes this the best Vinted scraper

- 💰 **$1 per 1,000 results, no per-run fee.** Pay only for what you keep. The Free plan covers your first 5,000 rows.
- 🌍 **All 26 Vinted markets in one actor.** 🇬🇧 🇫🇷 🇩🇪 🇮🇹 🇪🇸 🇳🇱 🇵🇱 🇵🇹 🇧🇪 🇦🇹 🇱🇹 🇨🇿 🇸🇰 🇭🇺 🇷🇴 🇭🇷 🇫🇮 🇩🇰 🇸🇪 🇪🇪 🇬🇷 🇮🇪 🇱🇺 🇱🇻 🇸🇮 🇺🇸 — pick a country code, change nothing else, every mode works the same.
- 🏷️ **Brand name auto-resolves to brand ID.** Type `"yeezy"` as your brand filter; the actor looks up the canonical brand and applies it. No copy-pasting `brand_ids[]=` numbers out of Vinted URLs.
- 💵 **Net seller price on every row.** Every listing carries `netSellerPrice` after Vinted's buyer-protection fee, so repricing logic models true take-home, not gross listing.
- ❤️ **Popularity signals on every row.** `favouriteCount` and `viewCount` ship on every listing — the only Vinted actor that surfaces them, so demand-velocity research doesn't need a second scrape.
- 🚦 **Sold / reserved / hidden flags.** `isClosed`, `isReserved`, `isHidden` populated wherever Vinted exposes them, so you can detect when an item leaves active inventory.
- 🏅 **Seller-quality signals.** `sellerBadges` (`ACTIVE_LISTER`, `SPEEDY_SHIPPING`), `sellerFeedbackCount`, `sellerFeedbackReputation`, plus `isBusinessSeller` for Pro accounts.
- ⚡ **HTTP-only with concurrent pagination.** No browser, no Playwright. Pages fan out in parallel so 200-row searches finish in under a minute.
- 📦 **One record shape for every mode.** All four modes share a discriminated `recordType` field, so a single output pipeline can consume the lot.
- 🛡️ **Honest about Vinted's limits.** Sold listings aren't exposed by Vinted at all. This actor tells you so up front instead of pretending.

### What data can you extract?

<table>
<tr>
<td>🏷️ <b>Title & brand</b></td>
<td>💷 <b>Price</b></td>
<td>💵 <b>Net seller price</b></td>
<td>🔢 <b>Brand ID</b></td>
</tr>
<tr>
<td>📏 <b>Size</b></td>
<td>✨ <b>Condition</b></td>
<td>🎨 <b>Color</b></td>
<td>📝 <b>Description</b></td>
</tr>
<tr>
<td>📸 <b>Photos</b></td>
<td>❤️ <b>Favourite count</b></td>
<td>👁️ <b>View count</b></td>
<td>🚀 <b>Promoted flag</b></td>
</tr>
<tr>
<td>👤 <b>Seller login + URL</b></td>
<td>🆔 <b>Seller ID</b></td>
<td>⭐ <b>Feedback count + score</b></td>
<td>🏅 <b>Seller badges</b></td>
</tr>
<tr>
<td>💼 <b>Business-seller flag</b></td>
<td>🚦 <b>Sold / reserved / hidden</b></td>
<td>📦 <b>Heavy-bulky flag</b></td>
<td>🕒 <b>Uploaded (relative)</b></td>
</tr>
<tr>
<td>🌍 <b>Market</b></td>
<td>💱 <b>Currency</b></td>
<td>🔗 <b>Item URL</b></td>
<td>📅 <b>Scraped timestamp</b></td>
</tr>
</table>

### Scraping modes

#### 🔍 Search by keyword

Search any Vinted market by keyword with optional filters (brand name, sub-category, condition, price range, sort).

```json
{
  "mode": "search",
  "country": "uk",
  "searchText": "nike air max",
  "brand": "nike",
  "condition": ["very_good", "new_with_tags"],
  "priceFrom": 20,
  "priceTo": 80,
  "sortBy": "newest_first",
  "maxResults": 200
}
````

#### 👤 User listings (seller closet)

Pull every active item from a seller's closet by their member URL.

```json
{
  "mode": "user-listings",
  "country": "uk",
  "userUrl": "https://www.vinted.co.uk/member/3151368835-jacie7",
  "maxResults": 500
}
```

#### 📦 Item detail

Paste one or more item URLs to get the full record: title, brand, size, condition, color, description, photos, seller info, `isClosed` and `isReserved` flags, plus the buyer-protection-fee math.

```json
{
  "mode": "item-detail",
  "country": "uk",
  "itemUrls": [
    "https://www.vinted.co.uk/items/9026871059-nike-air-max-moto-2k-black-fire-pink"
  ]
}
```

#### 🏷️ Brand catalog (name → ID)

Look up a brand name and get the top 10 matches with ID, slug, item count, and a flag for whether Vinted runs authenticity checks on it. Useful before locking a brand filter into a daily search.

```json
{
  "mode": "brand-catalog",
  "country": "uk",
  "brandKeyword": "yeezy"
}
```

### How to scrape Vinted: step by step

1. [Create a free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [Vinted Scraper](https://console.apify.com/actors/tuQH3svQCJNYgfBZc?addFromActorId=tuQH3svQCJNYgfBZc) in the Apify Console.
3. Pick a mode, fill the country and the matching field (search text, member URL, item URLs, or brand keyword).
4. Click **Start**. A 100-row search typically finishes in 15-30 seconds; 200+ rows use concurrent pagination and finish in under a minute.
5. Export the dataset as JSON, CSV, or Excel, or pull results via the API.

### How much does Vinted Scraper cost?

**$1.00 per 1,000 results.** No per-run fee, no monthly minimum.

The Free plan's $5 monthly credit covers about **5,000 rows**. The $29/month Starter plan covers about **29,000 rows**. Compute usage on top is typically a few cents per thousand for an HTTP-only actor like this one.

You pay only for rows written to the dataset, so filters that narrow a search don't waste budget.

### Input

```json
{
  "mode": "search",
  "country": "uk",
  "searchText": "nike air max",
  "brand": "nike",
  "category": 1242,
  "size": "10",
  "condition": ["very_good", "new_with_tags"],
  "color": "Black",
  "priceFrom": 20,
  "priceTo": 100,
  "sortBy": "newest_first",
  "maxResults": 200
}
```

| Field | Type | Default | Note |
|---|---|---|---|
| `mode` | enum | `search` | `search`, `user-listings`, `item-detail`, `brand-catalog` |
| `country` | enum | `uk` | 26 markets, e.g. `uk`, `fr`, `de`, `it`, `es`, `nl`, `pl`, `us` |
| `searchText` | string | none | Keyword query (search mode) |
| `brand` | string | none | Brand name; auto-resolved to ID (search mode) |
| `category` | integer | none | Vinted catalog ID; copy from the `catalog[]=` value in a Vinted URL |
| `size` | string | none | Size label (search mode) |
| `condition` | array | none | One or more of `new_with_tags`, `new_without_tags`, `very_good`, `good`, `satisfactory` |
| `color` | string | none | Color label (search mode) |
| `priceFrom` / `priceTo` | number | none | Price range in the country's local currency |
| `sortBy` | enum | `relevance` | `relevance`, `price_low_to_high`, `price_high_to_low`, `newest_first` |
| `userUrl` | URL | none | Member URL (user-listings mode) |
| `itemUrls` | URL\[] | none | Item URLs (item-detail mode) |
| `brandKeyword` | string | none | Fuzzy brand query (brand-catalog mode) |
| `maxResults` | integer | `100` | Cap on dataset rows. `0` means up to Vinted's 960-per-query ceiling. |
| `maxConcurrency` | integer | `6` | Parallel requests. Higher is faster, lower is gentler on proxies. 1-10. |

### Output

Every row carries a `recordType` discriminator so a single pipeline can fan-out by mode.

**Listing row** (search and user-listings modes):

```json
{
  "recordType": "listing",
  "id": 9025648983,
  "title": "Nike Air Max Plus Terrascape Black UK 5.5 Pre Owned",
  "url": "https://www.vinted.co.uk/items/9025648983-nike-air-max-plus-terrascape-black-uk-55-pre-owned",
  "price": 25,
  "currency": "GBP",
  "serviceFee": 1.95,
  "totalBuyerPrice": 26.95,
  "netSellerPrice": 23.05,
  "brand": "Nike",
  "brandId": 53,
  "size": "5.5",
  "condition": "Very good",
  "color": null,
  "country": "uk",
  "photos": [
    "https://images1.vinted.net/t/01_005b3_7QR4TyiFfSyAtNSUo9GtcuyM/f800/1779968758.jpeg"
  ],
  "sellerId": 130039032,
  "sellerLogin": "graceolivia1311",
  "sellerProfileUrl": "https://www.vinted.co.uk/member/130039032-graceolivia1311",
  "isBusinessSeller": false,
  "favouriteCount": 13,
  "viewCount": 0,
  "promoted": false,
  "isClosed": false,
  "isReserved": false,
  "isHidden": false,
  "isHeavyBulky": false,
  "scrapedAt": "2026-05-29T18:48:54.553Z"
}
```

**Item detail row** (item-detail mode) carries the same fields as above plus:

```json
{
  "recordType": "item_detail",
  "description": "In excellent worn condition as images show...",
  "color": "Black",
  "uploadedRelative": "7 hours ago",
  "sellerFeedbackCount": 838,
  "sellerFeedbackReputation": 0.94,
  "sellerBadges": ["ACTIVE_LISTER", "SPEEDY_SHIPPING"],
  "isClosed": false,
  "isReserved": false,
  "isHidden": false,
  "category": null,
  "shippingPrices": null
}
```

**Item-detail error row** (when a single URL can't be fetched — never billed):

```json
{
  "recordType": "item_detail_error",
  "url": "https://www.vinted.co.uk/items/1111111111-doesntexist",
  "reason": "HTML fetch failed across all proxy tiers (likely 4xx/anti-bot block or item removed).",
  "country": "uk",
  "scrapedAt": "2026-05-29T18:48:21.000Z"
}
```

**Brand row** (brand-catalog mode):

```json
{
  "recordType": "brand",
  "id": 115490,
  "title": "Yeezy",
  "slug": "yeezy",
  "itemCount": 376215,
  "favouriteCount": 83562,
  "isLuxury": true,
  "requiresAuthenticityCheck": true,
  "country": "uk",
  "scrapedAt": "2026-05-28T16:22:55.788Z"
}
```

### Use cases

- 🛍️ **Cross-border reseller arbitrage.** Pull Nike Air Force 1 listings on `vinted.fr` and `vinted.de`, sort by `price_low_to_high`, surface the gap.
- 💵 **Repricing engines that model true take-home.** `netSellerPrice` is the seller's number after Vinted's buyer-protection fee, so your reprice logic doesn't quietly leak margin.
- 📊 **Brand-level market research.** Lock a brand filter (`"yeezy"` resolves to `id=115490`), pull every active listing across markets, aggregate by size or condition.
- 🔍 **Counterfeit / brand-protection monitoring.** Watch a brand's full active inventory and a flagged seller's full closet on a schedule.
- 👤 **Seller surveillance.** Paste a competitor's member URL; get every active item with price, size, condition, and photos.
- 📈 **Demand-velocity research.** Track `favouriteCount` per item over time to find what's getting attention before it sells.
- 🤖 **LLM fashion-resale agents.** One flat record shape per row, with a `recordType` discriminator that feeds straight into an agent loop.
- 📂 **Brand taxonomy bootstrap.** Run `brand-catalog` once per market to capture every brand's name, ID, slug, and item count for downstream filtering.

### Limitations

- **Sold listings aren't exposed.** Vinted removes items from search and from seller closets once they sell. This actor returns active listings only; there is no anonymous way to retrieve historical sold prices.
- **960 results per query.** Vinted caps any single search at 960 items, regardless of how many actually exist. To go deeper, narrow the filter (`brand`, `category`, `priceFrom`/`priceTo`) or split a query into smaller windows.
- **Brand lookup returns the top 10.** `brand-catalog` returns up to 10 fuzzy matches per keyword, ordered by Vinted's own item-count ranking.
- **Following list is private.** A seller's follower list is reachable; the list of accounts they follow is not exposed by Vinted.
- **Account-private fields are off-limits.** Messages, order history, draft listings, and seller statistics all require being logged in as the seller, which this actor never does.

### FAQ

#### How much does Vinted Scraper cost?

Vinted Scraper uses pay-per-result pricing. You pay **$1.00 for 1,000 results**. The Apify Free plan gives you $5 in usage credits a month, enough for around 5,000 results. If you run regularly, the $29/month Starter plan covers about 29,000 results.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape Vinted?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate Vinted Scraper with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use Vinted Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~vinted-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"search","country":"uk","searchText":"nike air max","maxResults":50}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use Vinted Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call Vinted Scraper. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/tuQH3svQCJNYgfBZc/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

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

What to scrape.

## `country` (type: `string`):

Which Vinted market subdomain to use. Determines listing pool and currency.

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

Keyword query. Used by Search mode.

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

Brand filter as a name (e.g. 'nike', 'yeezy'). Resolved at runtime via Vinted's brand lookup. Used by Search mode.

## `category` (type: `integer`):

Vinted catalog ID. Find by browsing a category on Vinted and copying the catalog\[]= value from the URL. Used by Search mode.

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

Size label (e.g. 'M', 'UK 9', 'EU 42'). Used by Search mode.

## `condition` (type: `array`):

Item-condition filter. Used by Search mode.

## `color` (type: `string`):

Color filter (e.g. 'Black', 'White'). Used by Search mode.

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

Minimum price in the local currency of the selected country. Used by Search mode.

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

Maximum price in the local currency of the selected country. Used by Search mode.

## `sortBy` (type: `string`):

How to order results. Used by Search mode.

## `userUrl` (type: `string`):

Full Vinted member URL (e.g. https://www.vinted.co.uk/member/3136845853-yerardbaez). Used by User listings mode.

## `itemUrls` (type: `array`):

One or more full Vinted item URLs. Used by Item detail mode.

## `brandKeyword` (type: `string`):

Fuzzy brand name to look up (returns up to 10 matches with ID, slug, item count). Used by Brand catalog mode.

## `maxResults` (type: `integer`):

Maximum dataset rows to push. 0 = up to Vinted's 960-per-query cap (Search mode) or full closet (User listings).

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

How many requests run in parallel. Higher = faster but more proxy load. Capped at 10 for paginated modes, 8 for item-detail.

## Actor input object example

```json
{
  "mode": "search",
  "country": "uk",
  "searchText": "nike air max",
  "sortBy": "relevance",
  "maxResults": 100,
  "maxConcurrency": 6
}
```

# Actor output Schema

## `items` (type: `string`):

Use the `recordType` field to discriminate row shapes. Listing rows carry price, fees, brand + ID, size, condition, photos, seller info, favouriteCount, viewCount, sold/reserved/hidden flags. Item-detail adds description, upload time, seller badges, feedback score. Brand rows carry brand ID, slug, item count, luxury + authenticity-check flags.

# 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",
    "country": "uk",
    "searchText": "nike air max"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/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",
    "country": "uk",
    "searchText": "nike air max",
}

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/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",
  "country": "uk",
  "searchText": "nike air max"
}' |
apify call sourabhbgp/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper",
        "description": "Scrape Vinted across all 26 EU and US markets in one actor. Four modes: keyword search with filters, full seller closets, item detail, and brand name to ID lookup. Every row carries net seller price after fees, favourites, views, and sold or reserved status. $1 per 1,000 results.",
        "version": "0.0",
        "x-build-id": "8eZtxDtZxjPIrzBjw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-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/sourabhbgp~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-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/sourabhbgp~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-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": [
                    "mode",
                    "country"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "user-listings",
                            "item-detail",
                            "brand-catalog"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "search"
                    },
                    "country": {
                        "title": "Country (Vinted market)",
                        "enum": [
                            "uk",
                            "fr",
                            "de",
                            "it",
                            "es",
                            "nl",
                            "pl",
                            "pt",
                            "be",
                            "at",
                            "lt",
                            "cz",
                            "sk",
                            "hu",
                            "ro",
                            "hr",
                            "fi",
                            "dk",
                            "se",
                            "ee",
                            "gr",
                            "ie",
                            "lu",
                            "lv",
                            "si",
                            "us"
                        ],
                        "type": "string",
                        "description": "Which Vinted market subdomain to use. Determines listing pool and currency.",
                        "default": "uk"
                    },
                    "searchText": {
                        "title": "Search text",
                        "type": "string",
                        "description": "Keyword query. Used by Search mode."
                    },
                    "brand": {
                        "title": "Brand name (auto-resolves to brand ID)",
                        "type": "string",
                        "description": "Brand filter as a name (e.g. 'nike', 'yeezy'). Resolved at runtime via Vinted's brand lookup. Used by Search mode."
                    },
                    "category": {
                        "title": "Category ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Vinted catalog ID. Find by browsing a category on Vinted and copying the catalog[]= value from the URL. Used by Search mode."
                    },
                    "size": {
                        "title": "Size",
                        "type": "string",
                        "description": "Size label (e.g. 'M', 'UK 9', 'EU 42'). Used by Search mode."
                    },
                    "condition": {
                        "title": "Condition",
                        "type": "array",
                        "description": "Item-condition filter. Used by Search mode.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "new_with_tags",
                                "new_without_tags",
                                "very_good",
                                "good",
                                "satisfactory"
                            ],
                            "enumTitles": [
                                "New with tags",
                                "New without tags",
                                "Very good",
                                "Good",
                                "Satisfactory"
                            ]
                        }
                    },
                    "color": {
                        "title": "Color",
                        "type": "string",
                        "description": "Color filter (e.g. 'Black', 'White'). Used by Search mode."
                    },
                    "priceFrom": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Minimum price in the local currency of the selected country. Used by Search mode."
                    },
                    "priceTo": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Maximum price in the local currency of the selected country. Used by Search mode."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "price_low_to_high",
                            "price_high_to_low",
                            "newest_first"
                        ],
                        "type": "string",
                        "description": "How to order results. Used by Search mode.",
                        "default": "relevance"
                    },
                    "userUrl": {
                        "title": "User URL",
                        "pattern": "^https?://www\\.vinted\\.(co\\.uk|com|fr|de|it|es|nl|be|at|pl|pt|lt|cz|sk|hu|ro|hr|fi|dk|se|ee|gr|ie|lu|lv|si)/member/\\d+",
                        "type": "string",
                        "description": "Full Vinted member URL (e.g. https://www.vinted.co.uk/member/3136845853-yerardbaez). Used by User listings mode."
                    },
                    "itemUrls": {
                        "title": "Item URLs",
                        "type": "array",
                        "description": "One or more full Vinted item URLs. Used by Item detail mode.",
                        "items": {
                            "type": "string",
                            "pattern": "^https?://www\\.vinted\\.(co\\.uk|com|fr|de|it|es|nl|be|at|pl|pt|lt|cz|sk|hu|ro|hr|fi|dk|se|ee|gr|ie|lu|lv|si)/items/\\d+"
                        }
                    },
                    "brandKeyword": {
                        "title": "Brand keyword",
                        "type": "string",
                        "description": "Fuzzy brand name to look up (returns up to 10 matches with ID, slug, item count). Used by Brand catalog mode."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset rows to push. 0 = up to Vinted's 960-per-query cap (Search mode) or full closet (User listings).",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many requests run in parallel. Higher = faster but more proxy load. Capped at 10 for paginated modes, 8 for item-detail.",
                        "default": 6
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
