# Vinted Products Crawler (`alkausari_mujahid/vinted-products-crawler`) Actor

Scrape Vinted catalog pages and extract detailed product data: title, price, size, condition, brand, color, description, seller info, images, shipping, and more. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/alkausari\_mujahid/vinted-products-crawler.md
- **Developed by:** [Alkausari M](https://apify.com/alkausari_mujahid) (community)
- **Categories:** E-commerce, Integrations, Automation
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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 Products Scraper

Extract **detailed product listings from [Vinted](https://www.vinted.com)** — prices, conditions, brands, sizes, seller profiles, images, and more — from any catalog or search results page. No browser required: runs on fast HTTP crawling and delivers clean, structured JSON output ready for analysis, price monitoring, or resale research.

### What does Vinted Products Scraper do?

This Actor accepts any Vinted catalog URL (search results, category pages, brand filters, etc.), paginates through the specified page range, visits each product detail page, and extracts a rich set of structured data per listing. Results are saved to an Apify dataset and can be downloaded as JSON, CSV, or Excel.

### Why use Vinted Products Scraper?

- **Price monitoring** — track second-hand sneaker prices, clothing trends, or specific brands over time
- **Resale research** — find underpriced items by comparing condition, brand, and price across listings
- **Market analysis** — understand what sells, at what price, and in what condition on Vinted
- **Inventory sourcing** — build feeds of specific categories or brands for resale platforms
- **Academic & data science** — collect labelled second-hand fashion datasets at scale

### How to use Vinted Products Scraper

1. Open [Vinted](https://www.vinted.com) and navigate to any catalog or search results page (apply filters for category, brand, size, price, condition, etc.)
2. Copy the URL from your browser (e.g. `https://www.vinted.com/catalog?catalog[]=2632&brand_ids[]=172724`)
3. Paste it into the **Start URLs** field in the Actor input
4. Set the **Start Page** and **End Page** to control how many catalog pages to crawl
5. Optionally enable **Apify Proxy** (recommended for higher success rates)
6. Click **Start** and wait for results to appear in the **Output** tab
7. Download your dataset as JSON, CSV, Excel, or access it via the Apify API

### Input

Configure the Actor using the **Input** tab in Apify Console, or pass a JSON object via the API.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | array | Yes | — | One or more Vinted catalog or search URLs to scrape |
| `startPageNum` | integer | No | `1` | First catalog page to scrape |
| `endPageNum` | integer | No | `3` | Last catalog page to scrape (inclusive) |
| `maxRequestsPerCrawl` | integer | No | `100` | Hard cap on total HTTP requests. Set `0` for unlimited |
| `proxyConfiguration` | object | No | disabled | Apify Proxy settings. Residential proxies are recommended for Vinted |

**Example input:**

```json
{
  "startUrls": [
    { "url": "https://www.vinted.com/catalog?catalog[]=2632&order=newest_first" }
  ],
  "startPageNum": 1,
  "endPageNum": 5,
  "maxRequestsPerCrawl": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### Output

Each scraped product is saved as one JSON object in the default dataset. All fields are always present — missing data appears as `null` for consistent schema. You can download the dataset in various formats such as JSON, CSV, Excel, or XML from the **Storage** tab or via the Apify API.

**Example output item:**

```json
{
  "url": "https://www.vinted.com/items/8637599768-pastel-sambas",
  "scrapedAt": "2026-04-28T10:14:32.000Z",
  "title": "Pastel Sambas",
  "price": "$75.00",
  "totalPrice": "$79.45",
  "size": "9",
  "condition": "New with tags",
  "brand": "adidas",
  "brandUrl": "https://www.vinted.com/brand/14-adidas",
  "color": "Beige, Lilac",
  "description": "BRAND NEW WITH BOX. Typical Samba fit for size reference.",
  "uploaded": "a week ago",
  "seller": "pre-ownedchic",
  "sellerProfileUrl": "https://www.vinted.com/member/3147450761",
  "sellerRating": 5,
  "sellerRatingCount": 6,
  "sellerBadges": ["Frequent Uploads", "Speedy Shipping"],
  "sellerLocation": "New York, United States",
  "sellerLastSeen": "Last seen an hour ago",
  "favorites": 12,
  "images": [
    "https://images1.vinted.net/t/05_024eb_.../f800/1777322013.webp"
  ],
  "shippingPrice": "from $0.00",
  "freeShipping": true,
  "material": null,
  "measurements": null
}
```

### Data fields

| Field | Type | Description |
|---|---|---|
| `url` | string | Direct URL to the product listing |
| `scrapedAt` | string | ISO 8601 timestamp of when the item was scraped |
| `title` | string | Product title as listed by the seller |
| `price` | string | Seller's asking price (before Buyer Protection fee) |
| `totalPrice` | string | Total price including Buyer Protection fee |
| `size` | string | Item size (e.g. `9`, `M`, `EU 42`) |
| `condition` | string | Condition label (e.g. `New with tags`, `Very good`, `Satisfactory`) |
| `brand` | string | Brand name |
| `brandUrl` | string | Link to the brand's catalog page on Vinted |
| `color` | string | Color(s) as listed by the seller |
| `description` | string | Full seller-written item description |
| `uploaded` | string | Relative upload time (e.g. `2 hours ago`, `a week ago`) |
| `seller` | string | Seller's username |
| `sellerProfileUrl` | string | Link to the seller's Vinted profile page |
| `sellerRating` | number | Seller's average rating out of 5 |
| `sellerRatingCount` | number | Total number of ratings the seller has received |
| `sellerBadges` | array | Trust badges awarded by Vinted (e.g. `Speedy Shipping`, `Frequent Uploads`) |
| `sellerLocation` | string | Seller's listed city/country |
| `sellerLastSeen` | string | When the seller was last active on Vinted |
| `favorites` | number | Number of users who have favorited the listing |
| `images` | array | Up to 9 product image URLs from Vinted's CDN |
| `shippingPrice` | string | Displayed shipping cost (e.g. `from $3.50`) |
| `freeShipping` | boolean | `true` if the item ships for free |
| `material` | string | Material(s) listed for the item (when provided by seller) |
| `measurements` | string | Measurements listed by the seller (when provided) |

### Pricing / Cost estimation

This Actor uses fast HTTP-based crawling (no browser), keeping compute costs very low.

| Pages crawled | ~Items scraped | Approx. compute units |
|---|---|---|
| 3 | ~90 | < 0.05 CU |
| 10 | ~300 | ~0.15 CU |
| 50 | ~1,500 | ~0.75 CU |

The Apify free tier includes enough compute units to scrape thousands of listings per month at no cost.

> Enabling residential proxies adds a small cost per request but significantly improves success rates on Vinted.

### Tips and advanced options

- **Filter before you scrape** — apply every filter Vinted offers (brand, category, size, price range, condition, country) before copying the URL. The Actor respects all query parameters.
- **Each catalog page holds ~32 items** — plan your `startPageNum`/`endPageNum` range accordingly.
- **Use proxies for large runs** — Vinted rate-limits scrapers. Apify Residential proxies are strongly recommended for runs larger than 3–5 pages.
- **Schedule recurring runs** — use the Apify Scheduler to monitor new listings on a saved search URL daily or hourly without any code.
- **Export to Google Sheets or Slack** — use Apify's built-in integrations to automatically forward results downstream without writing any glue code.
- **Combine multiple URLs** — add several start URLs (different categories or brands) in a single run to merge results into one dataset.

### FAQ, disclaimers, and support

**Is scraping Vinted legal?**
This Actor only collects publicly visible listing data — the same information any visitor sees in their browser without logging in. Always ensure your use complies with Vinted's Terms of Service and applicable data protection laws. Do not use scraped data to contact sellers unsolicited or to store personal data beyond what is permitted.

**Why are some fields `null`?**
Not every listing includes every attribute. Material, measurements, and favorites are optional fields that sellers may leave blank. All keys are always present in the output for a consistent schema — missing values appear as `null`.

**The Actor got blocked or returns no results — what should I do?**
Enable Apify Proxy with the `RESIDENTIAL` group in the proxy configuration input. This routes requests through real residential IP addresses that Vinted is far less likely to block.

**Can I scrape a specific brand, category, or size?**
Yes. Apply the desired filters on Vinted, copy the resulting URL, and use it as a start URL. All active filters are encoded in the URL and the Actor fully honours them.

**I need a custom feature or integration.**
Open a ticket in the [Issues tab](../../issues) or contact the Actor author directly for custom development.

# Actor input Schema

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

Vinted catalog URLs to scrape (e.g. search/filter result pages).

## `startPageNum` (type: `integer`):

Page number to start scraping from.

## `endPageNum` (type: `integer`):

Page number to stop scraping at (inclusive).

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

Proxy settings. Enable Apify Proxy for better success rates on Vinted.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.vinted.com/catalog?catalog[]=12&brand_ids[]=172724"
    }
  ],
  "startPageNum": 1,
  "endPageNum": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.vinted.com/catalog?catalog[]=12&brand_ids[]=172724"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alkausari_mujahid/vinted-products-crawler").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": [{ "url": "https://www.vinted.com/catalog?catalog[]=12&brand_ids[]=172724" }] }

# Run the Actor and wait for it to finish
run = client.actor("alkausari_mujahid/vinted-products-crawler").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": [
    {
      "url": "https://www.vinted.com/catalog?catalog[]=12&brand_ids[]=172724"
    }
  ]
}' |
apify call alkausari_mujahid/vinted-products-crawler --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Products Crawler",
        "description": "Scrape Vinted catalog pages and extract detailed product data: title, price, size, condition, brand, color, description, seller info, images, shipping, and more. Export to JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "F2vFUf6mAJagdbLgt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alkausari_mujahid~vinted-products-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alkausari_mujahid-vinted-products-crawler",
                "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/alkausari_mujahid~vinted-products-crawler/runs": {
            "post": {
                "operationId": "runs-sync-alkausari_mujahid-vinted-products-crawler",
                "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/alkausari_mujahid~vinted-products-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-alkausari_mujahid-vinted-products-crawler",
                "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": "Start URLs",
                        "type": "array",
                        "description": "Vinted catalog URLs to scrape (e.g. search/filter result pages).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "startPageNum": {
                        "title": "Start Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Page number to start scraping from.",
                        "default": 1
                    },
                    "endPageNum": {
                        "title": "End Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Page number to stop scraping at (inclusive).",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Enable Apify Proxy for better success rates on Vinted.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
