# Vinted Scraper: Every Listing, Past the 960 Cap (`alexmorain/vinted-scraper`) Actor

Scrape every Vinted listing past the 960-per-search cap: 11,150 relevant listings on a search the site stops at 960. Keywords or URLs on 7 sites (FR, DE, ES, IT, PL, UK, US), total price with fees, only listings that contain your words, photos, seller, full description, new-listings monitoring.

- **URL**: https://apify.com/alexmorain/vinted-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 88.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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

### What does Vinted Scraper do?

Vinted Scraper exports **every listing of a [Vinted](https://www.vinted.com) search**, not only the first 960 that the site shows. Give it keywords and countries, or paste catalog URLs, and you get one row per listing: title, brand, size, condition, price, the Buyer Protection fee and the total price, favourites, photos, seller id and business flag. If you ask for it, each row also carries the full description, category, colour, posting time and the seller's feedback.

It works as a **Vinted API** for the public catalog: it reads the same pages the Vinted website shows to a visitor, over plain HTTP. No browser, no login, no cookies from your account.

It covers the **7 Vinted sites**: vinted.fr, vinted.de, vinted.es, vinted.it, vinted.pl, vinted.co.uk and vinted.com. Each row keeps the currency of its site (EUR, PLN, GBP, USD).

#### Vinted stops at 960 results per search

Whatever the search, Vinted returns at most **960 listings**: ten pages of 96, and the eleventh page is empty. A search for `nike` on vinted.fr shows 960 listings while the category counts of the search page add up to more than 300,000. A scraper that reads the ten pages loses the rest without telling you.

This actor notices when a search hits the cap and cuts it into smaller searches until every piece is under 960. It cuts in this order: first by **category**, then by **price range**, then by **condition**, and last by **colour**. It reads the pieces in parallel, removes the listings that appear in two pieces, and reports at the end how many listings Vinted announced and how many it delivered.

Measured on 7 and 8 November 2026, on the Apify platform (vinted.fr):

| Search | Vinted announced | One search (what the site shows) | Read by the actor | Filtered out by Only listings that contain every search word | Delivered |
|---|---|---|---|---|---|
| `tamagotchi` | 14,160 | 960 | 13,997 | 2,847 | **11,150** |
| `ipod classic` | 1,235 | 960 | 1,228 | 620 | **608** |
| `salomon xt-6` (before that option existed) | 2,720 | 960 | 2,707 | none | **2,707** |
| `new balance 530` (before that option existed) | 18,419 | 960 | 18,166 | none | **18,166** |

"Announced" is the total that the category counts of the search page add up to when no filter is set. It is Vinted's own count, and Vinted's search is fuzzy: it matches listings that only partly contain your words. That is why the actor reads almost all of the announced listings and then, by default, delivers fewer: it keeps only the listings whose title or brand contains every word of your search (see below). In these runs no cell stayed at 960 after the last split and no cell failed. The gap between announced and read (0.5% to 1.4%) is explained in the FAQ.

### Why use Vinted Scraper?

- **Resellers and sourcing.** Watch a brand, a model or a category across countries for underpriced listings, with the total price including the Buyer Protection fee. Run it in **New items only** mode on a schedule and pay only for what is new.
- **Price and market research.** Count listings and read asking prices by brand, model, condition or country. A search is no longer capped at the 960 most recent ones, so a median price rests on the whole market, not on a slice.
- **Resale and arbitrage between countries.** The same model on vinted.fr, vinted.de and vinted.pl in one run, each row with its currency.
- **Brand and trend monitoring.** Track how many listings of a brand appear each day and how favourites evolve.
- **Pipelines.** Rows go to the dataset in JSON, CSV or Excel, to Google Sheets, Slack, Zapier, Make or n8n, and a webhook tells you when a run ends. Apify adds scheduling, an API for every run, proxy rotation and monitoring.

### What data can Vinted Scraper extract?

| Field | Example | Description |
|---|---|---|
| `id` | `10711433187` | Vinted listing id, unique per site. Use it to deduplicate across runs |
| `url` | `https://www.vinted.fr/items/10711433187-cargo-nike-noir` | Link to the listing |
| `title`, `brand` | `Cargo Nike noir`, `Nike` | Title and brand shown on the card |
| `size`, `condition` | `XS`, `Neuf sans étiquette` | Size (`null` when the listing has none) and condition, in the language of the site |
| `price` | `40` | Price asked by the seller, in the currency of the site |
| `serviceFee` | `2.7` | Buyer Protection fee added on top |
| `totalPrice` | `42.7` | Price plus fee: what the buyer pays for the item, shipping not included |
| `currency` | `EUR` | ISO currency of the site |
| `favouriteCount` | `0` | Members who favourited the listing |
| `isPromoted` | `false` | `true` when the seller paid to promote the listing |
| `sellerId`, `sellerIsBusiness` | `312278158`, `false` | Seller's Vinted member id and professional flag |
| `photos`, `thumbnailUrl`, `dominantColor` | `["https://images1.vinted.net/..."]`, `#C7C5C4` | Full-size photo URLs, small cover photo and the dominant colour of the cover |
| `domain`, `country` | `www.vinted.fr`, `FR` | Site of the listing and its country (`GB` for vinted.co.uk, `US` for vinted.com) |
| `searchQuery`, `searchUrl` | `nike`, `https://www.vinted.fr/catalog?search_text=nike&order=newest_first` | The search that found the listing |
| `scrapedAt` | `2026-11-08T02:09:45Z` | When the row was collected |

With **Add the item page (details)**, each row also has:

| Field | Example | Description |
|---|---|---|
| `description` | `Cargo Nike noir porter une seule fois...` | The full text written by the seller |
| `brandId`, `categoryId` | `53`, `583` | Vinted ids, usable in the **Brand ids** and **Category ids** inputs |
| `category` | `Hommes Pantalons` | Category path in the language of the site |
| `color`, `material` | `Noir`, `null` | Declared by the seller. `material` is empty on many listings |
| `uploadedText` | `Il y a une minute` | When the listing was posted, as Vinted writes it ("a minute ago"), in the language of the site. It is not a timestamp |
| `sellerLogin` | `xcii.tcheumii` | Seller's login |
| `sellerFeedbackCount`, `sellerFeedbackReputation` | `12`, `1` | Number of reviews of the seller and the reputation value Vinted reports |
| `canBuy`, `isReserved`, `isHidden` | `true`, `false`, `false` | State of the listing |
| `detailsFetched` | `true` | `false` on a row whose page was gone or unreachable |

The list rows do not carry the posting date: Vinted does not give it in the search results. To get it, even as relative text, use the details option.

### How to scrape Vinted

1. Click **Try for free**.
2. Type one or more **Keywords** (for example `nike` or `levi's 501`) and pick the **Countries**. Or paste Vinted catalog URLs into **Vinted catalog URLs**: the keyword, price range, category, brand, condition and colour filters are read from the URL.
3. Set **Max items per search**. It is also your cost cap: each item is one charged result.
4. Leave **Go beyond 960 items** on.
5. Press **Start**, then download the dataset as JSON, CSV or Excel.

To watch a search, tick **New items only** and add a schedule.

### How much will it cost to scrape Vinted?

The actor is billed per result: a start fee of $0.002 per GB of memory (512 MB is the default and counts as one event), plus one charge per listing. A listing read with **details** costs more than a plain one. Prices fall with your Apify plan:

| Plan | Listing, per 1,000 | Listing with details, per 1,000 |
|---|---|---|
| Free | $1.00 | $2.00 |
| Bronze | $0.90 | $1.80 |
| Silver | $0.80 | $1.60 |
| Gold | $0.50 | $1.00 |

Examples at the Free plan price: the 11,150 listings of `tamagotchi` cost about $11.15 plus the start fee. 500 listings with details cost $1.00. In **New items only** mode, a listing delivered once is never charged again.

The Apify platform usage of a run is small and is included: the 11,150-listing `tamagotchi` run used $0.074 of platform usage in total, which is about $0.007 per 1,000 listings delivered. A run with details costs more in usage because it opens every listing page: 100 listings with details used $0.008. **Max items per search** and the spending limit you set on a run stop it at the cap you choose. The default of 1,000 items per search limits a first test to $1.00 at the Free price. Listings dropped by the keyword filter are not charged.

### Input

See the **Input** tab for every option. The ones worth knowing:

| Field | What it does |
|---|---|
| `searchUrls` | Vinted catalog pages, one per line, from any of the 7 sites. Keyword, price range, category, brand, condition and colour are read from the URL. Size and material filters are not supported and are ignored (the log says so). Item, member and brand pages are rejected with a message |
| `searchQueries` | One search per keyword and country |
| `countries` | `fr`, `de`, `es`, `it`, `pl`, `co.uk`, `com`. Empty with keywords means France |
| `priceMin`, `priceMax` | Seller's price range in the currency of each site, fees not included. Apply to the keyword searches |
| `catalogIds`, `brandIds` | Vinted category and brand ids. The id is in the catalog URL after `catalog[]=` or `/catalog/`, and after `brand_ids[]=`. Several ids mean any of them |
| `conditions` | `New with tags`, `New without tags`, `Very good`, `Good`, `Satisfactory`. Empty means all |
| `maxItems` | Items per search. `0` means no limit. Default 1,000 |
| `strictMatch` | On by default. Delivers only listings whose title or brand contains every word of the keywords. Dropped listings are never charged |
| `splitBeyondLimit` | On by default. Off reads the first 960 only, in fewer requests |
| `includeDetails` | Opens every listing page. One extra request per item |
| `newOnly`, `registryKey` | Returns only listings not delivered by a previous run of the same searches |
| `webhookUrl` | JSON summary posted when the run ends |
| `maxConcurrency` | Parallel connections, 1 to 20, default 6 |
| `proxyConfiguration` | Apify datacenter proxy by default |

Filters set as inputs (`priceMin`, `catalogIds`, `conditions` and the others) apply to the keyword searches. A pasted URL keeps its own filters.

#### Example inputs

A keyword on three sites, with a price range:

```json
{
  "searchQueries": ["stone island"],
  "countries": ["fr", "de", "it"],
  "priceMin": 20,
  "priceMax": 300,
  "maxItems": 5000
}
```

Pasted catalog URLs (a category on vinted.fr, a keyword on vinted.co.uk):

```json
{
  "searchUrls": [
    "https://www.vinted.fr/catalog?search_text=jordan&catalog[]=1231",
    "https://www.vinted.co.uk/catalog?search_text=barbour"
  ],
  "maxItems": 0
}
```

One brand across a category, only items in good condition, with the full listing:

```json
{
  "searchQueries": ["veste"],
  "countries": ["fr"],
  "brandIds": ["53"],
  "conditions": ["New with tags", "Very good"],
  "includeDetails": true,
  "maxItems": 500
}
```

A daily watch, with a webhook:

```json
{
  "searchQueries": ["new balance 530"],
  "countries": ["fr"],
  "newOnly": true,
  "maxItems": 0,
  "webhookUrl": "https://hooks.example.com/vinted"
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A listing read with details (a real row from a run of 8 November 2026):

```json
{
  "id": 10711433187,
  "url": "https://www.vinted.fr/items/10711433187-cargo-nike-noir",
  "title": "Cargo Nike noir",
  "brand": "Nike",
  "size": "XS",
  "condition": "Neuf sans étiquette",
  "price": 40,
  "serviceFee": 2.7,
  "totalPrice": 42.7,
  "currency": "EUR",
  "favouriteCount": 0,
  "isPromoted": false,
  "sellerId": 312278158,
  "sellerIsBusiness": false,
  "photos": [
    "https://images1.vinted.net/t/05_019b1_bWqAujuTMqja9ztpddSQPPiU/f800/67f7fe9b.webp?s=80cdba2c25c48d976984f1dc8804d2280ff1194f"
  ],
  "thumbnailUrl": "https://images1.vinted.net/t/05_019b1_bWqAujuTMqja9ztpddSQPPiU/310x430/67f7fe9b.webp?s=6c46683d5ae592481407cd1dead462f01ce371d7",
  "dominantColor": "#C7C5C4",
  "domain": "www.vinted.fr",
  "country": "FR",
  "searchQuery": "nike",
  "searchUrl": "https://www.vinted.fr/catalog?search_text=nike&order=newest_first",
  "scrapedAt": "2026-11-08T02:09:45Z",
  "description": "Cargo Nike noir porter une seule fois taille xs mais taille a peu près comme un S ( prix négociable )",
  "brandId": 53,
  "categoryId": 583,
  "category": "Hommes Pantalons",
  "color": "Noir",
  "material": null,
  "uploadedText": "Il y a une minute",
  "sellerLogin": "xcii.tcheumii",
  "sellerFeedbackCount": 12,
  "sellerFeedbackReputation": 1,
  "canBuy": true,
  "isReserved": false,
  "isHidden": false,
  "detailsFetched": true
}
```

Without details the same row has `description`, `brandId`, `categoryId`, `category`, `color`, `material`, `uploadedText`, `sellerLogin`, `sellerFeedbackCount`, `sellerFeedbackReputation`, `canBuy`, `isReserved` and `isHidden` set to `null`, and `detailsFetched` set to `false`.

#### The run report

Every run saves a record named `OUTPUT` in its key-value store (the **Run report** link of the Output tab). For each search it gives the announced total (Vinted's count), the number of cells, the requests, the listings read (`retrieved`), the listings dropped by the keyword filter (`filteredOut`), the listings delivered, the parts skipped as off-topic (`offTopicCells`), the cells that stayed at 960 after every split and the cells that failed. The top level also carries `delivered` and `filteredOut` for the whole run. At the top, `complete` says whether the whole read went through. The status message of the run shows the same figures on one line, with the network totals: requests, rate-limited requests, IP rotations, megabytes.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/vinted-scraper").call(run_input={
    "searchQueries": ["new balance 530"],
    "countries": ["fr", "de"],
    "maxItems": 5000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["totalPrice"], item["currency"], item["title"], item["url"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('alexmorain/vinted-scraper').call({
    searchUrls: ['https://www.vinted.fr/catalog?search_text=salomon%20xt-6'],
    includeDetails: true,
    maxItems: 300,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~vinted-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["tamagotchi"], "countries": ["fr"], "maxItems": 100}'
```

The synchronous endpoint waits for the run to end, so use it for small runs. For thousands of listings, start the run and read the dataset when it finishes.

#### Only listings that contain every search word

Vinted's search is fuzzy. When a search is rare or narrowed by a price range, Vinted pads the results with unrelated listings: a search for `polly pocket` between 300 and 310 EUR returns a games console. On `ipod classic`, only 56% of the first 960 listings have both words in the title or brand. You would pay for the rest.

So **Only listings that contain every search word** (`strictMatch`) is on by default. A listing is delivered only if its title or brand contains every word of your keywords. Case, accents and simple plurals are ignored, a word matches the start of a word (`classic` matches `classique`), and a number such as `530` also matches inside `MR530SG`. Dropped listings are never delivered or charged, and the run report counts them as `filteredOut`. When the first page of a part of the search has almost no listing that matches (2% or less), the actor does not read that part further and names it in `offTopicCells`.

What it can lose: listings whose title does not carry your words, for example an `iPod 6th generation 80 GB` when you searched `ipod classic`. On `ipod classic` we estimate those at about 2.5% of the listings read (27 of the 960 first rows). On `tamagotchi` we found none in a sample of 22 dropped rows. These are estimates from small samples, not counts. If you want exactly what Vinted returns, turn the option off. It applies to keywords, and to the keyword of a pasted URL. A search made of filters only (a category or a brand without keyword) is not filtered.

### Tips

- **Set `maxItems` first.** A broad keyword such as `nike` holds hundreds of thousands of listings. Start with 1,000, look at the rows, then raise it. `maxItems` counts per search, so three countries with `maxItems` 1,000 can deliver 3,000 rows.
- **Narrow the search rather than raising the cap.** A category id, a brand id or a price range cuts the number of requests and the cost for the same listings you care about.
- **Use the proxy default.** The actor uses the Apify datacenter proxy and changes IP whenever Vinted refuses one. Vinted answers about 30 requests a minute per IP, so the speed comes from parallel connections, each on its own IP. About 5% of the requests meet an HTTP 403 on the way and are replayed on a fresh IP. Residential proxy also works but costs far more: we measured about $0.14 per 1,000 listings in proxy traffic, against about $0.006 per 1,000 for the whole run on datacenter.
- **Mind the memory on huge reads.** At the default 512 MB a single run held about 100,000 delivered listings before the container ran out of memory (memory grows by about 3 KB per listing read). Above 80,000 listings in one run, set the memory to 1,024 MB or more in the run options (the start fee is charged per GB), or split the search with price or category filters. We have not run past 100,000 listings in one run.
- **Raise `maxConcurrency` for big reads.** The measured speed on 16 connections is about 3,600 listings per minute. The default of 6 connections is slower, and 20 is the maximum.
- **Details cost one request each.** Add them only when you need the description or the seller's feedback. Do a first run without details to select what you need, then read the details of those.
- **Read the status message.** A run that stopped early, a search that failed or a cell that stayed at 960 is written there and in the run report.

#### Monitoring with New items only

The first run reads everything and then records that the read was complete. The following runs read the newest pages of each search, one by one, and stop at the first page where every listing was already delivered. If more than 960 listings are new since the last run, the actor goes back to the full read for that search. Listings already delivered are never charged twice.

A run that stops early (`maxItems` reached, spending limit, a search that failed) does not record a complete read, so the next run reads everything again. For a watch, leave `maxItems` at `0`. The memory is a named key-value store, `vinted-registry`, with one record per set of searches. Change a search (another keyword, another price range) and the actor starts a new memory. Use `registryKey` to give a name to a watch, to keep several independent watches on the same search, or to change the search without losing the history.

On a test search (`tamagotchi connexion`, vinted.fr), the first run delivered 127 listings. The second run, a minute later, read one page, found 96 listings it already knew and delivered none, at no charge.

#### Webhook

If you set `webhookUrl`, the actor posts a JSON summary when the run ends: `actor`, `runId`, `datasetId`, `mode` (`all` or `new-only`), `status` (`succeeded`, `partial` or `failed`), `searches`, `failedSearches`, `articles` (the listings delivered), `skippedAlreadySeen` and `chargeLimitReached`. The URL is stored as a secret and never logged.

### FAQ

#### How do I get more than 960 Vinted results?

You split the search until each piece is under 960, then merge. Vinted Scraper does it for you. When the first page of a search says 960, it reads the category facets of that page and opens one search per sub-category, and does the same inside each sub-category until it reaches the leaves. A piece that is still at 960 is cut by price (at the median price of its first page), then by condition, then by colour. The pieces are read in parallel and the duplicates are removed by listing id.

The actor also checks that the sub-categories cover their parent. Some listings sit at the parent level only and belong to no child. When too many listings of the parent's first page are missing from its children, the parent is read again, cut by price.

#### Why is there a gap of 1 to 1.5% between announced and delivered?

The four measurements above read 98.6% to 99.5% of the announced total (13,997 of 14,160, 1,228 of 1,235, 2,707 of 2,720, 18,166 of 18,419). The search is a live feed sorted by newest first, and listings are posted, sold and removed while the run goes. On `nike` on vinted.fr, 34 of the 95 listings of the first page had changed 25 seconds later. When new listings arrive on top, every page pushes its last listings onto the next page (these are the duplicates the actor removes), and a listing sold during the read can slide between two pages and be missed. The actor reads one more page when a piece has fewer distinct listings than announced, which recovers the listings pushed past the last page. We did not measure which part of the remaining gap comes from removals. The announced figure is also taken from the facets at the start of the read and is not updated.

#### How fast is it?

On Apify datacenter proxy with 16 connections, we measured about 3,600 listings per minute: 45,000 listings of `nike` on vinted.fr in about 12 minutes, in 831 requests. A full read of 18,166 listings took 8.8 minutes, and `tamagotchi` (13,997 read) 7.2 minutes. With the default of 6 connections it is slower. Without a proxy the run has one IP and reads about 30 requests a minute. With details, add one request per listing, spread over the same connections.

#### Does it work on all Vinted countries?

On the 7 sites listed above. Each one was tested in one run: 50 listings per site, with the right currency (EUR on vinted.fr, vinted.de, vinted.es and vinted.it, PLN on vinted.pl, GBP on vinted.co.uk, USD on vinted.com). Other Vinted sites, such as the Lithuanian or Dutch one, are not supported.

#### Can I search without a keyword?

Yes, with a category id or a brand id: `catalogIds` or `brandIds` with `countries`, or a catalog URL such as `https://www.vinted.fr/catalog/1231-sneakers`. A search with neither a keyword nor a category nor a brand is refused with a message, because it would be the whole site.

#### Can I filter by size?

Not yet. Size and material filters in a pasted URL are ignored and the log says so. Keep the rows and filter on `size` after the run.

#### What happens if my run is migrated to another server?

The Apify platform sometimes moves a run to another server, which restarts the actor with the same input and the same storages. The actor keeps a record of the listings it already delivered and of how many each search delivered. After a restart it skips them (they are neither pushed again nor charged again) and `maxItems` counts them: a restarted run does not go over the cap. It does read the searches again from the start, so a migration can lengthen a big run.

#### What does a failed item page do?

With details on, a listing whose page is gone (HTTP 404) or unreachable is delivered with `detailsFetched` set to `false` and charged as a plain listing. In a test of 100 listings with details, 99 pages were read.

#### Why does `isPromoted` matter?

Promoted listings are paid placements and can appear out of order in the feed. In New items only mode the actor never uses them to decide that a page is already known.

#### Is it legal to scrape Vinted?

The actor reads public catalog pages that anyone can open without an account. Vinted's terms of use restrict automated access to its site, so check them against your use. Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

The rows carry the seller's member id, and with details the seller's login. Treat them as personal data.

#### What if Vinted changes?

The actor reads the data embedded in Vinted's catalog pages, which can change without notice. If a run starts failing or returning less, open the Issues tab and report it with the search you ran.

#### Support

Questions, a field you miss, a search that comes back short: use the **Issues** tab of this Actor. The **API** tab has the endpoints to start and read runs from your own code.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Vinted Scraper page](https://alexis.morain.fr/en/scrapers/vinted-scraper/) of my site. The [Classifieds and real estate family page](https://alexis.morain.fr/en/scrapers/families/classifieds-real-estate/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

## `searchUrls` (type: `array`):

Catalog pages copied from your browser, one per line, such as <code>https://www.vinted.fr/catalog?search_text=nike\&catalog\[]=5</code> or <code>https://www.vinted.de/catalog/1231-sneakers?search_text=jordan</code>. Any of the 7 sites. Keyword, price range, category, brand, condition and colour filters are read from the URL; size and material filters are not supported and are ignored. Can be combined with the keywords below.

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

One search per keyword and country, such as <code>nike</code> or <code>levi's 501</code>. The filters below apply to these searches.

## `countries` (type: `array`):

Vinted sites to search with the keywords, the category ids and the filters below. Empty = France. Pasted catalog URLs carry their own site.

## `priceMin` (type: `number`):

Only items priced at or above this amount, in the currency of each site (the seller's price, fees not included). Applies to the keyword searches, not to pasted URLs.

## `priceMax` (type: `number`):

Only items priced at or below this amount. Applies to the keyword searches, not to pasted URLs.

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

Vinted category ids, such as <code>5</code> (men) or <code>1231</code> (men's shoes). The id is in the catalog URL after <code>catalog\[]=</code> or <code>/catalog/</code>. Several = any of them. Applies to the keyword searches, not to pasted URLs. With no keyword, a category id alone makes a search.

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

Vinted brand ids, such as <code>53</code> (Nike). The id is in the catalog URL after <code>brand_ids\[]=</code>. Applies to the keyword searches, not to pasted URLs. With no keyword, a brand id alone makes a search.

## `conditions` (type: `array`):

Only items in these conditions. Empty = all. Applies to the keyword searches, not to pasted URLs.

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

Stops each search after this many items. Each item is one charged result, so this is also your cost cap: with several keywords or countries, the total is this number times the number of searches. <b>0 = no limit</b>. Leave it at 0 for monitoring, a capped run does not record a complete read. At the default 512 MB of memory a single run holds about 100,000 delivered items; above 80,000, raise the memory in the run options.

## `strictMatch` (type: `boolean`):

Vinted's search is fuzzy: when a search is rare or narrowed by a price range, it pads the results with unrelated listings (a search for <code>polly pocket</code> at 300 to 310 EUR returns a games console). With this on, a listing is delivered only if its title or brand contains every word of your keywords (case, accents and simple plurals ignored; a number such as <code>530</code> also matches inside <code>MR530SG</code>). Dropped listings are never charged and are counted as <code>filteredOut</code> in the run report. Parts of a search that are almost all unrelated are not read further. Turn it off to get exactly what Vinted returns. Applies to keyword searches, and to the keyword of a pasted URL.

## `splitBeyondLimit` (type: `boolean`):

Vinted shows 960 items at most per search. When a search reaches it, the actor splits it by category, price, condition and colour until every part is under 960. Turn it off to read the first 960 only (fewer requests).

## `includeDetails` (type: `boolean`):

Opens every item to add the full description, brand id, category, colour, material, posting time, the seller's login, review count and reputation, and whether it can be bought. One extra request per item, charged at the higher <i>item with details</i> price. Items whose page is gone are delivered without details and charged the plain price.

## `newOnly` (type: `boolean`):

Remembers which items it already delivered for these exact searches and returns only the new ones on the next run, reading the newest pages until it meets known items. Items already delivered are not charged again. Schedule it hourly or daily.

## `registryKey` (type: `string`):

Name your monitoring memory to keep several independent watches on the same search, or to change the search without losing history. Empty = one memory per distinct set of searches.

## `webhookUrl` (type: `string`):

Receives a JSON summary (status, articles delivered, searches, failed searches, run id, dataset id) when the run ends. Slack, Discord, Zapier and Make URLs work. Never logged.

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

Number of parallel connections, each on its own IP, used with a proxy. Without a proxy the run has one IP and reads one request at a time. Vinted answers about 30 requests a minute per IP, so each connection is paced.

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

Default: Apify datacenter proxy, a new IP whenever Vinted refuses one (about 5 % of requests get an HTTP 403 and are replayed). It reads about 3,500 items a minute on 16 connections for roughly $0.006 per 1,000 items all included. Residential works too but costs about $0.14 per 1,000 items in proxy traffic. Without any proxy the run has one IP and reads about 30 requests a minute.

## Actor input object example

```json
{
  "searchQueries": [
    "nike"
  ],
  "countries": [
    "fr"
  ],
  "maxItems": 50,
  "strictMatch": true,
  "splitBeyondLimit": true,
  "includeDetails": false,
  "newOnly": false,
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `articles` (type: `string`):

One row per item

## `dataset` (type: `string`):

Every item with all fields

## `report` (type: `string`):

Per search: announced total (Vinted's count), cells read, items read, items filtered out by the keyword filter, items delivered, off-topic parts skipped, cells still truncated

# 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"
    ],
    "countries": [
        "fr"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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"],
    "countries": ["fr"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/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 '{
  "searchQueries": [
    "nike"
  ],
  "countries": [
    "fr"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/vinted-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/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 <APIFY_API_TOKEN>` 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/F5Csm30n6RnuIrfol/builds/lsRdhDa1CmiY13f06/openapi.json
