# Vinted Universal Scraper (`scrapifier/vinted-universal-scraper`) Actor

⚡ Scrape Vinted by filters or just by pasting a URL! Search any keyword; filter by brand, category, size, colour, condition, price & currency on any Vinted country. Enrich items with the seller's profile, beat the 960-per-search cap with deep scrape, export clean data with photos — CSV/JSON/Excel.

- **URL**: https://apify.com/scrapifier/vinted-universal-scraper.md
- **Developed by:** [Scrapifier](https://apify.com/scrapifier) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.02 / 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Scrape second-hand fashion listings from Vinted by keyword, brand, category or Vinted URL and export them as JSON, CSV or Excel, or pull them straight from the API.

⚡ For every listing you get the **title, price and total price with Buyer Protection**, the **brand, size and condition**, favourites and views, swap and promoted flags, **all photos in full size**, the seller's login and profile link, and optionally the **seller's full profile** (feedback, city, country, items, followers, last seen). **Server-side filters**, **any Vinted country site** (23 domains), **no login, no cookies**, and you **pay per listing**.

[![Apify Actor](https://apify.com/actor-badge?actor=scrapifier/vinted-universal-scraper)](https://apify.com/scrapifier/vinted-universal-scraper)

### 🎯 Why scrape Vinted listings?

- **Price monitoring and resale**: follow the asking prices of a brand or a category across countries to spot underpriced items and set your own resale prices.
- **Market research**: measure how many listings a brand has, in which condition and at which price points, and how favourites and views are spread.
- **Sourcing for second-hand shops**: pull every listing under a price cap for a keyword or a category, newest first, and review them in a spreadsheet.
- **Seller analysis**: with seller details on, rank sellers by feedback count, reputation, number of items or followers to find professional sellers.
- **Research and data science**: build datasets of second-hand prices, photos and conditions for pricing models and trend analysis.

### 📊 What data does Vinted Scraper extract?

| Field | Description |
|---|---|
| `id` | Unique Vinted item id |
| `url` | Direct link to the item on Vinted |
| `title` | Listing title |
| `price`, `currency` | Seller's asking price and ISO currency code |
| `total_price`, `service_fee` | Total price including the Buyer Protection fee, and the fee itself |
| `brand` | Brand name |
| `size` | Size label |
| `condition` | Item condition label |
| `is_new_with_tags` | `true` when the item is brand new with tags |
| `favourites`, `views` | Number of favourites (likes) and view count |
| `is_favourite` | Favourited by the current session |
| `is_for_swap` | Seller is open to swap |
| `promoted` | Promoted (paid bump) listing |
| `photo`, `photos[]`, `photo_count` | Main photo URL, all photo URLs (full size) and their number |
| `dominant_color` | Dominant colour of the main photo (hex) |
| `seller.id`, `seller.login`, `seller.profile_url`, `seller.is_business` | Seller identity, always present |
| `seller.city`, `seller.country`, `seller.feedback_count`, `seller.feedback_reputation`, `seller.item_count`, `seller.given_item_count`, `seller.followers_count`, `seller.following_count`, `seller.last_logged_in`, `seller.is_verified` | Seller profile (location, feedback and reputation 0 to 1, items listed and sold, followers, last seen, verified), added with `include_seller_details` |
| `scraped_at` | Extraction timestamp |
| `search_url` | Catalog URL of the Vinted domain the item was searched on |

With `flatten` enabled, `seller_login`, `seller_id` and `photo_url` columns are added (plus `seller_feedback_count` and `seller_feedback_reputation` when seller details are on) so CSV and Excel exports stay flat.

### 🚀 How to scrape Vinted listings

1. Open the Actor and type one or more **keywords** in `search_text`, one per line (`nike air`, `robe zara`), or paste Vinted catalog, brand or category URLs in `urls`. Simplest: set your filters on Vinted, copy the address bar and paste it.
2. Pick the **Vinted country** in `country` (`fr`, `com`, `de`, `it`, `es`, `co.uk` and 17 more); it sets the domain and default currency.
3. Refine with the **filters**: brand names, condition, colour, price range, sort order, swap-only items, or advanced numeric ids (category, brand, size, material).
4. Set **Max results** per keyword or URL. Turn on **Deep scrape** to go past the 960 items a single Vinted search returns, and **Include seller details** for seller profiles.
5. Click **Start**. Items are pushed to the dataset in batches of 200 while the run is going.
6. Open the **Storage** tab to preview the listings and export them as JSON, CSV, Excel or XML, or read them from the dataset API.

The same run can be started from the Apify API, the Python or JavaScript client, or put on a schedule for daily price tracking.

### 📥 Input parameters

| Field | Key | Type | Default | Description |
|---|---|---|---|---|
| Vinted URLs | `urls` | array of URLs | none | Catalog/search URLs (all filters kept), brand URLs (`/brand/53-nike`) or category URLs (`/catalog/1904-women`). Empty = build a search with the filters below. |
| Keywords | `search_text` | array of strings | `["nike"]` | One keyword per line, each searched separately (bulk). Empty = the whole category. |
| Vinted country | `country` | select of 23 options | `fr` | Marketplace to search (`fr`, `com`, `de`, `it`, `es`, `co.uk`, `be`, `nl`, `pl` and 14 more). Sets the domain and default currency. |
| Brands (by name) | `brands` | array of strings | none | Brand names (`Nike`, `Zara`, `Levi's`), resolved automatically to Vinted brand ids. |
| Condition | `conditions` | multi-select | none | `6` New with tags, `1` New without tags, `2` Very good, `3` Good, `4` Satisfactory, `7` Not fully functional. Empty = any. |
| Colour | `colors` | multi-select of 29 options | none | One or more Vinted colour ids (`1` Black, `12` White, `9` Blue, `7` Red...). Empty = any. |
| Min price | `price_from` | integer | none | Lowest price to include, in the selected country's currency. |
| Max price | `price_to` | integer | none | Highest price to include. |
| Sort by | `order` | select | `newest_first` | `newest_first`, `relevance`, `price_low_to_high` or `price_high_to_low`. |
| Swap-only items | `only_swappable` | boolean | `false` | Only items the seller is open to swapping. |
| Category IDs (advanced) | `catalog_ids` | array of strings | none | Vinted category ids (`1904` = Women, `5` = Men). Empty = all categories. |
| Brand IDs (advanced) | `brand_ids` | array of strings | none | Exact Vinted brand ids (`53` = Nike, `2703` = Jordan). Combined with `brands`. |
| Size IDs (advanced) | `sizes` | array of strings | none | Vinted size ids. They depend on the category, get them from a filtered catalog URL. |
| Material IDs (advanced) | `material_ids` | array of strings | none | Vinted material ids (cotton, leather...), from a filtered catalog URL. |
| Currency override (advanced) | `currency` | string | none | ISO currency code (`EUR`, `GBP`). Defaults to the selected country's currency. |
| Max results | `max_results` | integer | `100` | Items to collect per keyword or per URL. `0` = as many as possible. A single search reaches up to 960. |
| Deep scrape (beyond 960) | `deep_scrape` | boolean | `false` | Split each search into price windows to collect far more than the 960-item cap. |
| Include seller details (slower) | `include_seller_details` | boolean | `false` | Add each seller's profile (feedback, city, country, items, followers, last seen) to every item. |
| Flat columns (CSV-friendly) | `flatten` | boolean | `false` | Add flat `seller_login`, `seller_id` and `photo_url` columns for CSV and Excel. |
| Report empty searches | `emit_input_status` | boolean | `true` | Add an `input_status` report to the run's OUTPUT record. |
| Proxy | `proxyConfiguration` | object | `{"useApifyProxy": true}` | Apify Proxy is on by default. Residential proxies are recommended for large runs and let you pick the country. |

Example input:

```json
{
  "search_text": ["nike"],
  "country": "fr",
  "brands": ["Nike"],
  "conditions": ["6"],
  "price_from": 10,
  "price_to": 60,
  "order": "newest_first",
  "max_results": 200,
  "include_seller_details": true
}
```

Pasted URLs are parsed for their query filters (keyword, category, brand, colour, size, condition, material, price, currency, order, swap) and for `/brand/<id>` and `/catalog/<id>` paths; the search itself runs on the domain selected in `country`, so set it to match the URL you paste. Brand names Vinted does not recognise are skipped with a warning; use `brand_ids` for exact control.

### 📤 Output example

Each listing is one dataset item, exportable as JSON, CSV, Excel or via the API.

```json
{
  "id": 9453626155,
  "url": "https://www.vinted.fr/items/9453626155-nike-w-ld1000",
  "title": "Nike W LD_1000",
  "price": 45.0,
  "currency": "EUR",
  "total_price": 46.85,
  "service_fee": 1.85,
  "brand": "Nike",
  "size": "39",
  "condition": "New with tags",
  "is_new_with_tags": true,
  "favourites": 3,
  "views": 41,
  "is_for_swap": false,
  "photo": "https://images1.vinted.net/.../f800/....jpeg",
  "photos": ["https://images1.vinted.net/...", "..."],
  "dominant_color": "#1467B7",
  "seller": {
    "login": "jornas59",
    "profile_url": "https://www.vinted.fr/member/26154389-jornas59",
    "is_business": false,
    "city": "Napoli",
    "country": "Italia",
    "feedback_count": 23,
    "feedback_reputation": 1.0,
    "item_count": 60,
    "followers_count": 12
  },
  "scraped_at": "2026-07-21 14:58:00"
}
```

The run's OUTPUT record also holds the run statistics (searches, unique items, duplicates, pages, errors, sellers enriched) and, per keyword or URL, an `input_status` entry (`ok` or `empty` with the item count) so you can see at a glance which search produced nothing.

### 💡 Ready-to-run examples

**New-with-tags Nike items between 10 and 60 EUR, with seller profiles**

```json
{ "search_text": ["nike"], "country": "fr", "brands": ["Nike"], "conditions": ["6"], "price_from": 10, "price_to": 60, "order": "newest_first", "max_results": 200, "include_seller_details": true }
```

**A whole brand page from its URL, beyond the 960 cap**

```json
{ "urls": ["https://www.vinted.fr/brand/53-nike"], "country": "fr", "deep_scrape": true, "max_results": 0 }
```

**A whole category with no keyword**

```json
{ "country": "fr", "catalog_ids": ["1904"], "deep_scrape": true, "max_results": 0 }
```

**Cheapest vintage jackets on the international site (USD)**

```json
{ "search_text": ["vintage jacket"], "country": "com", "order": "price_low_to_high", "max_results": 100 }
```

### 💰 Pricing: how much does it cost to scrape Vinted?

From **$1.50 per 1,000 listings** on the free plan, with automatic volume discounts down to **$1.02 per 1,000** on higher Apify plans. You pay only for the results you receive, there is no subscription and no start fee. New Apify accounts get free monthly platform credits to try it.

Cost is driven purely by the number of listings returned: `max_results` caps each keyword or URL (five keywords at `100` can return up to 500 items), and price, condition, colour or brand filters narrow the set on Vinted's side before you pay for it. Seller enrichment adds runtime, not billed items.

### ⚙️ Performance, proxies and limits

- **How it works**: the Actor opens an anonymous session on the selected Vinted domain, then reads Vinted's public JSON API (`api/v2/catalog/items`), 96 items per page. No login, no cookies to paste.
- **Proxy**: Apify Proxy is on by default. For large or frequent runs, Apify Residential proxies work best and let you pick the country. On an HTTP 401, 403, 419, 429 or 5xx response the Actor opens a fresh session (rotating the proxy IP) and retries, up to 5 attempts per request.
- **The 960 cap**: Vinted returns at most 10 pages of 96 items per query. **Deep scrape** splits each search into 15 ascending price windows (0 to 5, 5 to 10, up to 500 to 1000 and above 1000, clipped to your `price_from` and `price_to`), each fetching up to 960 items.
- **Max results per search**: `max_results` applies to each keyword or URL separately. `0` collects everything reachable.
- **Deduplication**: items are deduplicated by `id` within a run, across keywords and price windows. Duplicates are counted in the OUTPUT stats.
- **Seller details**: one extra API call per distinct seller (cached within the run), so enriched runs are slower.
- **Streaming**: items are pushed to the dataset in batches of 200, so partial results are available during the run.
- **Empty searches**: a keyword or URL that matches nothing yields `status: "empty"` in the `input_status` report.

### 🔌 Integrations and API

Run Vinted Scraper from the [Apify API](https://docs.apify.com/api/v2), the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or on a [schedule](https://docs.apify.com/platform/schedules). Connect it to Make, Zapier, n8n, Google Sheets, Slack or any webhook through [Apify integrations](https://apify.com/integrations). Every run's dataset is available as JSON, CSV, Excel or XML from the dataset API.

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapifier~vinted-universal-scraper/run-sync-get-dataset-items?token=%3CYOUR_TOKEN%3E" \
  -H "Content-Type: application/json" \
  -d '{ "search_text": ["nike"], "country": "fr", "conditions": ["6"], "price_to": 60, "max_results": 100 }'
```

### ❓ FAQ

**Is it legal to scrape Vinted?**

The Actor only reads listings that Vinted shows to anyone without logging in. Seller profiles contain personal data (login, city, country), so process them in line with GDPR and other privacy laws, respect Vinted's terms of use, and stay responsible for how you use the data. This is not legal advice.

**Do I need a Vinted account, login or cookies?**

No. The Actor creates its own anonymous session on the Vinted domain you select. Nothing to log in to and no cookies to paste.

**Can I export Vinted listings to Excel or Google Sheets?**

Yes. Every run's dataset downloads as CSV, XLSX, JSON or XML from the Storage tab, and the Google Sheets integration can push new listings to a sheet. Turn on `flatten` for flat seller and photo columns.

**How many listings can I scrape?**

One Vinted search stops at 960 items. With `deep_scrape` the query is split into price windows, each capped at 960, so a brand or a category can return thousands of listings. Set `max_results` to `0` for everything reachable, or keep a cap to control cost.

**Does it work for Vinted in Germany, the UK, Italy or the US?**

Yes. Pick the marketplace in `country`: 23 domains are supported, including `de`, `co.uk`, `it`, `es`, `pl` and `com` (the international site in USD). Prices come back in that country's currency unless you override `currency`.

**How do I find category, size or material ids?**

Filter on Vinted in your browser, copy the URL from the address bar and paste it in `urls`: the Actor reads the category, size, material, brand, colour and condition ids from it. Category `1904` is Women and `5` is Men; brand `53` is Nike.

**Do I need a proxy, and what if a run is blocked?**

Apify Proxy is enabled by default. For large or frequent runs, switch to Apify Residential proxies and pick the country of the marketplace. When Vinted answers with a rate-limit status, the Actor renews its session and retries up to 5 times before logging an error.

**How fresh is the data?**

Every run queries Vinted live and `scraped_at` records the extraction time. Schedule the Actor with `order` set to `newest_first` for a rolling feed of new listings.

### 🔗 Related scrapers

- [Leboncoin Scraper](https://apify.com/scrapifier/leboncoin-universal-scraper): listings from any Leboncoin search URL.
- [Leboncoin Vehicles Scraper](https://apify.com/scrapifier/leboncoin-universal-scraper-vehicles): cars, motorbikes and vans by filters.
- [Leboncoin Real Estate Scraper](https://apify.com/scrapifier/leboncoin-universal-scraper-real-estate): real-estate listings by filters, no URL needed.
- [Trustpilot Reviews Scraper](https://apify.com/scrapifier/trustpilot-universal-scraper): customer reviews and TrustScores for any company.
- [SeLoger Scraper](https://apify.com/scrapifier/seloger-universal-scraper): real-estate listings from SeLoger.

### 💬 Support

Questions, bugs or a feature request? Open an issue in the **Issues** tab of this Actor, I answer quickly. If Vinted Scraper saves you time, a rating on the Store helps others find it.

# Actor input Schema

## `urls` (type: `array`):

Paste one or more Vinted URLs — a catalog/search URL (all its filters are kept), a brand URL (e.g. /brand/53-nike) or a category URL (e.g. /catalog/1904-women). Leave empty to build a search with the filters below instead.

## `search_text` (type: `array`):

One or more keywords — each is searched separately (bulk), one keyword per line (e.g. "nike air", "robe zara", "vintage jacket"). Do NOT put several keywords on one line. Empty = the whole category.

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

Which Vinted marketplace to search. Sets the domain and default currency.

## `brands` (type: `array`):

Filter by brand name (e.g. Nike, Zara, Levi's) — resolved automatically to Vinted brand IDs. For exact control, use 'Brand IDs' below.

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

Item condition. Empty = any.

## `colors` (type: `array`):

One or more colours. Empty = any.

## `price_from` (type: `integer`):

Lowest price to include (in the selected country's currency).

## `price_to` (type: `integer`):

Highest price to include.

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

Result ordering.

## `only_swappable` (type: `boolean`):

Only items the seller is open to swapping.

## `catalog_ids` (type: `array`):

Vinted category IDs (e.g. 1904 = Women, 5 = Men). Easiest to get by pasting a category URL above. Empty = all categories.

## `brand_ids` (type: `array`):

Exact Vinted brand IDs (e.g. 53 = Nike, 2703 = Jordan). Combined with 'Brands' above.

## `sizes` (type: `array`):

Vinted size IDs (size IDs depend on the category — get them from a filtered catalog URL).

## `material_ids` (type: `array`):

Vinted material IDs (e.g. cotton, leather) — get them from a filtered catalog URL.

## `currency` (type: `string`):

ISO currency code (e.g. EUR, GBP). Defaults to the selected country's currency.

## `max_results` (type: `integer`):

How many items to collect per keyword / per URL (0 = as many as possible). A single search reaches up to 960; turn on 'Deep scrape' to go further.

## `deep_scrape` (type: `boolean`):

A single search returns at most ~960 items. Turn this on to collect far more from the same query.

## `include_seller_details` (type: `boolean`):

Add each seller's profile to every item: feedback score & count, city, country, number of items, followers, last seen. (Slightly slower.)

## `flatten` (type: `boolean`):

Add flat seller\_login / seller\_id / photo\_url columns for CSV/Excel exports.

## `emit_input_status` (type: `boolean`):

Add an input\_status report to the run's OUTPUT record.

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

Recommended for large runs — a proxy (Apify Residential works best) keeps big jobs reliable and lets you pick the country.

## Actor input object example

```json
{
  "search_text": [
    "nike"
  ],
  "country": "fr",
  "order": "newest_first",
  "only_swappable": false,
  "max_results": 100,
  "deep_scrape": false,
  "include_seller_details": false,
  "flatten": false,
  "emit_input_status": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All Vinted items extracted by this run.

# 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 = {
    "search_text": [
        "nike"
    ],
    "max_results": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapifier/vinted-universal-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 = {
    "search_text": ["nike"],
    "max_results": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapifier/vinted-universal-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/gUQvzcaGCNDSM8Zk8/builds/ZlGII99giTvd40xSQ/openapi.json