# Vinted Scraper: Listings, Prices & Item Details (`thescrapelab/vinted-listings-item-details-scraper`) Actor

Extract public Vinted listings and optional item descriptions, attributes, displayed prices, buyer fees, shipping and seller links across 27 markets.

- **URL**: https://apify.com/thescrapelab/vinted-listings-item-details-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 catalog listings

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Vinted Scraper: Listings, Prices & Item Details

Collect public Vinted listings from keywords, filtered catalog URLs or individual item URLs. Export listing titles, brands, sizes, conditions, images and displayed prices, with optional public descriptions, seller links, buyer protection totals, shipping minimums and explicit sold or reserved labels.

Useful for resale research, inventory sourcing and marketplace price snapshots. No Vinted account or API key is required. This Actor reads public HTML pages and does not call Vinted source APIs.

### Input example and Console run

Enter search keywords and choose countries, or clear keywords and supply catalog/item URLs. Start with three items and inspect the default Dataset. Export JSON, CSV or Excel. The run summary explains limits, empty searches, blocks and failed detail requests.

```json
{
  "keywords": [
    "nike"
  ],
  "countries": [
    "FR"
  ],
  "maxItems": 3,
  "includeDetails": true
}
```

### Countries and input

Configured countries: Austria, Australia, Belgium, Croatia, Czechia, Denmark, Estonia, Finland, France, Germany, Greece, Hungary, Ireland, Italy, Latvia, Lithuania, Luxembourg, Netherlands, Poland, Portugal, Romania, Slovakia, Slovenia, Spain, Sweden, United Kingdom and United States. Country codes are `AT AU BE HR CZ DK EE FI FR DE GR HU IE IT LV LT LU NL PL PT RO SK SI ES SE GB US`. `countries: ["ALL"]` searches all configured markets. Availability can differ by market and proxy; the run summary reports each target's actual outcome.

Use these five main inputs:

| Input | Meaning |
| --- | --- |
| `keywords` | Search terms, one per line. Clear this field for URL-only runs |
| `countries` | Defaults to France; choose `ALL` for all 27 markets |
| `maxItems` | Number of listings to save across the whole run; default 3, maximum 1,000 |
| `includeDetails` | Include descriptions, seller links and price context. Turn off for faster, cheaper price snapshots |
| `startUrls` | Optional public catalog/item URLs; catalog filters and each URL's country are preserved |

Pages, per-search limits and request limits adjust automatically when you change the number of listings. You do not need to coordinate multiple limits. The optional **Proxy settings** section defaults to residential Apify Proxy; standard residential proxy traffic is included in the event prices described below. Custom external proxy services may bill you separately. Most users can leave it unchanged.

For 100 catalog listings, use `{"keywords": ["nike"], "countries": ["FR"], "maxItems": 100, "includeDetails": false}`. For one listing from each market, use `{"keywords": ["nike"], "countries": ["ALL"], "maxItems": 27, "includeDetails": false}`.

Use 1 GB memory, including for multi-market runs. Larger detail requests may produce partial results within the run timeout. Check the run summary before treating a run as complete.

Existing JSON/API integrations can still supply `maxItemsPerTarget` (1–1,000), `maxPagesPerTarget` (1–20), `maxRequests` (1–1,500) or `proxyConfiguration`. Explicit limits take precedence over automatic sizing. These collection overrides are hidden from the form to keep normal runs simple. Setting `proxyConfiguration: {"useApifyProxy": false}` enables direct access, which can be rate limited.

Catalog targets receive turns in rounds. Targets that cannot receive a row under the remaining global cap are not fetched. Direct item URLs always fetch their item page, even when catalog detail enrichment is disabled. Matches across searches are deduplicated, so fewer rows than requested can be a valid result.

### Results

The default **Listings** view shows the title, market, numeric asking price, currency, brand, size, condition and item link. **Item details**, **Price breakdown** and **Coverage and sources** offer descriptions, separated price amounts and diagnostics. Full JSON exports retain every existing field. **Full listing data** preserves the original `overview` view for existing API users.

One row is saved per unique item ID and market. Matches across searches are joined in `sourceReferences`. Prices contain numeric `amount`, ISO `currency` and the original displayed `raw` text.

```json
{
  "itemId": "123",
  "url": "https://www.vinted.fr/items/123-nike",
  "market": "FR",
  "title": "Nike shoes",
  "brand": "Nike",
  "size": "L",
  "condition": "Très bon état",
  "description": "Seller's public description",
  "imageUrls": [],
  "askingPrice": { "amount": 12.5, "currency": "EUR", "raw": "12,50 €" },
  "priceIncludingBuyerProtection": { "amount": 13.83, "currency": "EUR", "raw": "13,83 €" },
  "shippingMinimum": null,
  "availability": "unknown",
  "availabilityEvidence": null,
  "sellerName": null,
  "sellerProfileUrl": null,
  "sourceReferences": ["https://www.vinted.fr/catalog?search_text=nike"],
  "detailStatus": "ok",
  "detailError": null,
  "scrapedAt": "2026-09-30T12:00:00.000Z"
}
```

`SNAPSHOT_CHECKPOINT` in the default key-value store contains delivered, billed listings and is saved periodically. Results are saved to the Dataset as each item finishes. If a run is interrupted, export the Dataset or the checkpoint’s `listings` array. `discoveredCount` may exceed the delivered count while details are being processed. Checkpoints do not automatically resume a run. Restarting or resurrecting a run that already performed billed work is rejected to prevent duplicate charges; its existing Dataset is preserved. Start a new run for a fresh snapshot.

`RUN_SUMMARY` in the default key-value store starts with a readable `message` and records target outcomes, the effective automatic limits, output and duplicate counts, request/retry totals and detail failures. `coverageStatus` distinguishes `complete` (all requested sources exhausted), `bounded` (configured catalog limits), `partial` (unvisited targets, source failures, interrupted work or failed details) and `failed` (every target failed). `targetCounts` gives total, visited, completed, empty, failed, limited and unvisited targets. `stopReason: COMPLETE` means the crawler finished its work; inspect coverage separately. Failed detail requests preserve useful catalog rows and set `detailStatus` to `failed`. HTTP 429 stops further requests and preserves partial output; wait before trying again. All-target access or parsing failures fail the run; valid empty searches remain successful empty results.

### Python API example

With the Apify Python client 3.x, use your Apify token from an environment variable:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/vinted-listings-item-details-scraper").call(
    run_input={
        "keywords": ["nike"], "countries": ["FR"],
        "includeDetails": True, "maxItems": 3,
    }
)
if run is None:
    raise RuntimeError("The run did not finish")
for item in client.dataset(run.default_dataset_id).list_items().items:
    print(item)
```

### Limitations and usage

Displayed prices are asking prices, including on sold-labelled pages; the Actor cannot establish actual transaction amounts. Buyer protection totals and minimum shipping are separate displayed values, not a guaranteed checkout total. Descriptions may contradict nominal prices; preserve that context when comparing items.

Missing fields are null. Sold/reserved status requires an explicit source label; disappearance is never treated as a sale. Countries represent the viewed marketplace, not necessarily the seller's location. Catalogs change while being paginated, so duplicate removal cannot guarantee complete inventory coverage.

No historical monitoring, currency conversion, image downloading or private seller contact enrichment is included. Login walls, challenge pages and source blocks are reported. Requests, pages and output are bounded; broad searches do not promise complete catalog exports.

### Pricing and spending limits

Launch pricing uses pay per event with standard Apify compute, storage, transfer and residential proxy usage during the run included. Reading/exporting or storing results after the run may incur standard Apify charges. No subscription is required.

| Event | Price | What is charged |
| --- | --- | --- |
| Catalog listing | $0.50 per 1,000 | One delivered unique listing without successful detail extraction |
| Detailed listing | $6.00 per 1,000 | One delivered listing with successfully extracted item details, including direct item URLs |
| Catalog page | $0.01 | One catalog page processed; empty searches and source failures also incur this execution fee. Internal retries do not add page fees |
| Actor start | $0.005 per GB, minimum one | Charged automatically at startup; use the recommended 1 GB memory |

Catalog and detailed listing charges are mutually exclusive. Failed detail extraction falls back to the catalog price, and duplicates within the run do not incur another listing charge. A request skipped because of a time or request limit has no catalog-page charge. `PAGE_OUTCOMES` records processed pages and their errors; `RUN_SUMMARY.billing` records the delivered event counts.

Total cost is the start fee + catalog-page fees + the applicable listing fees. For example, **100 catalog listings from two pages cost $0.075**, and **1,000 catalog listings from 20 pages cost $0.705**, if those quantities are delivered. Three successful details from one catalog page cost $0.033. Searching 27 markets for one catalog item each costs $0.2885 when all 27 pages are processed. These examples show fee arithmetic, not a guarantee of results or page counts. A blocked one-page search costs $0.015 at 1 GB and returns no listings.

Set a spending limit in Apify Console or through the API (`max_total_charge_usd` in the Python client). A low budget may stop discovery or enrichment and return fewer listings with `stopReason: CHARGE_LIMIT`; inspect the summary. The Actor stops before scheduling work it cannot charge within that limit. Custom proxy providers’ external bills are outside this cap.

Use catalog-only mode for the lowest-cost price snapshots. Direct access may be rate limited; datacenter proxy access was blocked in development tests. Report problems with the run ID, market and summary error code, excluding credentials.

### Optional direct-first access

The default `accessStrategy: "configured"` preserves configured proxy access. API users can opt into `accessStrategy: "direct-first"` to fetch catalog and detail pages directly and retry only blocked item detail requests through an allowed configured proxy. Explicit `proxyConfiguration: {"useApifyProxy": false}` disables proxy fallback. This strategy can reduce transfer costs, but does not guarantee that every public detail page is accessible.

Check `RUN_SUMMARY` for direct requests, proxied requests, detail proxy fallbacks, detail failures and coverage. Listings retain `detailStatus` and `detailError`; incomplete details do not count as complete-detail verification. Existing identity deduplication and result charging remain in effect.

# Actor input Schema

## `keywords` (type: `array`):

Enter search terms, one per line. For URL-only runs, clear this field and paste URLs below.

## `countries` (type: `array`):

Market domains, not seller locations. ALL searches every configured market. URLs keep their own markets.

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

Maximum total listings to save. Start with 3; increase this for larger exports. Pages and request limits adjust automatically. Large detail runs may finish with partial results within the run timeout.

## `includeDetails` (type: `boolean`):

Include descriptions, seller links, buyer protection totals and shipping. Turn off for faster, cheaper price snapshots.

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

Public HTTPS catalog or item URLs; catalog filters are preserved.

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

Residential Apify Proxy by default because sustained direct requests can be rate limited. Proxy traffic consumes credits. Set useApifyProxy to false for direct HTTP, or configure your own proxy.

## `maxItemsPerTarget` (type: `integer`):

Optional JSON/API override. Leave unset for automatic limits. Bound for each catalog or keyword-country target.

## `maxPagesPerTarget` (type: `integer`):

Optional JSON/API override. Leave unset for automatic limits. Bound for each catalog or keyword-country target.

## `maxRequests` (type: `integer`):

Optional JSON/API override. Leave unset for automatic limits. Includes redirects and retries.

## `accessStrategy` (type: `string`):

Configured preserves existing access. Direct first fetches catalog and details directly, retrying only blocked item details through your allowed proxy. Explicit useApifyProxy:false forbids proxy fallback. Allowed values: configured or direct-first. Other values are rejected.

## Actor input object example

```json
{
  "keywords": [
    "nike"
  ],
  "countries": [
    "FR"
  ],
  "maxItems": 3,
  "includeDetails": true,
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  },
  "accessStrategy": "configured"
}
```

# Actor output Schema

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

No description

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

No description

## `snapshotCheckpoint` (type: `string`):

No description

## `pageOutcomes` (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 = {
    "keywords": [
        "nike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/vinted-listings-item-details-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 = { "keywords": ["nike"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/vinted-listings-item-details-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/A0wvSuEJ0eAfCOAP2/builds/7pj5qmjvK6taLdElq/openapi.json