# Catawiki Cars Scraper — Classic Car Auctions (`rastriq/catawiki-cars-scraper`) Actor

Scrape classic car auction listings from Catawiki (catawiki.com), Europe's largest curated online auction platform. Extract bid prices, bid counts, auction end times, makes, models, and years. Uses stealth browser for anti-bot bypass.

- **URL**: https://apify.com/rastriq/catawiki-cars-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## Catawiki Cars Scraper — Classic Car Auction Data

Extract classic car auction listings from **Catawiki** (catawiki.com) — Europe's largest curated online auction platform. Catawiki Cars Scraper lets you scrape current bids, makes, models, years, auction end times, and lot metadata at scale. Export to JSON, CSV, or Excel, and integrate with any workflow via the Apify API.

> 🚀 **Try it free** — your first $5 of usage is on Apify. No credit card required.

### 📌 What is Catawiki Cars Scraper?

**Catawiki Cars Scraper** is an unofficial Catawiki data extractor that collects structured auction listing data from the Classic Cars category. Unlike manually browsing Catawiki — which shows limited results and requires constant refreshing — this scraper automatically extracts every active lot with full pricing and metadata.

Catawiki hosts weekly curated auctions of classic and collector cars, from vintage Porsches and Ferraris to everyday classics like Citroën 2CVs and Fiat 500s. Catawiki Cars Scraper captures all of this data in a structured format ready for analysis.

Use Catawiki Cars Scraper to:

- 🔍 **Monitor classic car auction prices** — track bidding trends across makes, models, and years
- 📊 **Build market intelligence reports** — compare realized prices with estimates and reserve thresholds
- 🏆 **Find investment opportunities** — spot undervalued lots by favorites count, bid activity, and time remaining
- 🔄 **Automate recurring data collection** — schedule weekly runs aligned with Catawiki's auction calendar

### 📋 What data does Catawiki Cars Scraper extract?

**Catawiki Cars Scraper** returns structured data with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique Catawiki lot identifier |
| `title` | string | Full lot title (Brand - Model - Year) |
| `brand` | string | Manufacturer name (parsed from title) |
| `model` | string | Model name (parsed from title) |
| `model_year` | integer | Year of manufacture |
| `price` | number | Current bid amount in listing currency |
| `price_currency` | string | ISO 4217 currency code (EUR, GBP, USD) |
| `current_bid` | number | Current highest bid |
| `status` | string | Auction status (e.g. "Current bid", "Upcoming") |
| `bid_count` | integer | Number of bids placed |
| `favorites` | integer | Number of users who favorited this lot |
| `auction_end` | string | Time remaining or auction end date |
| `reserve` | boolean | Whether the lot has a reserve price |
| `auction_id` | string | Catawiki auction event identifier |
| `description` | string | Lot subtitle — condition, location, mileage |
| `image_url` | string | URL of the lot's main image |
| `url` | string | Direct link to the lot on Catawiki |
| `scraped_at` | string | ISO 8601 extraction timestamp |

> 💡 Fields like `bid_count` and `expert_estimate` depend on auction status and may not be available for all listings.

### 🚀 How to use Catawiki Cars Scraper

Extracting Catawiki classic car data takes under two minutes:

1. **Create a free Apify account** at [apify.com](https://apify.com) — your first $5 is free
2. **Open Catawiki Cars Scraper** in Apify Console or click **Try for free** on this page
3. **Configure your search** — the default category (439 = Classic Cars) works out of the box. Optionally filter by make (e.g. "Porsche", "Ferrari")
4. **Set limits** — choose how many listings and pages to scrape
5. **Click Save & Start** and wait 30–60 seconds
6. **Download your results** in JSON, CSV, Excel, or XML — or access them via the Apify API

### ⚙️ Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | array | ❌ | — | Paste any Catawiki URL(s) — search results, category pages, or auction pages. If provided, overrides the category dropdown |
| `category` | string | ❌ | `"439"` | Dropdown: Classic Cars, Modern Classic Cars, or All. Only used when `startUrls` is empty |
| `make` | string | ❌ | — | Filter by make (client-side). Example: `"Porsche"`, `"Ferrari"` |
| `max_items` | integer | ❌ | `30` | Maximum listings to extract. `0` = no limit |
| `max_pages` | integer | ❌ | `3` | Maximum pages to scrape per URL. Each page has ~10–15 listings |
| `proxyConfiguration` | object | ❌ | Residential | Proxy settings. Residential proxies strongly recommended |
| `delay_min` | number | ❌ | `1.0` | Minimum delay between page loads (seconds) |
| `delay_max` | number | ❌ | `3.0` | Maximum delay between page loads (seconds) |

**Example 1 — Scrape by category (easiest):**

```json
{
  "category": "439",
  "make": "Porsche",
  "max_items": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Example 2 — Scrape by URL (paste from browser):**

```json
{
  "startUrls": [
    "https://www.catawiki.com/en/a/t/31-classic-car-auction",
    "https://www.catawiki.com/en/s?q=ferrari+250"
  ],
  "max_items": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### 📦 Output example

Each result is a structured JSON object. Here's a sample from a real run:

```json
{
  "id": "105583976",
  "listing_type": "auction",
  "url": "https://www.catawiki.com/en/l/105583976-triumph-vitesse-burlington-arrow-1985",
  "title": "Triumph - Vitesse Burlington arrow - 1985",
  "brand": "Triumph",
  "model": "Vitesse Burlington arrow",
  "model_year": 1985,
  "price": 7000,
  "price_currency": "EUR",
  "current_bid": 7000,
  "status": "Current bid",
  "favorites": 135,
  "auction_end": "3 days left",
  "reserve": true,
  "auction_id": "1259455",
  "image_url": "https://assets.catawiki.nl/assets/2026/7/22/9/6/1/961eb4fc.jpg",
  "description": "Located in: Netherlands - with Dutch registration - 69000 mi - Very good condition",
  "scraped_at": "2026-08-03T06:16:56Z",
  "source": "catawiki.com"
}
```

Download results in **JSON, CSV, Excel, XML, or HTML** from the Output tab, or pull them programmatically using the Apify API.

### 💰 How much does it cost to use Catawiki Cars Scraper?

Catawiki Cars Scraper runs on Apify's standard **Compute Unit (CU)** pricing. A typical run extracting ~20 listings consumes approximately 0.03 CUs and takes about 30 seconds.

| Scenario | Listings | Estimated cost |
|----------|----------|---------------|
| Quick test | 10–20 | < $0.01 |
| Weekly monitoring | 50–100 | ~$0.05 |
| Full category sweep | 200+ | ~$0.20 |

> 💡 **Tip**: Your first $5 of platform credit is free — enough for hundreds of test runs. Run a small test first to validate your setup before scaling.

Is scraping Catawiki free? Your free Apify credit covers roughly 500+ auction listings at no cost.

### 🔗 Related Rastriq Actors

Explore the full [Rastriq portfolio](https://apify.com/rastriq) on Apify Store:

| Actor | Description |
|-------|-------------|
| [Catawiki Scraper](https://apify.com/rastriq/catawiki-scraper) | Scrape Classic Motorcycles, Modern Classics, and Automobilia auctions |
| [Collecting Cars Scraper](https://apify.com/rastriq/collecting-cars-scraper) | Extract listings from Collecting Cars online auctions |
| [Classic-Trader Scraper](https://apify.com/rastriq/classic-trader-scraper) | Scrape premium classic car listings from Classic-Trader |
| [Car and Classic Scraper](https://apify.com/rastriq/carandclassic-scraper) | Extract vintage and classic car listings from Car and Classic |
| [AutoScout24 Scraper](https://apify.com/rastriq/autoscout24-scraper) | Scrape European car listings from AutoScout24 |

### ❓ Frequently Asked Questions

#### Is scraping Catawiki legal?

Catawiki Cars Scraper only accesses **publicly available data** on Catawiki — information visible to any visitor without logging in. The scraper respects rate limiting and applies reasonable delays between requests to avoid overloading Catawiki's servers.

As with any data collection activity, you are responsible for ensuring your use case complies with applicable laws (GDPR, CCPA) and Catawiki's Terms of Service. For guidance, see [Apify's blog on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Does Catawiki Cars Scraper require a Catawiki account?

No. Catawiki Cars Scraper works entirely with **public auction data** and does not require any account, login, or API credentials.

#### Why are some prices missing?

Catawiki loads bid prices dynamically via WebSocket for upcoming auctions that haven't opened for bidding yet. Prices are available for lots with active bidding ("Current bid" status).

#### What proxy configuration should I use?

Catawiki uses Akamai bot protection. **Residential proxies are strongly recommended** for reliable results. The scraper uses Camoufox (stealth Firefox) to bypass anti-bot detection.

#### How do I integrate Catawiki Cars Scraper with my workflow?

Catawiki Cars Scraper integrates natively with Make (Integromat), Zapier, Google Sheets, webhooks, and the full Apify API. See the API tab for ready-to-use code snippets in Python, Node.js, and more.

#### I found a bug or my run failed. Where do I report it?

Please open an issue in the **Issues tab** on this page. Include your input configuration and the run ID so we can investigate quickly.

# Actor input Schema

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

Paste any Catawiki URL — search results (<code>/en/s?q=porsche</code>), category pages (<code>/en/c/439-classic-cars</code>), or auction pages (<code>/en/a/t/31-classic-car-auction</code>).<br><br>Leave empty to use the Category selector instead.

## `category` (type: `string`):

Catawiki auction category. Only used when <b>Catawiki URLs</b> is empty.

## `make` (type: `string`):

Filter results by car make (client-side). Leave empty for all makes.<br>Example: <code>Porsche</code>, <code>Ferrari</code>, <code>Mercedes-Benz</code>

## `max_items` (type: `integer`):

Maximum number of listings to extract. <code>0</code> = no limit. Start with <b>20</b> for a quick test.

## `max_pages` (type: `integer`):

Max pages to scrape per URL. <code>0</code> = no limit. Each page has ~10–15 listings.

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

Residential proxies strongly recommended — Catawiki uses Akamai anti-bot.

## `delay_min` (type: `number`):

Minimum pause between page loads to avoid detection.

## `delay_max` (type: `number`):

Maximum pause between page loads.

## Actor input object example

```json
{
  "startUrls": [],
  "category": "439",
  "make": "",
  "max_items": 20,
  "max_pages": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "delay_min": 1,
  "delay_max": 3
}
```

# Actor output Schema

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

Classic car auction listings with prices, brands, models, and auction details.

# 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": [],
    "category": "439",
    "make": "",
    "max_items": 20,
    "max_pages": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/catawiki-cars-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": [],
    "category": "439",
    "make": "",
    "max_items": 20,
    "max_pages": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/catawiki-cars-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": [],
  "category": "439",
  "make": "",
  "max_items": 20,
  "max_pages": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call rastriq/catawiki-cars-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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