# Car & Classic \[$1💰] | Full 46k catalogue | Beats 10k cap (`memo23/carandclassic-scraper`) Actor

Scrape the full Car & Classic catalogue of classic cars, bikes and commercials.

- **URL**: https://apify.com/memo23/carandclassic-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, Lead generation, E-commerce
- **Stats:** 17 total users, 16 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

## Car & Classic Scraper

**Turn Car & Classic into a structured classic-car dataset — the whole catalogue, not the first 10,000.** Scrape listings from carandclassic.com with price, year, mileage, engine, gearbox, steering side, colour, location with coordinates, seller details, photos, and live auction bids. Classic cars, motorcycles and commercial vehicles across the UK and Europe. JSON, CSV or Excel out, priced per result.

#### ✨ Why use this scraper?

Car & Classic's own search API refuses to page beyond about 10,000 results. It doesn't return an error when you cross that line — it quietly hands back a 6-row page and stops. A scraper that pages until it runs out therefore *looks* like it finished, while silently dropping three quarters of a 46,000-listing catalogue.

- 🔓 **Gets past the 10,000 ceiling.** When a search is bigger than the API will serve, the Actor automatically splits it into year slices, sweeps each, and de-duplicates. A full-catalogue run returns ~44,000 listings instead of ~10,000.
- 📣 **Tells you when it falls short.** Every run compares what it collected against the total Car & Classic itself reports, and says so in the log. No silent truncation.
- 🔗 **Paste a search URL and it just works.** Car & Classic's search URL uses the same parameters as its API, so a pasted URL reproduces the site's own result count exactly. Paste several to run several searches at once.
- 📞 **Dealer contact details included.** Dealer listings carry the trading name, phone number and website, alongside verification year — with no extra requests.
- 🔨 **Live auctions with bids.** Auction listings include the current bid, bid count, reserve status (set / met / lowered) and end time.
- 🌍 **Pan-European, not just UK.** GB ~20,700, France ~8,600, Italy ~7,100, plus the Netherlands, US, Belgium, Germany, Spain and more — filterable by country, and each row carries latitude and longitude.
- ⚡ **100 listings per request, no per-car fetches.** Everything comes from the search API, so ~44,000 rows takes about three minutes.

#### 🎯 Use cases

| Team | What they build |
|------|-----------------|
| **Classic dealers & traders** | Pricing benchmarks by model, generation and condition across Europe |
| **Collectors** | Alerts on a specific generation or variant coming to market |
| **Auction watchers** | Live bid, reserve status and end-time tracking across every running auction |
| **Market analysts** | Classic-car value trends by make, era and country |
| **Lead generation** | Dealer directories from `sellerName`, `sellerPhone`, `sellerWebsite` and `town` |
| **Restorers & parts traders** | Finding project cars by mileage, year and price band |
| **ML / data teams** | Valuation training data with spec, location and listing history |

#### 📥 Supported inputs

You don't need a URL. Set the filters and run. `startUrls` is optional:

| Input | Behaviour |
|---|---|
| `https://www.carandclassic.com/search?make=porsche&model=911` | **Search** — the query string maps 1:1 onto the API |
| Filters on the input | Same filters, set directly |

**Pasted search URLs are the easiest route.** Build the search on carandclassic.com, copy the URL, paste it in. Paste as many as you like — each is scraped as its own search and results are de-duplicated by listing ID across all of them, so overlapping searches never bill twice. `maxItems` is a total across every URL.

If the Actor cannot read any filters from a URL you paste, it stops with an error rather than running. That's deliberate: an unreadable URL would otherwise fall through to scraping all ~46,000 listings instead of your selection.

**Not supported:** single-listing URLs as a starting point (Car & Classic has no per-listing API), and hosts outside `carandclassic.com`.

#### 🔄 How it works

1. **Translate** your filters, or the query string of any pasted search URL, into API parameters.
2. **Ask the API how many listings match** — the same number the website prints.
3. **Slice if needed.** Above ~10,000 the year range is bisected recursively until every slice fits under the ceiling.
4. **Sweep each slice** at 100 listings per request, de-duplicating by listing ID.
5. **Report coverage** — collected versus reported, with any shortfall stated explicitly.

#### ⚙️ Input parameters

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Car & Classic search URLs. Optional. |
| `maxItems` | integer | Maximum listings. Default `1000`. |
| `makes` | array | Make slugs as they appear in a URL, e.g. `["porsche","alfa-romeo"]`. Each runs as its own search. |
| `model` / `variant` / `generation` | string | Slugs, e.g. `911`, `gt3`, `991-2`. |
| `keywords` | string | Free-text search. |
| `vehicleType` | string | Cars, motorcycles or commercial vehicles. |
| `listingType` | string | Auctions only, classifieds only, or both. |
| `priceMin` / `priceMax` | integer | Price range in whole currency units. |
| `yearMin` / `yearMax` | integer | Year range. |
| `mileageMin` / `mileageMax` | integer | Mileage range. |
| `engineSizeMinCc` / `engineSizeMaxCc` | integer | Engine capacity in cc. |
| `colours` | array | Exterior colour. |
| `transmission` | string | Manual or automatic. |
| `steeringPosition` | string | LHD or RHD. |
| `sellerType` | string | Dealer or private. |
| `country` | string | ISO country code, e.g. GB, FR, IT. |
| `maxConcurrency` | integer | Parallel dataset writes. Default `10`. |

##### Example input

```json
{
  "startUrls": ["https://www.carandclassic.com/search?make=porsche&model=911"],
  "maxItems": 500
}
```

Every live auction, with bids:

```json
{
  "listingType": "auctions",
  "maxItems": 500
}
```

#### 📊 Output overview

One row per listing. Classifieds and auctions share a single shape — auction-only fields come back `null` on classifieds, and dealer-only fields come back `null` on private sales, so the column set never changes between rows.

#### 📦 Output sample

```json
{
  "listingId": "2241780",
  "listingUrl": "https://www.carandclassic.com/la/C2131760",
  "listingType": "basic",
  "title": "2018 Porsche 911 GT3",
  "make": "Porsche",
  "model": "911",
  "variant": "GT3",
  "generation": "991.2",
  "year": 2018,
  "price": 149900,
  "currency": "EUR",
  "mileage": 43500,
  "mileageUnit": "km",
  "engineSizeCc": 4000,
  "fuelType": "petrol",
  "transmission": "automatic",
  "gears": "7+",
  "steeringPosition": "lhd",
  "colour": "Red",
  "bodyType": "Coupe",
  "category": "Modern Cars",
  "country": "France",
  "countryCode": "FR",
  "town": "Paris",
  "latitude": 48.8247842,
  "longitude": 2.3678611,
  "sellerType": "dealer",
  "sellerName": "Sportwagen Paris",
  "sellerPhone": "+33187227763",
  "sellerWebsite": "http://sportwagenparis.com",
  "isAuction": false,
  "currentBid": null,
  "bidCount": null,
  "imageCount": 11,
  "createdAt": "2026-08-13T09:26:53+00:00",
  "scrapedAt": "2026-08-18T15:17:25.862Z"
}
```

#### 🗂 Key output fields

| Field | Notes |
|---|---|
| `listingId` | Stable ID. Use it to de-duplicate across scheduled runs. |
| `price` | Asking price, or the **current bid** on a live auction. |
| `currency` | **Check this.** The site is pan-European, so GBP and EUR both appear. |
| `mileage` / `mileageUnit` | **Check the unit** — European listings are in km, UK ones in miles. |
| `sellerPhone` / `sellerWebsite` | Dealer listings only; `null` for private sellers. |
| `isAuction` | True for live auctions. Auction fields are null on classifieds. |
| `currentBid` / `bidCount` / `reserveMet` | Live auction state at the moment of scraping. |
| `latitude` / `longitude` | Listing coordinates, useful for mapping or distance work. |
| `generation` | e.g. `991.2` — Car & Classic is unusually good at generation data, which matters for valuation. |

#### ❓ FAQ

**Why do other Car & Classic scrapers stop at around 10,000?**
Because the API stops serving real results past that point without raising an error. This Actor detects the ceiling and splits the search into year slices to get underneath it.

**Can I get all ~46,000 listings?**
Close to it. A full sweep returns roughly 44,000. The gap is listings with no year (which fall outside every year slice) plus normal churn during a multi-minute run. The Actor reports the exact shortfall in the log rather than hiding it.

**Can I get sold or completed auction results?**
No. Car & Classic's API only exposes currently-live auctions, so `hasSold` is effectively always false. Only live bidding state is available.

**Do I need a proxy?**
No. Car & Classic sits behind Cloudflare, but the Actor's HTTP stack handles it without one, and direct connections are both faster and free.

**Why is `mileageUnit` sometimes km?**
Because the listing is in mainland Europe. Always read `mileage` together with `mileageUnit`.

#### 💬 Support

- Issues tab on the Actor page
- Email: <muhamed.didovic@gmail.com>

#### 🛠 Additional services

- Custom output shape, additional fields, or one-off datasets: <muhamed.didovic@gmail.com>
- Need a similar scraper for another classic-car marketplace (Collecting Cars, Bring a Trailer, Classic Trader, Catawiki)? Drop an email.
- For API access (no Apify fee, just a usage fee for the API): <muhamed.didovic@gmail.com>

#### 🔎 Explore more scrapers

See other scrapers at [memo23's Apify profile](https://apify.com/memo23) — including the [PistonHeads](https://apify.com/memo23/pistonheads-scraper) and AutoTrader UK scrapers, plus job boards, real estate and more.

***

### 🤖 For AI Agents & LLM Apps

- **Deterministic input.** All filters are plain JSON; make and model take the same slugs as the website URL.
- **Stable schema.** Every field is present on every row (`null` when absent), so downstream parsing needs no defensive key checks.
- **Bounded cost.** `maxItems` caps the result count exactly.
- **Honest coverage.** The run states collected-versus-reported totals, so an agent can tell whether it has a complete set.
- **Grounding-friendly.** `listingUrl` gives every row a citable public source; `scrapedAt` and `modifiedAt` support freshness reasoning.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Car & Classic Ltd or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available listing pages and the public search endpoint on carandclassic.com — no authenticated endpoints, dealer-only features, or content behind a login. Users are responsible for ensuring their use complies with Car & Classic's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation.

***

### SEO Keywords

car and classic scraper, carandclassic scraper, classic car scraper, classic car listings api, classic car data, scrape carandclassic.com, Apify car and classic, classic car marketplace scraper, classic car auction scraper, classic car prices uk, european classic car listings, vintage car scraper, collector car data, classic car dealer leads, porsche 911 listings scraper, classic car valuation data, car auction bids scraper, classic motorcycle listings scraper, bring a trailer alternative, collecting cars alternative, classic trader alternative, uk classic car market data

# Actor input Schema

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

Optional. Build a search on carandclassic.com, copy the URL and paste it here — its query string maps directly onto the API, so results match the site exactly. Paste several to scrape several searches in one run. Leave empty to use the filters below.

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

Maximum listings to return. Car & Classic holds roughly 46,000, so set this deliberately.

## `makes` (type: `array`):

Make slugs, e.g. \["porsche","jaguar"]. Each is searched separately.

## `model` (type: `string`):

Model slug, e.g. 911. Meaningful with a single make.

## `variant` (type: `string`):

Variant slug, e.g. gt3.

## `generation` (type: `string`):

Generation slug, e.g. 991-2.

## `keywords` (type: `string`):

Free-text search across listings.

## `vehicleType` (type: `string`):

Car & Classic also lists motorcycles and commercial vehicles.

## `listingType` (type: `string`):

Auctions carry live bid counts and reserve status. Note only currently-live auctions are available; Car & Classic does not expose completed/sold auctions through this API.

## `priceMin` (type: `integer`):

Lowest asking price, in whole currency units.

## `priceMax` (type: `integer`):

Highest asking price, in whole currency units.

## `yearMin` (type: `integer`):

Earliest year.

## `yearMax` (type: `integer`):

Latest year.

## `mileageMin` (type: `integer`):

Lowest recorded mileage.

## `mileageMax` (type: `integer`):

Highest recorded mileage.

## `engineSizeMinCc` (type: `integer`):

Smallest engine capacity in cc.

## `engineSizeMaxCc` (type: `integer`):

Largest engine capacity in cc.

## `colours` (type: `array`):

Exterior colour. The API takes one at a time, so the first is used.

## `transmission` (type: `string`):

Gearbox type.

## `steeringPosition` (type: `string`):

Useful on a pan-European site — roughly half the catalogue is LHD.

## `sellerType` (type: `string`):

Dealer listings also carry the dealer's name, phone number and website.

## `country` (type: `string`):

ISO country code. The catalogue is pan-European: GB ~20,700, FR ~8,600, IT ~7,100.

## `maxConcurrency` (type: `integer`):

Parallel dataset writes.

## `proxy` (type: `object`):

Optional. Direct connections work well here and are the default; a proxy is rarely needed.

## Actor input object example

```json
{
  "startUrls": [],
  "maxItems": 100,
  "makes": [],
  "vehicleType": "",
  "listingType": "",
  "colours": [],
  "transmission": "",
  "steeringPosition": "",
  "sellerType": "",
  "country": "",
  "maxConcurrency": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Every scraped listing.

# 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": [],
    "maxItems": 100,
    "makes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/carandclassic-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": [],
    "maxItems": 100,
    "makes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/carandclassic-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": [],
  "maxItems": 100,
  "makes": []
}' |
apify call memo23/carandclassic-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/carandclassic-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/ndKpcP8SrXSnynMkr/builds/F5G3aCaalv5bk20LO/openapi.json