# Vinted Scraper — Second-Hand Fashion Listings, Prices & Sellers (`memo23/apify-vinted-scraper`) Actor

Scrape Vinted listings via the catalog search API — title, brand, size, condition, price, buyer-protection total, favourites, views, seller and photos. Paste any Vinted catalog, member/closet, or item URL, or search by keyword + filters across any country domain. JSON/CSV out.

- **URL**: https://apify.com/memo23/apify-vinted-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 listings

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

Turn any Vinted URL or keyword into a structured stream of second-hand fashion listings.
Scrape title, brand, size, condition, price, buyer-protection total, favourites, views, seller, and photos from any catalog search, member closet, or item page — across every Vinted country domain.

![How Vinted Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-vinted.png)

### Why Use This Scraper?

- ✅ Multiple Vinted entry points — paste any catalog, member/closet, or item URL
- ✅ Keyword search mode with brand, category, size, condition, and price filters
- ✅ Every country domain — vinted.com, vinted.co.uk, vinted.fr, vinted.de, and 18 more
- ✅ Real prices including the buyer-protection total and service fee, not just the sticker price
- ✅ Seller, favourites, views, and photo data on every row
- ✅ Flat one-row-per-listing output ready for CSV and spreadsheets

### Overview

The Vinted Scraper is built for resellers, price analysts, and market researchers who need structured listing data from Vinted's second-hand fashion marketplace.

The output is always **listing-shaped rows**. Whether you start from a catalog search URL, a member's closet, or a single item URL, the resulting dataset is a flat stream of listing rows — one per item — not separate seller or search rows.

Vinted partitions its catalog by **country domain**: an item on vinted.com does not exist on vinted.fr, and the access token used to read the API is bootstrapped per domain. The scraper handles this automatically — every seed carries its own domain, and the `domain` field controls keyword searches.

### Supported Inputs

#### URL types

| URL type | Pattern | Example |
|---|---|---|
| Catalog / search | `/catalog?search_text=...&brand_ids[]=...` | `https://www.vinted.com/catalog?search_text=nike&order=newest_first` |
| Member / closet | `/member/{id}-{login}` | `https://www.vinted.com/member/3158054083-magicthriftbus` |
| Single item | `/items/{id}-slug` | `https://www.vinted.com/items/9439503568-nike-pullover-hoodie-blue` |

#### Copy-pasteable startUrls

```json
{
  "startUrls": [
    "https://www.vinted.com/catalog?search_text=nike&order=newest_first",
    "https://www.vinted.co.uk/catalog?search_text=carhartt",
    "https://www.vinted.com/member/3158054083-magicthriftbus"
  ]
}
````

#### Keyword / search mode

The actor also runs from a keyword plus filters, without any URL:

```json
{
  "searchText": "levis 501",
  "domain": "vinted.fr",
  "priceFrom": 10,
  "priceTo": 60,
  "order": "newest_first"
}
```

#### Unsupported inputs

- ❌ Content behind a Vinted login (private messages, favourites lists, buyer-only fields)
- ❌ Full item descriptions and measurements on cross-domain item URLs (Vinted 404s item detail unless the domain matches the item's home country — the scraper still emits the id, url, and domain)
- ❌ Hosts outside `*.vinted.*`

### Use Cases

| Audience | Use case |
|---|---|
| **Resellers** | Track sold-through, benchmark asking prices, and spot underpriced listings to flip |
| **Price analysts** | Build price distributions by brand, size, and condition across country domains |
| **Brand / market teams** | Monitor how a brand trades second-hand and how buyer-protection fees affect final price |
| **Sourcing agents** | Watch specific closets for new drops and reserved-vs-available status |
| **Researchers** | Bulk-export second-hand fashion supply for circular-economy and resale studies |
| **Agencies** | Deliver client-ready Vinted datasets without maintaining a scraper |

### How It Works

![How Vinted Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-vinted.png)

1. **Input** — provide Vinted URLs and/or a keyword plus filters on a chosen country domain
2. **Bootstrap token** — the actor fetches the domain homepage to obtain a per-domain access token
3. **Classify** — each URL is auto-routed to the catalog search, wardrobe (closet), or item endpoint
4. **Collect & paginate** — it walks pages up to Vinted's `total_pages` or your `maxItems`
5. **Output** — one flat listing row per item, exportable as JSON or CSV

### Input Configuration

#### Input fields

| Field | Type | Required | Notes |
|---|---|---|---|
| `startUrls` | `array<string>` | yes (or `searchText`) | Vinted catalog, member, or item URLs; auto-classified |
| `searchText` | `string` | optional | Keyword used when no URLs are given |
| `domain` | `string` enum | optional | Country domain; default `vinted.com` |
| `brandIds` | `array<string>` | optional | Numeric Vinted brand IDs (keyword search only) |
| `catalogIds` | `array<string>` | optional | Numeric category IDs (keyword search only) |
| `sizeIds` | `array<string>` | optional | Numeric size IDs (keyword search only) |
| `statusIds` | `array<string>` | optional | Numeric condition IDs (keyword search only) |
| `priceFrom` | `integer` | optional | Minimum price (keyword search only) |
| `priceTo` | `integer` | optional | Maximum price (keyword search only) |
| `order` | `string` enum | optional | `relevance` | `newest_first` | `price_low_to_high` | `price_high_to_low` |
| `maxItems` | `integer` | optional | Hard cap on listings; default `1000` |
| `maxConcurrency` | `integer` | optional | API pages in parallel; default `10` |
| `proxy` | `object` | optional | Residential recommended; built-in route by default |

#### Common scenarios

**1. Keyword search on a specific domain**

```json
{
  "searchText": "nike",
  "domain": "vinted.com",
  "order": "newest_first",
  "maxItems": 500
}
```

**2. Mixed start URLs**

```json
{
  "startUrls": [
    "https://www.vinted.com/catalog?search_text=nike",
    "https://www.vinted.com/member/3158054083-magicthriftbus"
  ],
  "maxItems": 200
}
```

**3. Filtered keyword search**

```json
{
  "searchText": "jacket",
  "domain": "vinted.co.uk",
  "brandIds": ["53"],
  "priceFrom": 15,
  "priceTo": 80
}
```

### Output Overview

Each dataset item is one listing row containing:

- **Core fields** — id, title, url, brand, size, condition, domain
- **Pricing** — price, currency, service fee, and total including buyer protection
- **Engagement** — favourites and views
- **Seller** — id, login, profile url, and business flag
- **Media** — the main photo url and photo count

Different start types (catalog / closet / item) all resolve to the same flat listing shape. A few fields are naturally sparse: `isReserved` is populated from closet pages but null on catalog search, and `views`/`favourites` are commonly `0` for brand-new listings.

### Output Samples

#### Catalog search start (keyword `nike`, vinted.com)

```jsonc
{
  "id": 9439503568,
  "title": "Nike pullover hoodie - blue",
  "url": "https://www.vinted.com/items/9439503568-nike-pullover-hoodie-blue",
  "brand": "Nike",
  "size": "L / US 12-14",
  "condition": "Very good",
  "price": 7,
  "currency": "USD",
  "totalPriceWithBuyerProtection": 8.05,
  "serviceFee": 1.05,
  "favourites": 0,
  "views": 0,
  "isPromoted": false,
  "isReserved": null,
  "sellerId": 3169579411,
  "sellerLogin": "daniv359",
  "sellerUrl": "https://www.vinted.com/member/3169579411-daniv359",
  "sellerIsBusiness": false,
  "photoUrl": "https://images1.vinted.net/t/05_00713_.../f800/1784482413.jpeg",
  "photoCount": 3,
  "domain": "vinted.com",
  "scrapedAt": "2026-07-19T17:42:41.921Z"
}
```

#### Member / closet start (same flat shape, `isReserved` populated)

```jsonc
{
  "id": 9439107296,
  "title": "2001 Mattel Harry Potter \"Gryffindor Friends\" plush doll",
  "url": "https://www.vinted.com/items/9439107296-...",
  "brand": "Harry Potter",
  "size": "One size",
  "condition": "Good",
  "price": 5,
  "currency": "USD",
  "totalPriceWithBuyerProtection": 5.7,
  "serviceFee": 0.7,
  "isReserved": false,
  "sellerLogin": "magicthriftbus",
  "photoCount": 5,
  "domain": "vinted.com"
  /* ...same fields as above... */
}
```

### Key Output Fields

#### Listing Core

- `id`, `title`, `url`, `brand`, `size`, `condition`, `domain`

#### Pricing

- `price`, `currency`
- `serviceFee`, `totalPriceWithBuyerProtection`

#### Engagement

- `favourites`, `views`, `isPromoted`, `isReserved`

#### Seller

- `sellerId`, `sellerLogin`, `sellerUrl`, `sellerIsBusiness`

#### Media

- `photoUrl`, `photoCount`

### FAQ

#### Which Vinted URLs are supported?

Catalog/search URLs (`/catalog?...`), member/closet URLs (`/member/{id}-{login}`), and single item URLs (`/items/{id}-slug`). Each is auto-classified. Filters in a catalog URL's query string (search\_text, brand\_ids, catalog, size\_ids, status, color\_ids, price\_from, price\_to, order) are mapped straight to the API.

#### Do you return listing rows or seller rows?

Always listing rows. A member/closet URL is expanded into one row per item in that seller's wardrobe — you never get a single "seller" row.

#### How do I filter by brand or category?

Filter on the Vinted site, then copy the numeric IDs out of the resulting catalog URL — `brand_ids[]`, `catalog[]`, `size_ids[]`, `status[]` — and pass them in the matching input fields (keyword-search mode). Or just paste the whole filtered catalog URL into `startUrls`.

#### Why is `totalPriceWithBuyerProtection` higher than `price`?

`price` is the seller's asking price. Vinted adds a Buyer Protection fee (`serviceFee`) on top; `totalPriceWithBuyerProtection` is what a buyer actually pays.

#### Why are some fields null or zero?

`isReserved` is only present on closet pages, so it is null on catalog search. `views` and `favourites` are frequently `0` on freshly listed items. Full item descriptions and measurements require the item-detail endpoint, which Vinted geo-restricts by domain.

#### Which countries can I scrape?

Any Vinted domain — vinted.com, .co.uk, .fr, .de, .es, .it, .nl, .be, .pl, .cz, .sk, .at, .lt, .lu, .pt, .se, .ro, .hu, .gr, .fi, .dk, .ie. Pick one with the `domain` field, or paste URLs from any of them.

#### Can I scrape private profiles or content behind login?

No. The actor only reads publicly available listing data. Anything behind the Vinted login wall is out of scope.

#### What about rate limits?

Vinted's catalog API shows low anti-bot friction. The actor bootstraps a fresh per-domain token, refreshes it and rotates the proxy on any 401/403 or block page, and paginates politely. Residential proxy is recommended for large runs.

### Support

Found a bug or have a feature request? Open an issue on the actor's [Issues tab](https://apify.com/memo23/apify-vinted-scraper/issues).

### Additional Services

Need full item descriptions, measurements, sold-listing history, or scheduled closet monitoring? Custom work is available on request — open an issue with what you need.

### Explore More Scrapers

If you found this useful, you might also like:

- [**North Data Scraper**](https://apify.com/memo23/northdata-scraper) — European company data, officers, and financials
- Other marketplace and directory scrapers on [apify.com/memo23](https://apify.com/memo23)

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/apify-vinted-scraper`).

**Purpose:** scrape Vinted second-hand fashion listings from catalog searches, member closets, or item URLs across any Vinted country domain.

**Minimal input:**

```json
{ "searchText": "nike", "domain": "vinted.com", "maxItems": 20 }
```

**Output:** one dataset row per listing — id, title, url, brand, size, condition, price, currency, serviceFee, totalPriceWithBuyerProtection, favourites, views, isPromoted, isReserved, sellerId, sellerLogin, sellerUrl, sellerIsBusiness, photoUrl, photoCount, domain, scrapedAt.

**Behaviors an agent should know:**

- Always set `maxItems` — an uncapped popular search can span hundreds of pages (~96 items each).
- `startUrls` take priority over `searchText`/filter fields; the discrete filters apply to keyword search only.
- `domain` selects the country catalog AND the token bootstrap domain; a seed URL's own domain overrides it.
- Item-detail URLs are best-effort: Vinted geo-restricts `/api/v2/items/{id}`, so a cross-domain item emits a minimal row (id, url, domain).
- Billing is per dataset row; empty searches and the run itself are not charged.

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Vinted UAB, Vinted, Inc., or any of their subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available Vinted listing pages — no authenticated endpoints, buyer-only features, or content behind the Vinted login wall. Users are responsible for ensuring their use complies with Vinted's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

### SEO Keywords

vinted scraper, scrape vinted, vinted api, vinted.com scraper, Apify vinted, vinted listings scraper, vinted closet scraper, second hand fashion data, vinted price monitoring, resale price data, vinted brand data, vinted seller scraper, used clothing scraper, secondhand marketplace scraper, vinted catalog scraper, vinted uk scraper, vinted fr scraper, fashion resale intelligence, circular economy data, vinted product data.

# Actor input Schema

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

Vinted URLs to scrape. Three shapes are auto-classified: (1) catalog/search pages like `https://www.vinted.com/catalog?search_text=nike&brand_ids[]=53` — the filters in the query string are mapped to the API and paginated; (2) member/closet pages like `https://www.vinted.com/member/12345-someseller` — the seller's whole wardrobe is paginated; (3) single item pages like `https://www.vinted.com/items/9439503568-nike-hoodie` — best-effort item row. The domain of each URL (vinted.com, vinted.fr, …) is respected automatically.

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

Free-text keyword to search when no URLs are provided above, e.g. `nike`, `carhartt jacket`, `levis 501`. Combined with the filter fields below and run against the domain selected in `domain`.

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

Vinted country domain to scrape. Vinted partitions its catalog by domain — an item on vinted.com does not exist on vinted.fr — and the access token is bootstrapped from this same domain. Applies to keyword search and to seed URLs that do not already carry a Vinted domain. Default vinted.com.

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

Restrict the keyword search to these Vinted brand IDs (numeric). Filter by a brand on Vinted and copy the `brand_ids[]` value from the catalog URL, e.g. `53` for Nike. Multiple IDs are OR-ed.

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

Restrict the keyword search to these Vinted catalog/category IDs (numeric). Read the `catalog[]` value from a filtered catalog URL, e.g. `5` for Women, `79` for Men. Multiple IDs are OR-ed.

## `sizeIds` (type: `array`):

Restrict the keyword search to these Vinted size IDs (numeric). Read `size_ids[]` from a filtered catalog URL. Multiple IDs are OR-ed.

## `statusIds` (type: `array`):

Restrict the keyword search to these Vinted condition/status IDs (numeric), e.g. new-with-tags vs good. Read `status[]` from a filtered catalog URL. Multiple IDs are OR-ed.

## `priceFrom` (type: `integer`):

Minimum price in the domain's currency. Applied to the keyword search only. Leave empty for no lower bound.

## `priceTo` (type: `integer`):

Maximum price in the domain's currency. Applied to the keyword search only. Leave empty for no upper bound.

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

Sort order for the keyword search. `relevance` (default), `newest_first`, `price_low_to_high`, or `price_high_to_low`.

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

Hard cap on the number of listings collected across all URLs and searches. Use this to control billing on broad searches.

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

Maximum number of API pages processed in parallel.

## `proxy` (type: `object`):

Proxy settings. Vinted's catalog API shows low anti-bot friction, but the actor ships with a built-in residential route for scale. Provide your own proxy here to override it; leave default to use the built-in residential routing.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.vinted.com/catalog?search_text=nike&order=newest_first"
  ],
  "searchText": "nike",
  "domain": "vinted.com",
  "brandIds": [],
  "catalogIds": [],
  "sizeIds": [],
  "statusIds": [],
  "order": "relevance",
  "maxItems": 1000,
  "maxConcurrency": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.vinted.com/catalog?search_text=nike&order=newest_first"
    ],
    "searchText": "nike",
    "brandIds": [],
    "catalogIds": [],
    "sizeIds": [],
    "statusIds": [],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/apify-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 = {
    "startUrls": ["https://www.vinted.com/catalog?search_text=nike&order=newest_first"],
    "searchText": "nike",
    "brandIds": [],
    "catalogIds": [],
    "sizeIds": [],
    "statusIds": [],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/apify-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 '{
  "startUrls": [
    "https://www.vinted.com/catalog?search_text=nike&order=newest_first"
  ],
  "searchText": "nike",
  "brandIds": [],
  "catalogIds": [],
  "sizeIds": [],
  "statusIds": [],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/apify-vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper — Second-Hand Fashion Listings, Prices & Sellers",
        "description": "Scrape Vinted listings via the catalog search API — title, brand, size, condition, price, buyer-protection total, favourites, views, seller and photos. Paste any Vinted catalog, member/closet, or item URL, or search by keyword + filters across any country domain. JSON/CSV out.",
        "version": "0.0",
        "x-build-id": "PXxnKkfIYhLbLmUwZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~apify-vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-apify-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/memo23~apify-vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-apify-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/memo23~apify-vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-apify-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": {
                    "startUrls": {
                        "title": "Vinted URLs",
                        "type": "array",
                        "description": "Vinted URLs to scrape. Three shapes are auto-classified: (1) catalog/search pages like `https://www.vinted.com/catalog?search_text=nike&brand_ids[]=53` — the filters in the query string are mapped to the API and paginated; (2) member/closet pages like `https://www.vinted.com/member/12345-someseller` — the seller's whole wardrobe is paginated; (3) single item pages like `https://www.vinted.com/items/9439503568-nike-hoodie` — best-effort item row. The domain of each URL (vinted.com, vinted.fr, …) is respected automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchText": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword to search when no URLs are provided above, e.g. `nike`, `carhartt jacket`, `levis 501`. Combined with the filter fields below and run against the domain selected in `domain`."
                    },
                    "domain": {
                        "title": "Country domain",
                        "enum": [
                            "vinted.com",
                            "vinted.co.uk",
                            "vinted.fr",
                            "vinted.de",
                            "vinted.es",
                            "vinted.it",
                            "vinted.nl",
                            "vinted.be",
                            "vinted.pl",
                            "vinted.cz",
                            "vinted.sk",
                            "vinted.at",
                            "vinted.lt",
                            "vinted.lu",
                            "vinted.pt",
                            "vinted.se",
                            "vinted.ro",
                            "vinted.hu",
                            "vinted.gr",
                            "vinted.fi",
                            "vinted.dk",
                            "vinted.ie"
                        ],
                        "type": "string",
                        "description": "Vinted country domain to scrape. Vinted partitions its catalog by domain — an item on vinted.com does not exist on vinted.fr — and the access token is bootstrapped from this same domain. Applies to keyword search and to seed URLs that do not already carry a Vinted domain. Default vinted.com.",
                        "default": "vinted.com"
                    },
                    "brandIds": {
                        "title": "Brand IDs",
                        "type": "array",
                        "description": "Restrict the keyword search to these Vinted brand IDs (numeric). Filter by a brand on Vinted and copy the `brand_ids[]` value from the catalog URL, e.g. `53` for Nike. Multiple IDs are OR-ed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "catalogIds": {
                        "title": "Catalog (category) IDs",
                        "type": "array",
                        "description": "Restrict the keyword search to these Vinted catalog/category IDs (numeric). Read the `catalog[]` value from a filtered catalog URL, e.g. `5` for Women, `79` for Men. Multiple IDs are OR-ed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sizeIds": {
                        "title": "Size IDs",
                        "type": "array",
                        "description": "Restrict the keyword search to these Vinted size IDs (numeric). Read `size_ids[]` from a filtered catalog URL. Multiple IDs are OR-ed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statusIds": {
                        "title": "Condition IDs",
                        "type": "array",
                        "description": "Restrict the keyword search to these Vinted condition/status IDs (numeric), e.g. new-with-tags vs good. Read `status[]` from a filtered catalog URL. Multiple IDs are OR-ed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceFrom": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in the domain's currency. Applied to the keyword search only. Leave empty for no lower bound."
                    },
                    "priceTo": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in the domain's currency. Applied to the keyword search only. Leave empty for no upper bound."
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest_first",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "Sort order for the keyword search. `relevance` (default), `newest_first`, `price_low_to_high`, or `price_high_to_low`.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Maximum items to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of listings collected across all URLs and searches. Use this to control billing on broad searches.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of API pages processed in parallel.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Vinted's catalog API shows low anti-bot friction, but the actor ships with a built-in residential route for scale. Provide your own proxy here to override it; leave default to use the built-in residential routing."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
