# Vinted Search Scraper (`apt_marble/vinted-search-scraper`) Actor

Search Vinted by keyword across market domains, catalogs and brands, and collect matching items with titles, prices, brands, sizes, sellers, photos, dates and links.

- **URL**: https://apify.com/apt\_marble/vinted-search-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 search items

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Vinted Search Scraper

Search all of Vinted by keyword — across market domains, catalogs and brands — and get every matching item back as clean, structured data. Enter keywords like `nike` or `levis 501`, pick your markets (`fr`, `de`, `es`, `it`, `co.uk` and more), narrow by catalog or brand, set a price range, and receive a row for each item with its title, price, brand, size, condition, seller, photo, location and a direct link. Collect anywhere from a handful of results to a 5,000-row multi-market export. Built for resellers, second-hand deal hunters, market researchers and sales teams who need Vinted listings as data: track prices across countries, spot underpriced items fast, watch brands daily, and build inventory lists without opening a single item page by hand.

### What you can do with it

- **Search every market at once** — run one keyword across France, Germany, Spain, Italy, the UK and more in a single run, with the market labeled on every row.
- **Filter by catalog and brand** — focus on a clothing catalog or a single brand ID, or search everything at once.
- **Stay inside a price band** — set a minimum and maximum price to surface only items in your budget.
- **Catch new items first** — sort newest-first and re-run on a schedule to spot fresh listings before anyone else.
- **Find the cheapest deals** — sort by price to surface the lowest-priced items for any keyword.
- **Build inventory and lead lists** — export titles, prices, brands, sizes, sellers, photos and links straight into a spreadsheet or pipeline.
- **Watch a market over time** — re-run daily or weekly and compare datasets to track prices, supply and demand.

### What you get

One row per item. Abridged sample of a single result:

```json
{
  "itemId": "4123456789",
  "title": "Nike Air Force 1 blanches - taille 38",
  "url": "https://www.vinted.fr/items/4123456789-nike-air-force-1-blanches-taille-38",
  "photo": "https://images1.vinted.net/t/01_00abc/328x245.jpg",
  "price": 35,
  "currency": "EUR",
  "brand": "Nike",
  "size": "38",
  "status": "Very good",
  "city": "Paris",
  "sellerLogin": "modeuse75",
  "sellerId": "12345678",
  "postedDate": "2026-09-01T14:32:00.000Z"
}
```

Each row keeps the item's main photo, its brand and size where shown, the seller's name, and the exact date it was posted. Where an item omits a field — no size, no photo, no city — the actor leaves it empty rather than guessing.

### Input reference

| Setting | Type | Default | What it does |
| --- | --- | --- | --- |
| Search keywords | list of text | — | Keywords to search for, e.g. `["nike", "levis 501"]`. One search runs per keyword, in every market domain. Leave empty to list the newest items with no keyword filter. |
| Market domains | list of text | `fr` | Market domain suffixes to search: `fr`, `de`, `es`, `it`, `co.uk`, `com`, `pl`, `nl` and other Vinted markets. |
| Catalog IDs | list of text | — | Catalog (category) numeric IDs to filter by, e.g. `1242`. Leave empty for all catalogs. |
| Brand IDs | list of text | — | Brand numeric IDs to filter by, e.g. `53`. Leave empty for all brands. |
| Min price | number | — | Minimum item price in the market currency. Leave empty for no lower bound. |
| Max price | number | — | Maximum item price in the market currency. Leave empty for no upper bound. |
| Sort | choice | `newest_first` | `newest_first` (newest first), `price_low_to_high` (cheapest first), `price_high_to_low` (priciest first), or `relevance`. |
| Max items | whole number | `200` | How many items to collect. The actor works through the result pages automatically until this number is reached or the results run out. Maximum 5,000. |

Provide at least a market domain (it has a default, so a run works out of the box); add keywords to narrow the results.

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `itemId` | text | The item's numeric ID. |
| `title` | text | Item title as shown to readers. |
| `url` | text | Direct link to the item. |
| `photo` | text | The item's main photo, when it has one. |
| `price` | number | Asking price, when listed. |
| `currency` | text | Currency code of the market, e.g. `EUR`. |
| `brand` | text | Brand name, when shown. |
| `size` | text | Size label, when shown. |
| `status` | text | Condition status, when shown. |
| `city` | text | Seller city or location, when shown. |
| `sellerLogin` | text | Seller's public username. |
| `sellerId` | text | Seller's numeric ID. |
| `postedDate` | text | Date and time the item was published, in ISO format. |
| `query` | text | Keyword that produced this row (empty for unfiltered recent lists). |
| `rank` | number | Position of the item in its search results. |

### Example use cases

- **Reseller deal flow** — search `burberry trench` across five markets, cheapest-first, every morning; message sellers on the standout rows.
- **Brand watch** — filter one brand ID newest-first on a daily schedule and track what appears, at what price.
- **Price research** — pull 2,000 rows for `levis 501` across several markets and compare asking prices by country.
- **Size hunt** — search a model plus your size in a price band and export fresh matches with links weekly.
- **Market sizing** — count items per market and brand for a product niche to see where supply concentrates.

### Pricing

You pay per result, with no monthly minimum.

| What you are charged for | Price |
| --- | --- |
| Search item — one item added to your dataset | **$1.50 per 1,000** |

**Worked example.** A keyword check collecting 2000 items costs 2000 × $0.0015 = **$3.00**.

### Limits & what this actor cannot do

- Titles, prices, photos and availability are a snapshot at the moment of collection; items are edited, reserved or sold constantly.
- The actor returns what Vinted actually serves and reports distinct items only — the same item repeated across pages is returned once.
- Each row carries the search result's single main photo, not the full gallery, and no description text; both live on the item page.
- Where an item omits a field the actor leaves it empty rather than guessing.
- Prices come back in each market's own currency; a figure is never re-labelled into a different currency.
- Speed depends on the size of the job and on Vinted's own response times; no fixed throughput is promised.
- Vinted's terms govern automated access. You are responsible for using the data lawfully and in line with the source site's terms, and for handling any personal data in line with applicable privacy law.

### FAQ

**Do I need a Vinted account?**
No. The actor reads only what Vinted shows publicly in its search results.

**Does it need my login or password?**
No. There is nothing to connect and nothing to configure — enter keywords and press start.

**Which markets can I search?**
Any Vinted market domain suffix (`fr`, `de`, `es`, `it`, `co.uk`, `com`, `pl`, `nl`, …). Mix as many as you like in one run.

**How many items can I get in one run?**
Up to 5,000 per run. If a search holds more than that, split it with narrower keywords or fewer markets per run.

**Why are some fields empty?**
Because the item did not show them. The actor reports exactly what the search carries — an empty field means "not shown", never a failed guess.

**Can I get full descriptions and all photos?**
Not from search results — they carry one photo and no description. Feed the item links from any run into an item-details scraper for the complete record.

**Can I schedule it?**
Yes. Schedule it hourly, daily or weekly, and each run writes a fresh dataset you can compare against the last — ideal for tracking prices, new items and supply over time.

**Is the data complete?**
It is complete for everything Vinted shows openly in its search results. The actor reports distinct items rather than the shifting estimate of the total, and leaves unshown fields empty instead of inventing them.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search for, e.g. "nike" or "levis 501". One search is run per keyword, in every market domain. Leave empty to list the newest items without a keyword filter.

## `domains` (type: `array`):

Vinted market domain suffixes to search, e.g. fr, de, es, it, co.uk, com, pl, nl. One search is run per domain.

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

Vinted catalog (category) numeric IDs to filter by, e.g. 1242 for a clothing catalog. Leave empty for all catalogs.

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

Vinted brand numeric IDs to filter by, e.g. 53 for Nike. Leave empty for all brands.

## `minPrice` (type: `number`):

Minimum item price in the market currency. Leave empty for no lower bound.

## `maxPrice` (type: `number`):

Maximum item price in the market currency. Leave empty for no upper bound.

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

Order the results are returned in.

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

Maximum total items to collect across all searches. The actor pages through results automatically until this number is reached or the results run out.

## Actor input object example

```json
{
  "queries": [
    "nike"
  ],
  "domains": [
    "fr",
    "de",
    "es"
  ],
  "catalogIds": [],
  "brandIds": [],
  "order": "newest_first",
  "maxItems": 200
}
```

# Actor output Schema

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

Every row this run produced.

## `runSummary` (type: `string`):

What this run collected, and anything it could not read.

# 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 = {
    "queries": [
        "nike"
    ],
    "domains": [
        "fr",
        "de",
        "es"
    ],
    "catalogIds": [],
    "brandIds": [],
    "order": "newest_first",
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/vinted-search-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 = {
    "queries": ["nike"],
    "domains": [
        "fr",
        "de",
        "es",
    ],
    "catalogIds": [],
    "brandIds": [],
    "order": "newest_first",
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/vinted-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "nike"
  ],
  "domains": [
    "fr",
    "de",
    "es"
  ],
  "catalogIds": [],
  "brandIds": [],
  "order": "newest_first",
  "maxItems": 200
}' |
apify call apt_marble/vinted-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apt_marble/vinted-search-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aSlGE4KKfufJZLtCq/builds/twzjMXzyvBh3JqcTk/openapi.json