# 🛍️ Vinted Scraper (`scrapio/vinted-scraper`) Actor

Scrape Vinted listings including product titles, prices, brands, sizes, conditions, seller details, locations, images, favorites, and listing URLs. Perfect for resale market research, price tracking, competitor analysis, inventory monitoring, and trend discovery.

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

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Catalog & Search Extractor

Extract clean, structured product data from any **Vinted** catalog or search page — across **every Vinted country domain** (`.com`, `.co.uk`, `.de`, `.fr`, `.it`, `.es`, `.pl`, …). Just paste a search URL and get back price, brand, size, condition, seller details and image galleries — no login required.

### ✨ Why Choose This Actor?

- **🌍 Works on every Vinted domain** — paste a `.com`, `.de`, `.fr` (or any) catalog URL.
- **🧼 Clean output** — flattened, ready-to-use JSON instead of Vinted's noisy raw API objects.
- **🌐 Smart proxy ladder** — runs proxy-free by default, then auto-escalates to datacenter and residential proxies only if Vinted blocks you. Cheaper and faster than always-on proxies.
- **🛡️ Anti-bot resilient** — browser TLS fingerprinting + exponential-backoff retries with automatic session re-warming.
- **💾 Live results** — items stream into the dataset as they're found; a stopped run still keeps everything collected so far.
- **📦 Bulk-friendly** — feed it many search URLs at once.

### 🔑 Key Features

| Feature | Description |
|---|---|
| 🔗 Bulk URLs | Scrape multiple searches in one run |
| 🎯 Item cap | Limit total items, or fetch the full retrievable window |
| ⏱️ Polite delays | Configurable delay + jitter between requests |
| 🌐 Proxy fallback | direct → datacenter → residential (sticky) |
| 📊 Section views | Overview, Pricing, Seller, Engagement, Media |

### 📥 Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Vinted catalog / search URLs (bulk supported). **Required.** |
| `maxItems` | integer | Max products to collect (`0` = no limit). |
| `requestDelay` | number | Seconds between requests (jitter added). |
| `proxyConfiguration` | object | Apify Proxy settings powering the fallback ladder. |
| `maxPagesPerUrl` | integer | Cap pages fetched per URL (`0` = no cap). |
| `maxRequestRetries` | integer | Retries per blocked request. |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.vinted.com/catalog?search_text=nike&order=newest_first" }
  ],
  "maxItems": 100,
  "requestDelay": 1.0,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

### 📤 Output

Each item is saved in this clean schema:

```json
{
  "id": 9126191763,
  "title": "Born Brown Suede Leather Peep Toe Sandal Booties",
  "price": { "amount": 38, "currency": "USD" },
  "brand": "Born",
  "url": "https://www.vinted.com/items/9126191763-born-...",
  "imageUrl": "https://images1.vinted.net/.../1780965676.jpeg",
  "thumbnails": [
    { "type": "thumb70x100", "url": "https://...", "dimensions": "70x100" }
  ],
  "seller": {
    "id": 277625888,
    "username": "goodnightsuzie",
    "profileUrl": "https://www.vinted.com/member/277625888-goodnightsuzie"
  },
  "size": "8",
  "condition": "New without tags",
  "stats": { "favorites": 1, "views": 0 }
}
```

| Field | Description |
|---|---|
| `id` | Vinted item ID |
| `title` | Listing title |
| `price.amount` / `price.currency` | Numeric price + currency code |
| `brand` | Brand name |
| `url` | Direct listing link |
| `imageUrl` | Main photo |
| `thumbnails` | All thumbnail sizes with dimensions |
| `seller.*` | Seller ID, username, profile URL |
| `size` | Size label |
| `condition` | Item condition |
| `stats.favorites` / `stats.views` | Engagement counters |

### 🚀 How to Use (Apify Console)

1. Log in at <https://console.apify.com> → **Actors**.
2. Open **Vinted Scraper**.
3. Paste one or more Vinted search/catalog URLs into **Vinted Search / Catalog URLs**.
4. (Optional) Set **Maximum Items** and proxy settings.
5. Click **Start** and watch results stream into the log in real time.
6. Open the **Output** tab — switch between the **Overview / Pricing / Seller / Engagement / Media** views.
7. Export to JSON / CSV / XLSX.

### 🤖 Use via API

```bash
curl -X POST "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"startUrls":[{"url":"https://www.vinted.com/catalog?search_text=nike"}],"maxItems":50}'
```

### 💡 Best Use Cases

- 📈 Resale / reselling price research and sourcing.
- 🔎 Brand & competitor monitoring on second-hand marketplaces.
- 📊 Market & trend analysis for specific categories.
- 🗂️ Building product datasets for analytics or ML.

### 💳 Pricing

This Actor uses the **pay-per-event** model. You're billed per **scraped item** plus the standard Apify platform usage. Set a **Maximum Items** value (or a run budget) to control spend — the Actor stops cleanly when your limit is reached.

### ❓ FAQ

**Do I need a Vinted account?** No. The Actor uses Vinted's public catalog data and mints an anonymous session automatically.

**Why did I get fewer items than the search shows?** Vinted caps deep pagination at roughly 360 items per search, even when it advertises more. That's the maximum retrievable window — narrow your search (brand, size, price) to surface different items.

**Which countries are supported?** All of them — paste a URL from any Vinted domain.

**Do I need a proxy?** No. The Actor runs proxy-free and only escalates to datacenter/residential proxies if Vinted blocks the request.

### 🛟 Support & Feedback

Found a bug or want a new field? Open an issue on the Actor's **Issues** tab. Data is collected only from publicly available pages; you are responsible for compliant use (GDPR, CCPA, target ToS).

# Actor input Schema

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

One or more Vinted catalog or search URLs (any domain — .com, .co.uk, .de, .fr, .it …). Example: https://www.vinted.com/catalog?search\_text=nike. Supports bulk input — paste many URLs at once.

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

Maximum number of products to collect across all URLs. Set to 0 for no limit (fetches the full retrievable result window). Note: Vinted caps deep pagination at ~360 items per search.

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

By default the scraper runs WITHOUT a proxy. If Vinted blocks the request, it automatically falls back to a datacenter proxy, and then to a residential proxy (sticking with residential for the rest of the run). Configure Apify Proxy here to power those fallbacks.

## `maxPagesPerUrl` (type: `integer`):

Safety cap on the number of catalog pages fetched per URL. 0 means no cap (stop when results are exhausted).

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed / blocked request (with exponential backoff) before giving up on that page.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.vinted.com/catalog?search_text=shoe%20grandma&order=newest_first"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxPagesPerUrl": 0,
  "maxRequestRetries": 5
}
```

# 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 = {
    "startUrls": [
        "https://www.vinted.com/catalog?search_text=shoe%20grandma&order=newest_first"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapio/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 = {
    "startUrls": ["https://www.vinted.com/catalog?search_text=shoe%20grandma&order=newest_first"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapio/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 '{
  "startUrls": [
    "https://www.vinted.com/catalog?search_text=shoe%20grandma&order=newest_first"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapio/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🛍️ Vinted Scraper",
        "description": "Scrape Vinted listings including product titles, prices, brands, sizes, conditions, seller details, locations, images, favorites, and listing URLs. Perfect for resale market research, price tracking, competitor analysis, inventory monitoring, and trend discovery.",
        "version": "0.1",
        "x-build-id": "9IXHMPbELjmfqOdAE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Vinted Search / Catalog URLs",
                        "type": "array",
                        "description": "One or more Vinted catalog or search URLs (any domain — .com, .co.uk, .de, .fr, .it …). Example: https://www.vinted.com/catalog?search_text=nike. Supports bulk input — paste many URLs at once.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "🎯 Maximum Items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to collect across all URLs. Set to 0 for no limit (fetches the full retrievable result window). Note: Vinted caps deep pagination at ~360 items per search.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy Configuration",
                        "type": "object",
                        "description": "By default the scraper runs WITHOUT a proxy. If Vinted blocks the request, it automatically falls back to a datacenter proxy, and then to a residential proxy (sticking with residential for the rest of the run). Configure Apify Proxy here to power those fallbacks.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxPagesPerUrl": {
                        "title": "📄 Max Pages Per URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety cap on the number of catalog pages fetched per URL. 0 means no cap (stop when results are exhausted).",
                        "default": 0
                    },
                    "maxRequestRetries": {
                        "title": "🔁 Max Request Retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed / blocked request (with exponential backoff) before giving up on that page.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```