# Vinted Scraper - Listings, Prices, Sellers & Reviews (`scrapesage/vinted-scraper`) Actor

Scrape Vinted secondhand fashion across 20+ markets: search listings, item details, prices, brands, sizes, conditions, photos, seller profiles, leads and reviews. Search by keyword, filters or paste item/member/catalog URLs. Monitor new listings & price drops. No login.

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

## Pricing

from $3.00 / 1,000 item scrapeds

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 — Listings, Prices, Sellers & Reviews

Extract **structured data from [Vinted](https://www.vinted.com)** — Europe's largest secondhand fashion marketplace — across **20+ markets**. Search listings by keyword or filters, pull full **item details** (description, brand, size, condition, colour, all photos), turn sellers into **leads** (reputation, sales volume, location, lead score), and collect **seller reviews**. Paste item, member or catalog URLs, or run a search and let it paginate.

No login, no cookies to manage, no API key — fast, reliable extraction that works on every Vinted market (vinted.com, .co.uk, .fr, .de, .es, .it, .nl, .pl and more).

### Why this Vinted scraper?

Most Vinted scrapers do one thing — listings *or* a single seller *or* an arbitrage scan. This actor is the **richest all-in-one in the category**: listings, full item details, seller leads, and reviews in a single run, with a built-in **monitor mode** for new-listing and price-drop alerts — and **no per-run start fee**.

| Data | Typical scrapers | This actor |
|---|---|---|
| Listing title, price, brand, size, condition | ✅ | ✅ |
| **Total price incl. Buyer Protection** + service fee | ❌ | ✅ |
| **All listing photos** (full resolution) | partial | ✅ |
| Favourites & view counts | partial | ✅ |
| **Full item description, category & colour** | ❌ | ✅ (item details) |
| **Seller leads** — reputation, sales volume, followers, location, lead score | ❌ | ✅ |
| **Seller reviews** — rating, text, reviewer, seller reply | ❌ | ✅ |
| 20+ markets / currencies in one actor | partial | ✅ |
| Keyword **and** filter **and** URL inputs | partial | ✅ |
| **Monitor mode** (new listings + price drops) | rare | ✅ |
| Per-run start fee | often | ❌ never |
| One clean dataset per record type (no empty columns) | ❌ | ✅ |

### Use cases

- **Resale & arbitrage** — track prices, conditions and total-with-protection costs across markets to find underpriced inventory and cross-border gaps.
- **Price & market research** — monitor how brands, sizes and conditions are priced over time, and benchmark your own listings.
- **Seller sourcing & lead generation** — find high-volume and business sellers by reputation, sales volume and location; export them as leads for sourcing, wholesale or partnership outreach.
- **Brand & trend intelligence** — measure supply, demand (favourites/views) and pricing for any brand or category across Europe.
- **Datasets for AI / recommenders** — clean, structured fashion listings with images, descriptions and attributes for model training and catalog building.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Vinted Scraper**, enter one or more **search queries** (or paste item/member/catalog URLs), pick a **market**, and choose what to output.
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["nike air max"],
    "country": "com",
    "order": "newest_first",
    "priceTo": 80,
    "maxItems": 200,
    "includeItemDetails": true,
    "includeSellerLeads": true,
    "includeSellerReviews": false,
    "monitorMode": false
}
````

- **searchQueries** — keywords to search (e.g. `"zara dress"`, `"levis 501"`). Each is paginated up to **Max items**.
- **startUrls** — Vinted URLs, auto-detected: item pages (`/items/…`) → item details, member pages (`/member/…`) → seller profiles, catalog/search pages (`/catalog?…`) → searches with their filters preserved. The market is taken from each URL's domain.
- **itemIds / sellerIds** — bulk lists of Vinted item or member IDs.
- **country** *(default `com`)* — which market to search; prices are returned in that market's currency.
- **order** — `newest_first`, `relevance`, `price_low_to_high`, `price_high_to_low`.
- **priceFrom / priceTo, catalogIds, brandIds, sizeIds, statusIds** — narrow searches (find IDs in a filtered catalog URL on Vinted).
- **includeItemDetails** *(default false)* — add full description, category and colour from each item page (one extra request per item; billed at the item-detail rate).
- **includeSellerLeads** *(default false)* — one deduplicated seller record per seller in the results.
- **includeSellerReviews** *(default false)* — the feedback/reviews left on those sellers (cap with **maxReviewsPerSeller**).
- **maxSellerItems** *(default 0)* — when scraping a member, also output up to this many of their listings.
- **monitorMode / monitorKey** — emit only new (and price-dropped) records across scheduled runs.
- **proxyConfiguration** — proxy settings (Apify datacenter proxy by default).

### Output

By default you get a clean, dense table of **items**. Turn on seller leads and reviews to add those record types (each row is tagged with a `type` of `item`, `seller`, or `review` — use the dataset views to filter columns).

An item record (`type: "item"`), with item details enabled:

```json
{
    "type": "item",
    "itemId": 9200968578,
    "title": "Nike Air Max 270 Grey and Red Sneakers",
    "url": "https://www.vinted.com/items/9200968578-nike-air-max-270-grey-and-red-sneakers",
    "price": 75,
    "currency": "USD",
    "totalPrice": 79.45,
    "serviceFee": 4.45,
    "brand": "Nike",
    "size": "7",
    "condition": "New without tags",
    "favouritesCount": 12,
    "viewCount": 143,
    "photos": ["https://images1.vinted.net/.../1.jpeg", "https://images1.vinted.net/.../2.jpeg"],
    "sellerId": 3163344264,
    "sellerLogin": "simplymom615",
    "sellerProfileUrl": "https://www.vinted.com/member/3163344264-simplymom615",
    "sellerIsBusiness": false,
    "market": "com",
    "description": "Nike Air Max 270 Grey and Red Sneakers… Pre-owned but never worn. Does not include original box.",
    "category": "Men Sneakers",
    "color": "Multi",
    "conditionStandard": "New",
    "scrapedAt": "2026-06-18T05:40:27.476Z"
}
```

A seller record (`type: "seller"`) carries `login`, `city`, `countryTitle`, `feedbackReputation`, positive/neutral/negative feedback counts, `itemCount`, `totalItemsCount`, `followersCount`, `business`, `verifications`, `avgResponseTime`, `about` and a 0-100 `leadScore`. A review record (`type: "review"`) carries `rating`, `feedback`, `reviewerLogin`, the seller's `reply`, `itemId`, `createdAt` and `feedbackUrl`.

#### What to expect (field coverage)

Vinted is seller-entered data, so a few fields are populated only when the seller filled them in.

| Entity | Always present | Usually present | Present when published |
|---|---|---|---|
| **Item** | id, title, URL, price, currency, total price, condition, seller, photos | brand ~90%, size ~85% | description/category/colour (with item details) |
| **Seller** | id, login, profile, country, reputation, counts, lead score | city ~80%, response time (active sellers) | `about`, business details |
| **Review** | id, rating, reviewer, date | review text (most) | seller `reply` (when the seller responded) |

A blank field means the seller didn't publish it — not that scraping failed. Nothing is dropped, so you always get the richest record available.

### Monitor mode & scheduling

Two features work together for hands-off tracking — and they don't conflict:

- **Monitor mode** (in this actor) remembers every item/seller/review ID it has seen in a named key-value store and, on the next run, emits **only new listings** plus any listing whose **price dropped** (with `priceDropped` and `previousPrice`). It controls *what* is returned.
- **[Apify Schedules](https://docs.apify.com/platform/schedules)** control *when* the actor runs (e.g. every hour).

Combine them: schedule a saved search to run hourly with monitor mode on, and each run returns just the fresh listings and price drops — perfect for sniping deals or watching a competitor. Use a distinct **monitorKey** per saved search so their histories stay separate.

### Automate & integrate

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run searches daily/hourly to capture new listings and price drops.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (Slack alert, CRM import, reprice job) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/vinted-scraper').call({
    searchQueries: ['vintage levis'],
    country: 'co.uk',
    maxItems: 200,
    includeItemDetails: true,
});

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

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new listings or seller leads straight into your tools.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get pinged when a monitored search finds new deals.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find Nike sneakers under £50 on Vinted UK and list the highest-rated sellers" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **e-commerce & resale intelligence stack** across marketplaces:

- **[Poshmark Scraper](https://apify.com/scrapesage/poshmark-scraper)** — US resale listings, sold comps and seller leads (Vinted's US sibling).
- **[eBay Scraper](https://apify.com/scrapesage/ebay-scraper)** — listings, sold prices and seller leads.
- **[Reverb Scraper](https://apify.com/scrapesage/reverb-scraper)** — music-gear listings, price guide and seller leads.
- **[Discogs Scraper](https://apify.com/scrapesage/discogs-scraper)** — vinyl & CD marketplace, prices and seller leads.
- **[Amazon Scraper](https://apify.com/scrapesage/amazon-scraper)** — products, prices, reviews and sellers.
- **[AliExpress Scraper](https://apify.com/scrapesage/aliexpress-scraper)** — products, prices, orders and supplier leads.
- **[Flipkart Scraper](https://apify.com/scrapesage/flipkart-scraper)** — India's #1 marketplace: products, prices and reviews.
- **[Shopify Store Scraper](https://apify.com/scrapesage/shopify-store-scraper)** — products, variants, prices and store leads.

### Tips

- **Use a single market** that matches your audience — prices come back in that market's currency. For cross-border arbitrage, run the same search on several markets and compare.
- **Narrow with filters** (price, brand, size, condition) to get straight to the listings you care about — paste a filtered Vinted catalog URL into Start URLs and all its filters are preserved automatically.
- **Seller leads**: turn on `includeSellerLeads` to deduplicate every seller in your results and score them — ideal for finding high-volume or business sellers.
- **Item details cost one extra request per item.** For very large pulls where you only need price/condition, leave `includeItemDetails` off; turn it on when you need descriptions, category and colour.
- **Recurring deal alerts**: combine **monitor mode** with [Schedules](https://docs.apify.com/platform/schedules) and a [webhook](https://docs.apify.com/platform/integrations/webhooks) to get only new listings and price drops pushed to you.

### FAQ

**Which markets are supported?** 20+ Vinted markets including the US/global (vinted.com), UK, France, Germany, Spain, Italy, Netherlands, Belgium, Austria, Poland, Czechia, Slovakia, Lithuania, Luxembourg, Portugal, Sweden, Finland, Denmark, Romania, Hungary, Croatia, Greece and Ireland.

**Does it need the Vinted API or a key?** No. There is no public Vinted API; this actor reads Vinted's own public web endpoints — no key, login or browser needed.

**Can I scrape a specific seller?** Yes — paste their member URL (or pass a seller ID). You get their profile/lead, and optionally their listings (`maxSellerItems`) and reviews (`includeSellerReviews`).

**Can I export to Google Sheets, CSV or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor a search for new deals?** Turn on **monitor mode**, give it a **monitorKey**, and create a [Schedule](https://docs.apify.com/platform/schedules). Each run returns only new listings and price drops.

**A field is empty — why?** Some sellers don't add a size, description or location, and brand-new listings have zero views/favourites. Fields are blank only when the seller didn't publish that data — never because the scraper skipped it.

**Is scraping Vinted legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR for personal data) and Vinted's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Keywords to search on Vinted (e.g. "nike air max", "zara dress", "levis 501"). Each query is run against the chosen market and paginated up to Max items. Combine with the filters below to narrow results.

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

Vinted URLs to scrape — auto-detected by type. Item pages (/items/…) become item-detail records, member pages (/member/…) become seller profiles (+ their items/reviews when enabled), and catalog/search pages (/catalog?…) are scraped as searches with their filters preserved. The market is taken from each URL's domain (e.g. vinted.fr, vinted.co.uk).

## `itemIds` (type: `array`):

Vinted numeric item IDs (e.g. 9200974745). Each is fetched as a full item-detail record on the selected market.

## `sellerIds` (type: `array`):

Vinted numeric member IDs (e.g. 3163341031). Each is fetched as a seller profile; their listings and reviews are also pulled when those options are enabled.

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

Which Vinted market to search. Prices are returned in that market's local currency. Start URLs use their own domain regardless of this setting.

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

How to sort search results.

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

Only return items priced at or above this amount (in the market's currency). Leave empty for no minimum.

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

Only return items priced at or below this amount (in the market's currency). Leave empty for no maximum.

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

Restrict searches to one or more Vinted category IDs (e.g. 1904 = Women, 5 = Men). Find IDs in a catalog URL on Vinted. Leave empty to search all categories.

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

Restrict searches to one or more Vinted brand IDs (e.g. 53 = Nike). Find IDs in a filtered catalog URL on Vinted.

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

Restrict searches to one or more Vinted size IDs. Find IDs in a filtered catalog URL on Vinted.

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

Restrict searches to one or more Vinted condition IDs (e.g. 6 = New with tags, 1 = New without tags, 2 = Very good, 3 = Good, 4 = Satisfactory).

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

Maximum number of item records to scrape across all queries and URLs. Seller leads and reviews are additional and not counted against this limit.

## `includeItemDetails` (type: `boolean`):

Enrich every listing with its full description, category path, colour and exact condition by opening the item page (one extra request per item). Item records are then billed at the 'item detail' rate instead of the 'item' rate.

## `includeSellerLeads` (type: `boolean`):

Output one deduplicated seller record per unique seller found in the results — username, location, feedback reputation, sales volume, followers, business flag, verifications, response time and a 0-100 lead score. Ideal for sourcing, reseller and wholesale outreach.

## `includeSellerReviews` (type: `boolean`):

Output the feedback/reviews left on each seller (rating, text, reviewer, the seller's reply, date). Pulls reviews for the sellers found in the results or for member URLs/IDs.

## `maxReviewsPerSeller` (type: `integer`):

How many of the most recent reviews to output per seller when Include seller reviews is on.

## `maxSellerItems` (type: `integer`):

When scraping a member/seller (via member URL or seller ID), how many of their listings to also output. 0 returns only their profile (and reviews if enabled).

## `monitorMode` (type: `boolean`):

Remember item/seller/review IDs seen in previous runs (in a named key-value store) and emit only records that are new — plus listings whose price dropped. Works alongside Apify Schedules for hands-off monitoring of a search or seller.

## `monitorKey` (type: `string`):

Names the monitor store so different searches keep separate memory (e.g. "nike-uk-under-50"). Reuse the same key across scheduled runs to keep deduplicating against the same history.

## `proxyConfiguration` (type: `object`):

Proxy settings. Vinted is reachable on Apify datacenter proxies (the default); switch to Residential if you hit rate challenges at high volume or in some markets.

## Actor input object example

```json
{
  "searchQueries": [
    "nike air max"
  ],
  "startUrls": [
    {
      "url": "https://www.vinted.com/catalog?search_text=vintage%20levis"
    }
  ],
  "country": "com",
  "order": "newest_first",
  "maxItems": 100,
  "includeItemDetails": false,
  "includeSellerLeads": false,
  "includeSellerReviews": false,
  "maxReviewsPerSeller": 20,
  "maxSellerItems": 0,
  "monitorMode": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped Vinted records (items, seller leads and reviews) as JSON items in the default dataset.

# 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 = {
    "searchQueries": [
        "nike air max"
    ],
    "startUrls": [
        {
            "url": "https://www.vinted.com/catalog?search_text=vintage%20levis"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = {
    "searchQueries": ["nike air max"],
    "startUrls": [{ "url": "https://www.vinted.com/catalog?search_text=vintage%20levis" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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 '{
  "searchQueries": [
    "nike air max"
  ],
  "startUrls": [
    {
      "url": "https://www.vinted.com/catalog?search_text=vintage%20levis"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper - Listings, Prices, Sellers & Reviews",
        "description": "Scrape Vinted secondhand fashion across 20+ markets: search listings, item details, prices, brands, sizes, conditions, photos, seller profiles, leads and reviews. Search by keyword, filters or paste item/member/catalog URLs. Monitor new listings & price drops. No login.",
        "version": "0.1",
        "x-build-id": "GqW7a4q6tzGj7vavK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-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/scrapesage~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-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/scrapesage~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-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": {
                    "searchQueries": {
                        "title": "Search queries (keywords)",
                        "type": "array",
                        "description": "Keywords to search on Vinted (e.g. \"nike air max\", \"zara dress\", \"levis 501\"). Each query is run against the chosen market and paginated up to Max items. Combine with the filters below to narrow results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (items, members, catalog/search pages)",
                        "type": "array",
                        "description": "Vinted URLs to scrape — auto-detected by type. Item pages (/items/…) become item-detail records, member pages (/member/…) become seller profiles (+ their items/reviews when enabled), and catalog/search pages (/catalog?…) are scraped as searches with their filters preserved. The market is taken from each URL's domain (e.g. vinted.fr, vinted.co.uk).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "itemIds": {
                        "title": "Item IDs",
                        "type": "array",
                        "description": "Vinted numeric item IDs (e.g. 9200974745). Each is fetched as a full item-detail record on the selected market.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerIds": {
                        "title": "Seller / member IDs",
                        "type": "array",
                        "description": "Vinted numeric member IDs (e.g. 3163341031). Each is fetched as a seller profile; their listings and reviews are also pulled when those options are enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Market (Vinted domain)",
                        "enum": [
                            "com",
                            "co.uk",
                            "fr",
                            "de",
                            "es",
                            "it",
                            "nl",
                            "be",
                            "at",
                            "pl",
                            "cz",
                            "sk",
                            "lt",
                            "lu",
                            "pt",
                            "se",
                            "fi",
                            "dk",
                            "ro",
                            "hu",
                            "hr",
                            "gr",
                            "ie"
                        ],
                        "type": "string",
                        "description": "Which Vinted market to search. Prices are returned in that market's local currency. Start URLs use their own domain regardless of this setting.",
                        "default": "com"
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "newest_first",
                            "relevance",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "How to sort search results.",
                        "default": "newest_first"
                    },
                    "priceFrom": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return items priced at or above this amount (in the market's currency). Leave empty for no minimum."
                    },
                    "priceTo": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return items priced at or below this amount (in the market's currency). Leave empty for no maximum."
                    },
                    "catalogIds": {
                        "title": "Catalog (category) IDs",
                        "type": "array",
                        "description": "Restrict searches to one or more Vinted category IDs (e.g. 1904 = Women, 5 = Men). Find IDs in a catalog URL on Vinted. Leave empty to search all categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brandIds": {
                        "title": "Brand IDs",
                        "type": "array",
                        "description": "Restrict searches to one or more Vinted brand IDs (e.g. 53 = Nike). Find IDs in a filtered catalog URL on Vinted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sizeIds": {
                        "title": "Size IDs",
                        "type": "array",
                        "description": "Restrict searches to one or more Vinted size IDs. Find IDs in a filtered catalog URL on Vinted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statusIds": {
                        "title": "Condition IDs",
                        "type": "array",
                        "description": "Restrict searches to one or more Vinted condition IDs (e.g. 6 = New with tags, 1 = New without tags, 2 = Very good, 3 = Good, 4 = Satisfactory).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of item records to scrape across all queries and URLs. Seller leads and reviews are additional and not counted against this limit.",
                        "default": 100
                    },
                    "includeItemDetails": {
                        "title": "Include item details (description, category, colour)",
                        "type": "boolean",
                        "description": "Enrich every listing with its full description, category path, colour and exact condition by opening the item page (one extra request per item). Item records are then billed at the 'item detail' rate instead of the 'item' rate.",
                        "default": false
                    },
                    "includeSellerLeads": {
                        "title": "Include seller leads",
                        "type": "boolean",
                        "description": "Output one deduplicated seller record per unique seller found in the results — username, location, feedback reputation, sales volume, followers, business flag, verifications, response time and a 0-100 lead score. Ideal for sourcing, reseller and wholesale outreach.",
                        "default": false
                    },
                    "includeSellerReviews": {
                        "title": "Include seller reviews",
                        "type": "boolean",
                        "description": "Output the feedback/reviews left on each seller (rating, text, reviewer, the seller's reply, date). Pulls reviews for the sellers found in the results or for member URLs/IDs.",
                        "default": false
                    },
                    "maxReviewsPerSeller": {
                        "title": "Max reviews per seller",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many of the most recent reviews to output per seller when Include seller reviews is on.",
                        "default": 20
                    },
                    "maxSellerItems": {
                        "title": "Max items per seller",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "When scraping a member/seller (via member URL or seller ID), how many of their listings to also output. 0 returns only their profile (and reviews if enabled).",
                        "default": 0
                    },
                    "monitorMode": {
                        "title": "Monitor mode — only new records",
                        "type": "boolean",
                        "description": "Remember item/seller/review IDs seen in previous runs (in a named key-value store) and emit only records that are new — plus listings whose price dropped. Works alongside Apify Schedules for hands-off monitoring of a search or seller.",
                        "default": false
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Names the monitor store so different searches keep separate memory (e.g. \"nike-uk-under-50\"). Reuse the same key across scheduled runs to keep deduplicating against the same history.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Vinted is reachable on Apify datacenter proxies (the default); switch to Residential if you hit rate challenges at high volume or in some markets.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
