# Vinted Scraper (`barking_kelp/vinted-scraper`) Actor Scrape Vinted listings across multiple countries. Search by keywords, browse categories, or fetch specific items and URLs. Apply price, brand, size and condition filters, enrich results with extra details, and export clean data to JSON, CSV or Excel. - **URL**: https://apify.com/barking_kelp/vinted-scraper.md - **Developed by:** [9839_ser](https://apify.com/barking_kelp) (community) - **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.40 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Vinted Scraper (Apify Actor, Scrapy) Scrapes [Vinted](https://www.vinted.com) on any of its 25 country domains: - **keyword search** (`mode: search`), optionally combined with filters and categories; - **whole categories** (`mode: category`), including categories far above Vinted's 960-item result cap; - **the full category tree** (`mode: category_tree`, ~2 900 categories per country); - **specific items** (`mode: items`) by URL or ID; - **any Vinted catalog URL** (`mode: urls`), the domain of the URL selects the country; - optional **full item details** (description, attributes, all photos, breadcrumbs, seller rating) and **seller profiles** (city, country, ratings, item counts, last seen). Built with Scrapy and the Apify Python SDK. ### How it works Vinted's web app is a Next.js application. Its old public JSON catalog API (`/api/v2/catalog/items`) returns 404 for non-app clients, so the scraper reads the **React Server Components payload** embedded in every server-rendered `/catalog` and `/items/` page (`src/vinted/rsc.py`, `src/vinted/parsers.py`). Each catalog page carries 96 items, the pagination block and the complete category tree. Responses are gzip/brotli compressed, so a catalog page costs roughly 0.5 MB of traffic. #### Session cookie The homepage of each domain hands out an anonymous session (`access_token_web`, a 24h JWT, plus `refresh_token_web` and a few others). `VintedSessionMiddleware` (`src/middlewares.py`): 1. downloads the homepage once per domain (through the normal downloader, so proxies apply) and stores every cookie; 2. attaches the cookies as a `Cookie` header to all requests to that domain; 3. absorbs `Set-Cookie` headers from every response, so rotated tokens are picked up; 4. refreshes the session 10 minutes before the JWT expires and immediately on a `401`, retrying the failed request. Scrapy's own cookie middleware is disabled; this middleware is the single source of truth. The JSON endpoints that need the token are the seller profile (`/api/v2/users/`) and brand lookup (`/api/v2/brands`). #### Getting past the 960-item cap Vinted never returns more than 10 pages x 96 = **960 items** for a single query, and `total_entries` is capped at 960 as well. A query whose first page reports 960 entries is therefore treated as *capped* and split into disjoint sub-queries (`src/vinted/query.py::split_query`), in this order: 1. **categories** – several ids become one query per id; a single id is replaced by its child categories; a query without a category is split into the root categories (Women, Men, Kids, Home, ...); 2. **price** – the range is bisected at the median price seen on page 1 (`price_from`/`price_to` are inclusive, so the halves are `[lo, m]` and `[m+0.01, hi]`); 3. **condition** – one query per `status_ids` value; 4. **colour** – one query per `color_ids` value (items without a colour can be missed here, hence last); 5. **sort order** – the four sort orders are fetched and deduplicated (overlapping, best effort). Every piece that reports fewer than 960 entries is paginated normally. Products are deduplicated by id across all sub-queries. `maxSplitDepth` bounds the recursion; queries that still hit the cap are logged as "truncated" at the end of the run (`vinted/queries_truncated` in the stats). #### Blocks Vinted sits behind DataDome and Cloudflare and rate-limits a single IP after a few dozen fast requests. `VintedBlockMiddleware` recognises 403/429 responses and challenge pages served with 200 and retries them with exponential backoff (2 s, 4 s, 8 s, ... up to 60 s, `Retry-After` honoured). A 429 also puts the whole domain into a cool-down so new requests wait instead of piling up more 429s. With Apify Proxy every retry leaves through a different IP. Use **residential proxies** for anything beyond a few hundred requests. #### Browser fingerprint (curl_cffi) DataDome also fingerprints the TLS/HTTP2 handshake. Item pages fetched with Scrapy's Twisted downloader get a 403 straight away, independent of the IP. All requests therefore go through [`scrapy-impersonate`](https://github.com/jxlil/scrapy-impersonate) (curl_cffi), which impersonates a real browser's handshake and header set. `VintedImpersonateMiddleware` tags every request with the target from `browserImpersonation` (default `chrome`) and drops Scrapy's own `User-Agent`/`Accept` so the headers match the impersonated browser. Set `browserImpersonation` to `none` to fall back to the plain Twisted downloader. ### Modes | `mode` | What it collects | Section to fill | | --- | --- | --- | | `search` | products matching keywords (optionally inside given categories) | `searchQueries` (+ `categoryIds`, filters) | | `category` | every product of the given categories, past the 960 cap | `categoryIds` (+ filters) | | `category_tree` | the whole category tree (~2 900 categories) as `type: "category"` records | – | | `items` | full details of specific products | `itemUrls` (URLs or numeric IDs) | | `urls` | products from arbitrary catalog URLs copied from the browser, filters included | `startUrls` | `countries` selects one or more Vinted marketplaces. In the `search`, `category` and `category_tree` modes every query runs on every selected country. In the `items` and `urls` modes the domain inside each URL decides the country; a bare item ID is opened on the first selected country (item IDs are global). ### Input | Field | Description | | --- | --- | | `mode` | `search` / `category` / `category_tree` / `items` / `urls` (see above) | | `countries` | List of country codes: `de`, `fr`, `uk`, `us`, `es`, `it`, `nl`, `be`, `pl`, `cz`, `lt`, `at`, `lu`, `pt`, `sk`, `se`, `ro`, `hu`, `hr`, `dk`, `fi`, `gr`, `ie`, `ee`, `lv` | | `searchQueries` | Keywords, one per line; with `categoryIds` every keyword is searched in every category | | `categoryIds` | Category ids (e.g. `1904` Women, `5` Men, `1193` Kids, `1918` Home, `2994` Electronics, `2525` duffle coats) | | `itemUrls` | Item URLs (`https://www.vinted.fr/items/123-slug`) or numeric item IDs | | `startUrls` | Catalog URLs with any filters, or item URLs, from any Vinted domain | | `priceFrom`, `priceTo`, `order`, `brands`, `brandIds`, `statusIds`, `colorIds`, `sizeIds`, `materialIds` | Filters, identical to the parameters in Vinted's URLs; `brands` are names resolved through the brand API | | `fetchItemDetails` | Visit every item page (≈ +1 request / product); always on in `items` mode | | `fetchSellerDetails` | Call the seller API for every product (small JSON request) | | `maxItems` | Stop after N unique products (0 = unlimited) | | `splitCappedResults`, `maxSplitDepth` | Cap-splitting controls (see above) | | `maxConcurrency`, `downloadDelay`, `proxyConfiguration` | Crawl politeness and proxies | | `browserImpersonation` | curl_cffi browser fingerprint: `chrome` (default), `edge`, `safari`, `firefox`, `none` | Condition ids: `6` new with tags, `1` new without tags, `2` very good, `3` good, `4` satisfactory. #### Quick examples (each finishes in well under a minute) ```json { "mode": "urls", "countries": ["de"], "maxItems": 500, "startUrls": [ { "url": "https://www.vinted.de/catalog/2525-duffle-coats?price_from=1000¤cy=EUR&order=newest_first" }, { "url": "https://www.vinted.fr/catalog/1773-capes-and-ponchos?brand_ids[]=53&order=newest_first" }, { "url": "https://www.vinted.co.uk/catalog?search_text=carhartt%20detroit%20jacket&status_ids[]=6&order=newest_first" } ] } ``` ```json { "mode": "search", "countries": ["pl", "it"], "searchQueries": ["levis 501"], "statusIds": ["6"], "maxItems": 150 } ``` ```json { "mode": "items", "countries": ["de"], "fetchSellerDetails": true, "itemUrls": ["https://www.vinted.fr/items/10418177392-baskets-nike-dunk", "10418692724"] } ``` ```json { "mode": "category_tree", "countries": ["de", "fr"] } ``` A full category export is the expensive case: `{ "mode": "category", "countries": ["fr"], "categoryIds": ["2525"], "maxItems": 0 }` walks the whole duffle-coat category (tens of thousands of items) with the price / condition / colour splits. ### Output All records go to the default dataset and carry a `type` field. The dataset schema with field descriptions and two Console views (*Products*, *Categories*) is in `.actor/dataset_schema.json`; the Actor output schema (`.actor/output_schema.json`) exposes the products view, the categories view, the raw dataset and a CSV export in the run's Output tab. #### `type: "product"` ```json { "type": "product", "id": 10418177392, "url": "https://www.vinted.de/items/10418177392-baskets-nike-dunk", "title": "Baskets Nike Dunk", "brand": "Nike", "sizeTitle": "44", "condition": "Zufriedenstellend", "price": 22.0, "currency": "EUR", "priceWithDiscount": null, "serviceFee": 1.8, "totalPrice": 23.8, "favouriteCount": 0, "isPromoted": false, "thumbnailUrl": "https://images1.vinted.net/t/.../310x430/....webp", "photos": ["https://images1.vinted.net/t/.../f800/....webp"], "dominantColor": "#C8C2BB", "seller": { "id": 29648461, "isBusiness": false }, "country": "de", "source": { "searchText": null, "catalogIds": [1242], "priceFrom": 20, "priceTo": 24.5, "statusIds": [], "colorIds": [], "brandIds": [], "order": "newest_first", "page": 3 }, "scrapedAt": "2026-10-17T20:11:54+00:00" } ``` With `fetchItemDetails` the record additionally contains `description`, `attributes` (brand, size, status, colour, material, ... as shown on the page), `color`, `material`, `brandId`, `uploadedAgo`, `breadcrumbs`, `categoryPath`, `categoryId`, `canBuy`, `instantBuy`, `isReserved`, `isHidden`, all `photos`, `shippingPrice`, `buyerProtectionFee`, a `pricing` object (item price, buyer-protection fee, shipping price with original price / discount / free flag, pick-up-only flag, total amount, as shown to an anonymous visitor of that domain), `structuredData` (JSON-LD: category, colour, condition, availability) and `seller.name`, `seller.feedbackCount`, `seller.feedbackReputation`. There is no separate request for shipping: the `pricingServices` block is part of the same server-rendered payload. View counts are not public on Vinted item pages any more and therefore not available. With `fetchSellerDetails` the `seller` object gains `name`, `profileUrl`, `city`, `countryCode`, `feedbackCount`, `feedbackReputation`, positive/neutral/negative counts, `itemCount`, `totalItemsCount`, `followersCount`, `lastLoggedOnTs`, `isOnHoliday`, `about`, `verification`. #### `type: "category"` ```json { "type": "category", "id": 2525, "title": "Dufflecoats", "path": "Damen > Kleidung > Jacken & Mäntel > Mäntel > Dufflecoats", "parentId": 1907, "parentTitle": "Mäntel", "depth": 4, "url": "https://www.vinted.de/catalog/2525-duffle-coats", "isLeaf": true, "childrenIds": [], "photoUrl": null, "country": "de", "scrapedAt": "..." } ``` Titles are localised per domain; ids and URL slugs are the same across countries. ### Running ```bash ## locally (input in storage/key_value_stores/default/INPUT.json, same format as on Apify) python3 -m venv .venv && . .venv/bin/activate && pip install -r requirements.txt python -m src ## as a plain Scrapy spider scrapy crawl vinted -a actor_input='{"mode":"search","countries":["fr"],"searchQueries":["nike dunk"],"maxItems":200}' -O out.json ## on Apify apify push ``` ### Cost estimate One catalog page (96 products) is a single ~0.5 MB request. A category of 50 000 items therefore needs about 550 catalog requests plus the page-1 probes of the splits (typically 10-20 % overhead). `fetchItemDetails` adds one ~0.4 MB request per product; `fetchSellerDetails` adds one ~4 KB request per product. ### Project layout ``` .actor/ Actor manifest, input schema, output schema, dataset schema, Dockerfile src/__main__.py `python -m src` entry point (Apify + Twisted reactor bootstrap) src/main.py Actor main: input -> Scrapy settings -> crawl src/settings.py Scrapy settings src/middlewares.py VintedSessionMiddleware (homepage cookie), VintedBlockMiddleware (DataDome/Cloudflare), VintedImpersonateMiddleware (curl_cffi browser fingerprint) src/spiders/vinted.py The spider: queries, splitting, pagination, details, sellers, categories src/vinted/countries.py Country -> domain / currency src/vinted/rsc.py React Server Components payload decoding src/vinted/parsers.py Catalog / item / category / seller parsers src/vinted/query.py Query model, URL parsing, split strategy ``` # Actor input Schema ## `mode` (type: `string`): `search`: keyword search (section *Search*), optionally restricted to categories and filters. `category`: export whole categories by ID (section *Categories*); result sets above Vinted's 960-item cap are split automatically. `category_tree`: output every category (id, title, parent, path, URL) as records with `type = "category"`. `items`: visit the given item pages (section *Items*) and output full product details. `urls`: start from any Vinted catalog URLs with filters already applied (section *URLs*). ## `countries` (type: `array`): One or more Vinted marketplaces to scrape. ## `searchQueries` (type: `array`): One search per line. If *Category IDs* are also given, every keyword is searched inside every category. ## `categoryIds` (type: `array`): Category IDs to scrape, one per line (e.g. 2525 = duffle coats). Categories above the 960-item cap are split by sub-category, price, condition and colour automatically (see *Result cap*). ## `itemUrls` (type: `array`): One item URL (https://www.vinted.fr/items/123456-slug) or numeric item ID per line. ## `startUrls` (type: `array`): Vinted catalog or item URLs. The prefilled examples are small result sets (a few pages each) that finish in well under a minute. ## `priceFrom` (type: `integer`): Minimum price in the country's currency. ## `priceTo` (type: `integer`): Maximum price in the country's currency. ## `order` (type: `string`): Sort order of the catalog listing. 'Newest first' gives the most stable pagination. ## `brands` (type: `array`): Brand names (Nike, Adidas, Zara, ...). They are resolved to Vinted brand IDs through the brand API before the crawl starts. ## `brandIds` (type: `array`): Numeric Vinted brand IDs (e.g. 53 = Nike, 362 = Carhartt). ## `statusIds` (type: `array`): Item condition filter (any number of values). ## `colorIds` (type: `array`): Numeric Vinted colour IDs, as in color_ids\[]=... of a filtered catalog URL. ## `sizeIds` (type: `array`): Numeric Vinted size IDs, as in size_ids\[]=... of a filtered catalog URL. ## `materialIds` (type: `array`): Numeric Vinted material IDs, as in material_ids\[]=... of a filtered catalog URL. ## `fetchItemDetails` (type: `boolean`): Visit every product page: description, attributes (colour, material, size, condition), all photos, breadcrumbs, shipping price and buyer-protection fee, seller rating, status flags. Always on in the `items` mode. ## `fetchSellerDetails` (type: `boolean`): Call the seller profile API for each product: login, city, country, ratings, item counts, followers, last seen. A small JSON request per product. ## `maxItems` (type: `integer`): Stop after this many unique products in total (0 = unlimited). Does not apply to category-tree records. ## `splitCappedResults` (type: `boolean`): Disable to take only the first 960 items of every query. ## `maxSplitDepth` (type: `integer`): Safety limit for how many times one query may be split recursively. Queries that are still capped at this depth are reported as truncated in the log. ## `maxConcurrency` (type: `integer`): How many requests run in parallel. Keep it low (2-4) without proxies. ## `downloadDelay` (type: `integer`): Fixed pause between requests, in seconds. 0 disables it. ## `proxyConfiguration` (type: `object`): Proxies for the crawl. Apify residential proxies work well; every retry of a blocked request leaves through a new IP. ## `browserImpersonation` (type: `string`): Requests are sent through curl_cffi with the TLS/HTTP2 fingerprint and headers of this browser. Vinted's DataDome answers 403 to item pages fetched with a non-browser fingerprint, so keep this on unless debugging. ## Actor input object example ```json { "mode": "search", "countries": [ "de" ], "searchQueries": [ "nike dunk" ], "categoryIds": [ "2525" ], "itemUrls": [ "https://www.vinted.de/items/10418692724", "https://www.vinted.fr/items/10418177392-baskets-nike-dunk", "10418671538" ], "startUrls": [ { "url": "https://www.vinted.de/catalog/2525-duffle-coats?price_from=1000¤cy=EUR&order=newest_first" }, { "url": "https://www.vinted.fr/catalog/1773-capes-and-ponchos?brand_ids[]=53&order=newest_first" }, { "url": "https://www.vinted.co.uk/catalog?search_text=carhartt%20detroit%20jacket&status_ids[]=6&order=newest_first" } ], "order": "newest_first", "fetchItemDetails": false, "fetchSellerDetails": false, "maxItems": 500, "splitCappedResults": true, "maxSplitDepth": 14, "maxConcurrency": 8, "downloadDelay": 0, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] }, "browserImpersonation": "chrome" } ``` # Actor output Schema ## `products` (type: `string`): Scraped products as JSON: one record per unique item with title, price, fees, brand, size, condition, photos, seller and the query it came from (`type = "product"`). ## `categories` (type: `string`): Category-tree records (`type = "category"`) with id, title, parent, path, depth and URL. Filled by the `category_tree` mode. ## `allRecords` (type: `string`): The whole default dataset, products and categories together. ## `csv` (type: `string`): The products view as CSV. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "countries": [ "de" ], "searchQueries": [ "nike dunk" ], "categoryIds": [ "2525" ], "itemUrls": [ "https://www.vinted.de/items/10418692724", "https://www.vinted.fr/items/10418177392-baskets-nike-dunk", "10418671538" ], "startUrls": [ { "url": "https://www.vinted.de/catalog/2525-duffle-coats?price_from=1000¤cy=EUR&order=newest_first" }, { "url": "https://www.vinted.fr/catalog/1773-capes-and-ponchos?brand_ids[]=53&order=newest_first" }, { "url": "https://www.vinted.co.uk/catalog?search_text=carhartt%20detroit%20jacket&status_ids[]=6&order=newest_first" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("barking_kelp/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "countries": ["de"], "searchQueries": ["nike dunk"], "categoryIds": ["2525"], "itemUrls": [ "https://www.vinted.de/items/10418692724", "https://www.vinted.fr/items/10418177392-baskets-nike-dunk", "10418671538", ], "startUrls": [ { "url": "https://www.vinted.de/catalog/2525-duffle-coats?price_from=1000¤cy=EUR&order=newest_first" }, { "url": "https://www.vinted.fr/catalog/1773-capes-and-ponchos?brand_ids[]=53&order=newest_first" }, { "url": "https://www.vinted.co.uk/catalog?search_text=carhartt%20detroit%20jacket&status_ids[]=6&order=newest_first" }, ], "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("barking_kelp/vinted-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "countries": [ "de" ], "searchQueries": [ "nike dunk" ], "categoryIds": [ "2525" ], "itemUrls": [ "https://www.vinted.de/items/10418692724", "https://www.vinted.fr/items/10418177392-baskets-nike-dunk", "10418671538" ], "startUrls": [ { "url": "https://www.vinted.de/catalog/2525-duffle-coats?price_from=1000¤cy=EUR&order=newest_first" }, { "url": "https://www.vinted.fr/catalog/1773-capes-and-ponchos?brand_ids[]=53&order=newest_first" }, { "url": "https://www.vinted.co.uk/catalog?search_text=carhartt%20detroit%20jacket&status_ids[]=6&order=newest_first" } ], "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call barking_kelp/vinted-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,barking_kelp/vinted-scraper" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/iTcBwfYlYdnoWfhVc/builds/IOsbedIGCb0q9MNVX/openapi.json