# Vinted Scraper - Secondhand Fashion Listings (`jongoose/vinted-scraper`) Actor

Scrape Vinted secondhand-fashion listings into clean structured data - title, price (+ buyer-protection total), brand, size, condition, favourite count, seller and photos. Search by keyword or paste Vinted catalog URLs; works on vinted.com, .co.uk, .de and more. No login or API key.

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

## Pricing

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

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 - Secondhand Fashion Listings

Scrape **Vinted** secondhand & vintage fashion listings into clean, structured data - no Vinted account or API key required. Works across Vinted's regional sites (vinted.com, vinted.co.uk, vinted.de, vinted.fr, and more).

### What you get (per listing)
- **Item id** and canonical listing **URL**
- **Title**
- **Price** (`amount` + `currency`), plus **`totalItemPrice`** (price incl. Vinted Buyer Protection) and the **`serviceFee`**
- **Brand**, **size**, and **condition** (New with tags / New without tags / Very good / Good / Satisfactory)
- **Favourite count**, view count and promoted flag
- **Seller** login, id, profile URL and business-seller flag
- **Photos** - primary `photoUrl` plus the full `photoUrls` list

#### Full field list
`id`, `title`, `url`, `price`, `currency`, `totalItemPrice`, `serviceFee`, `brand`, `size`, `condition`, `status`, `favouriteCount`, `isFavourite`, `viewCount`, `isPromoted`, `sellerLogin`, `sellerId`, `sellerProfileUrl`, `isBusinessSeller`, `photoUrl`, `photoUrls`, `path`, `scrapedFrom`.

### Input
- **Search keyword** - a term such as `nike`, `carhartt jacket`, or `y2k jeans`. The simplest way to pull a full, paginated result set.
- **Vinted catalog / search URLs** - build a filtered search on any Vinted site (category, brand, size, price, condition, sort order...) and paste the result URL(s). Every filter in the URL is forwarded to Vinted's catalog API and paginated in full. Each URL keeps its own regional host.
- **Domain / region** - which Vinted site to search when using the keyword (default `vinted.com`).
- **Max listings** caps the run. (Vinted itself caps deep pagination at roughly 960 results per individual search.)
- **Proxy** - Vinted rate-limits datacenter IPs, so the actor uses Apify **Residential** proxy by default.

#### Example input
```json
{
  "searchText": "carhartt jacket",
  "domain": "vinted.co.uk",
  "maxItems": 200,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

Or drive it from a filtered catalog URL:

```json
{
  "startUrls": [{ "url": "https://www.vinted.com/catalog?search_text=nike&price_to=50&order=newest_first" }],
  "maxItems": 500
}
```

#### Example output (one record)

```json
{
  "id": 9200043363,
  "title": "Nike Court Vision Low Men's Leather Lace-Up Sneakers Black/White",
  "url": "https://www.vinted.com/items/9200043363-nike-court-vision-low-mens-sneakers",
  "price": { "amount": 19.99, "currency": "USD" },
  "currency": "USD",
  "totalItemPrice": { "amount": 21.69, "currency": "USD" },
  "serviceFee": { "amount": 1.7, "currency": "USD" },
  "brand": "Nike",
  "size": "7",
  "condition": "Very good",
  "favouriteCount": 5,
  "sellerLogin": "sierrac71",
  "photoUrl": "https://images1.vinted.net/t/.../f800/....jpeg",
  "scrapedFrom": "www.vinted.com"
}
```

### How it works

Vinted's web app is backed by an internal JSON API. This actor reads the **catalog search endpoint** (`/api/v2/catalog/items`) directly, so every field comes from one clean response - there are **no per-listing detail requests** (fast + cheap), and pagination follows Vinted's real `page` parameter.

A cold call to that endpoint returns **HTTP 401** (`invalid_authentication_token`) because it needs the anonymous `access_token_web` cookie a normal page view sets. The actor handles this by first **GETting the region homepage** on a persistent browser-impersonating session (which seeds that cookie plus Cloudflare's `__cf_bm`), then calling the API on the **same session** so the cookies ride along. If the token is ever rejected mid-crawl, the actor automatically **re-primes** it on a fresh proxy IP and retries.

- **Durable:** parses structured JSON, not brittle CSS selectors.
- **Multi-region:** one actor covers every Vinted marketplace.
- Export as JSON, CSV, Excel, or pull via the Apify API.

Great for resellers and analysts doing **pricing intelligence, brand & trend monitoring, and secondhand-market research**. This is **public marketplace data for research; it is not a consumer report and must not be used for FCRA-covered purposes.**

# Actor input Schema

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

Search term to scrape, e.g. `nike`, `carhartt jacket`, `y2k jeans`. The simplest way to pull a full, paginated result set from the chosen domain. Used when no Start URL is given.

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

One or more Vinted catalog or search URLs. Build a filtered search on any Vinted site (keyword, category, brand, size, price, condition, order...) and paste the URL(s) here - every filter in the URL is forwarded to Vinted's catalog API and paginated in full. A URL keeps its own regional host (e.g. vinted.co.uk). Leave empty to use the Search keyword above.

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

Which regional Vinted site to search when using the Search keyword. Pasted Start URLs keep their own host.

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

Stop after collecting this many listings. Note Vinted caps deep pagination at roughly 960 results per individual search.

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

Vinted rate-limits datacenter IPs, so this actor uses Apify Residential proxy by default. Keep residential for reliable results.

## Actor input object example

```json
{
  "searchText": "carhartt jacket",
  "startUrls": [],
  "domain": "vinted.com",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchText": "nike",
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("jongoose/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 = {
    "searchText": "nike",
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("jongoose/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 '{
  "searchText": "nike",
  "startUrls": []
}' |
apify call jongoose/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper - Secondhand Fashion Listings",
        "description": "Scrape Vinted secondhand-fashion listings into clean structured data - title, price (+ buyer-protection total), brand, size, condition, favourite count, seller and photos. Search by keyword or paste Vinted catalog URLs; works on vinted.com, .co.uk, .de and more. No login or API key.",
        "version": "0.1",
        "x-build-id": "EP4rBS06qyzTkCq2K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jongoose~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jongoose-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/jongoose~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jongoose-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/jongoose~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jongoose-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": {
                    "searchText": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Search term to scrape, e.g. `nike`, `carhartt jacket`, `y2k jeans`. The simplest way to pull a full, paginated result set from the chosen domain. Used when no Start URL is given."
                    },
                    "startUrls": {
                        "title": "Vinted catalog / search URLs",
                        "type": "array",
                        "description": "One or more Vinted catalog or search URLs. Build a filtered search on any Vinted site (keyword, category, brand, size, price, condition, order...) and paste the URL(s) here - every filter in the URL is forwarded to Vinted's catalog API and paginated in full. A URL keeps its own regional host (e.g. vinted.co.uk). Leave empty to use the Search keyword above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domain": {
                        "title": "Vinted domain / region",
                        "enum": [
                            "vinted.com",
                            "vinted.co.uk",
                            "vinted.de",
                            "vinted.fr",
                            "vinted.es",
                            "vinted.it",
                            "vinted.nl",
                            "vinted.be",
                            "vinted.pl",
                            "vinted.cz",
                            "vinted.at",
                            "vinted.pt",
                            "vinted.lt",
                            "vinted.se",
                            "vinted.sk",
                            "vinted.ro",
                            "vinted.hu"
                        ],
                        "type": "string",
                        "description": "Which regional Vinted site to search when using the Search keyword. Pasted Start URLs keep their own host.",
                        "default": "vinted.com"
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after collecting this many listings. Note Vinted caps deep pagination at roughly 960 results per individual search.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Vinted rate-limits datacenter IPs, so this actor uses Apify Residential proxy by default. Keep residential for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
