# Classic-Trader Scraper — Premium Classic Cars (`rastriq/classic-trader-scraper`) Actor

Scrape classic car listings from Classic-Trader.com, a premium European marketplace for collector vehicles. Extract price, make, model, year, condition, dealer info, and photos. Ideal for classic car valuation, market tracking, and investment analysis.

- **URL**: https://apify.com/rastriq/classic-trader-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Other, Automation
- **Features:** Limited permissions
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.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/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

## Classic-Trader Scraper — Premium Classic Cars

**Classic-Trader Scraper** extracts classic and collector car listings from Classic-Trader.com: price, make, model, year, condition, dealer info and photos. Use it for classic car valuation, investment analysis and dealer market research — export to JSON, CSV or Excel.

### What data can you scrape from Classic-Trader?

Extract structured data from **Classic-Trader.com** — Europe's largest premium marketplace for historic and collector vehicles.

- **Structured output** — Clean, normalized records ready for spreadsheets, BI tools or databases
- **Two search modes** — Paste a URL from your browser or use built-in filters (brand, category, year)
- **Export anywhere** — JSON, CSV, Excel, or via the Apify API and integrations

***

### Output: Classic-Trader data structure

| Field | Label | Format |
|-------|-------|--------|
| `id` | ID | number |
| `url` | URL | link |
| `title` | Title | text |
| `brand` | Brand | text |
| `model` | Model | text |
| `year_of_production` | Year | number |
| `body` | Body style | text |
| `price_amount` | Price | number |
| `price_currency` | Currency | text |
| `mileage_value` | Mileage | number |
| `selling_method` | Selling method | text |
| `location_country` | Country | text |
| `seller_company_name` | Seller | text |
| `image_url` | Image | image |
| `scraped_at` | Scraped at | datetime |

#### Example output (one record)

```json
{
  "id": 123456,
  "url": "https://www.classic-trader.com/uk/cars/listing/porsche/911/911-carrera/123456",
  "title": "1973 Porsche 911 Carrera RS 2.7 Touring",
  "brand": "Porsche",
  "model": "911 Carrera",
  "year_of_production": 1973,
  "body": "Coupe",
  "price_amount": 485000,
  "price_currency": "GBP",
  "mileage_value": 62000,
  "mileage_unit": "km",
  "selling_method": "fixed_price",
  "location_country": "DE",
  "seller_company_name": "Classic Remise Berlin",
  "image_url": "https://cloud.classic-trader.com/...",
  "scraped_at": "2026-07-23T12:00:00Z"
}
```

***

### 🚀 How to use Classic-Trader Scraper

1. Click **Start** with the default input to test with a small sample (15 Porsche listings, under 60 seconds).
2. Open the **Output** tab to preview results.
3. Export as CSV / Excel / JSON, or connect via API.

***

### How to scrape Classic-Trader — input options

#### Option 1: Paste a URL (easiest)

Copy any Classic-Trader search URL from your browser and paste it in **Start URLs**. The scraper detects pagination and follows all pages automatically.

Works with any locale and URL format:

- `https://www.classic-trader.com/uk/cars/search/porsche`
- `https://www.classic-trader.com/uk/cars/muscle-cars`
- `https://www.classic-trader.com/de/autos/suche/bmw?yearBeginOfProduction=1960&yearEndOfProduction=1975`

When you use URLs, all filter fields (Brand, Category, Year, Region) are skipped.

#### Option 2: Use filters

| Field | Description | Default |
|-------|-------------|---------|
| **Brand** | Select a brand to filter listings. Choose **(All brands)** to use a Category filter or scrape the full catalogue. | `porsche` |
| **Category** | Search within a curated category page (e.g. Muscle Cars, Pre-War Cars). Mutually exclusive with Brand. | — |
| **Year from** | Earliest production year to include. Leave empty for no lower bound. | — |
| **Year to** | Latest production year to include. Leave empty for no upper bound. | — |
| **Region** | Regional version of Classic-Trader to scrape. **UK** is recommended — other regions may return limited results. | `uk` |
| **Max results** | Maximum listings to return. Start with **15** for a quick test. Raise to **500–2000** for full market snapshots. | `15` |
| **Max pages** | Hard cap on pages fetched (15 results per page). Leave empty to paginate until Max results. | — |
| **Proxy configuration** | Residential proxies recommended for runs above ~200 items. | Apify auto |

***

### How much does it cost to use Classic-Trader Scraper?

**Classic-Trader Scraper** uses **Pay-Per-Event** pricing — you pay only for results delivered, not for compute time: **$3.00 per 1,000 listings** plus $0.05 per run start.

| Plan | What you get |
|------|-------------|
| **Free tier** | $5/month of platform credits — enough for thousands of results |
| **Paid plans** | Scale to tens of thousands of results per run |

***

### Use cases

- **Classic car valuation** — Track asking prices across brands and model years for investment analysis.
- **Dealer inventory monitoring** — Monitor competitor stock and pricing in real time.
- **Market research** — Analyze trends in the collector car market by segment (pre-war, muscle cars, etc.).
- **Auction intelligence** — Track auction estimates, bids, and hammer prices for upcoming and past sales.

***

### 🔄 Integrations & scheduling

- **Schedule** daily/weekly runs from the Apify Console for automated data collection.
- Push results to **Google Sheets, Slack, Zapier, Make, webhooks** or any database.
- Fetch datasets via the **Apify REST API** or the official JavaScript/Python clients.

***

### Is it legal to scrape Classic-Trader?

This Actor collects only **publicly available** data. It does not log in, bypass paywalls, or access private information. You are responsible for using the extracted data in compliance with the site's Terms of Service and applicable data protection laws (including GDPR where relevant).

***

### 🧪 Ready-made examples

Start from a pre-configured task and adapt it to your needs:

- [Find classic Porsche cars for sale in the UK](https://apify.com/rastriq/classic-trader-scraper/examples/classic-trader-porsche-uk)
- [Browse pre-war classic cars for sale in the UK](https://apify.com/rastriq/classic-trader-scraper/examples/classic-trader-prewar-cars)
- [UK Classic Muscle Cars Listings](https://apify.com/rastriq/classic-trader-scraper/examples/classic-muscle-cars-for-sale)
- [Vintage Ferrari Prices in Europe](https://apify.com/rastriq/classic-trader-scraper/examples/vintage-ferrari-prices-europe)
- [German Classic Cars Price Data Scraper](https://apify.com/rastriq/classic-trader-scraper/examples/german-classic-cars-market)

***

### ❓ FAQ

**Can I access the data via API?**
Yes. Every run stores its dataset on Apify. Fetch it via REST API or use the official JavaScript/Python clients.

**What export formats are supported?**
JSON, CSV, Excel (XLSX), XML, and HTML table. You can also push data directly to Google Sheets or any webhook endpoint.

**Do I need proxies?**
Residential proxies are recommended for best results. The default proxy configuration is pre-set.

**What data does the Actor return for auctions?**
For auction listings, the Actor returns estimate ranges, current highest bid, number of bids/watchers, and auction state — instead of a nominal asking price, which Classic-Trader encodes as a placeholder for auctions.

### Related Scrapers by Rastriq — Classic & Collector Cars

- [Car and Classic Scraper](https://apify.com/rastriq/carandclassic-scraper) — Europe's largest classic car marketplace
- [Collecting Cars Scraper](https://apify.com/rastriq/collecting-cars-scraper) — UK's leading online car auction platform
- [Bring a Trailer Scraper](https://apify.com/rastriq/bringatrailer-scraper) — US auction results
- [Classic.com Scraper](https://apify.com/rastriq/classic-com-scraper) — Classic car market analytics
- [TheMarket Scraper](https://apify.com/rastriq/themarket-scraper) — Curated classic car auctions

### Related Scrapers by Rastriq — Used Cars & Marketplaces

- [Wallapop Cars Scraper](https://apify.com/rastriq/wallapop-cars-scraper)
- [Cochesnet Spain Scraper](https://apify.com/rastriq/cochesnet-spain)
- [Autoscout24 Scraper](https://apify.com/rastriq/autoscout24-scraper)
- [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper)

# Actor input Schema

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

Paste one or more Classic-Trader URLs straight from your browser. The scraper detects pagination and follows all pages automatically.<br><br>Works with any locale and URL format:<br>• <code>https://www.classic-trader.com/uk/cars/search/porsche</code><br>• <code>https://www.classic-trader.com/uk/cars/muscle-cars</code><br>• <code>https://www.classic-trader.com/de/autos/suche/bmw?yearBeginOfProduction=1960\&yearEndOfProduction=1975</code><br><br>💡 <b>Tip:</b> When you use URLs, all the filter fields below (Brand, Category, Year, Region) are skipped.

## `brand` (type: `string`):

Select a brand to filter listings. Choose <b>(All brands)</b> to use a Category filter or scrape the full catalogue.<br><br>If the brand you need is not in the list, you can type its slug directly — e.g. <code>de-tomaso</code>, <code>facel-vega</code>. Slugs follow the URL pattern: <code>classic-trader.com/uk/cars/search/{slug}</code>

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

Search within a curated category page. Mutually exclusive with Brand — if both are filled, Category takes priority.<br><br>Use this when you want a cross-brand segment (e.g. all Muscle Cars, all Pre-War cars).

## `year_min` (type: `integer`):

Earliest production year to include. Leave empty for no lower bound.<br><br>Example: <code>1960</code> includes all cars built from 1960 onwards.

## `year_max` (type: `integer`):

Latest production year to include. Leave empty for no upper bound.<br><br>Example: <code>1979</code> excludes cars built after 1979.

## `locale` (type: `string`):

Regional version of Classic-Trader to scrape. <b>Important:</b> Only <code>uk</code> is fully functional. Other locales may return 0 results due to classic-trader.com returning 404 on non-UK search pages. This is a site limitation, not a scraper bug.

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

Maximum listings to write to the dataset.<br><br>Start with <b>15</b> for a quick test (1 page, ~30 sec). Raise to <b>500–2000</b> for full market snapshots.

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

Hard cap on pages fetched (15 results per page). Leave empty to paginate until <i>Max results</i> or end of results.<br><br>Tip: set to <code>1</code> for a fast single-page test without touching Max results.

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

Proxy settings. <b>Residential proxies recommended</b> for runs above ~200 items. Datacenter proxies may get rate-limited at scale.

## Actor input object example

```json
{
  "startUrls": [],
  "brand": "porsche",
  "category": "",
  "year_min": 1960,
  "year_max": 1979,
  "locale": "uk",
  "max_items": 100,
  "max_pages": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Classic car listings with price, specs, seller, location, and auction data.

# 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": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/classic-trader-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": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/classic-trader-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 '{
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call rastriq/classic-trader-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/classic-trader-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/WLbTpnT5LDop86qxq/builds/faRMndE49HJaWOlul/openapi.json
