# ClassicCars.com Scraper — US Classic Car Listings (`rastriq/classiccars-com-scraper`) Actor

Scrape classic and collector car listings from ClassicCars.com, America's largest classic car marketplace. Extract price, make, model, year, mileage, location, dealer info, and images from 40K+ active listings.

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

## Pricing

from $2.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

## ClassicCars.com Scraper — US Classic Car Listings, Prices & Dealers

Extract structured data from [ClassicCars.com](https://classiccars.com), America's largest online marketplace for classic and collector cars. ClassicCars.com Scraper lets you scrape listing prices, vehicle specs, mileage, dealer info, and images from 40,000+ active listings — no API key or login required.

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

### 📌 What is ClassicCars.com Scraper?

**ClassicCars.com Scraper** is an unofficial ClassicCars.com API that extracts classic and collector car listings at scale. Unlike browsing the site manually — where you can only view 15–60 listings per page — this scraper automates pagination, detail page enrichment, and structured export for the entire marketplace.

Use ClassicCars.com Scraper to:

- 💰 **Track classic car prices** — monitor asking prices across makes, models, and year ranges to spot undervalued vehicles or market trends
- 📊 **Analyze inventory and supply** — track listing volumes and turnover by make, model, or region across America's largest classic car marketplace
- 🏪 **Monitor dealers and private sellers** — identify top dealers, their inventory mix, and pricing strategies
- 🔄 **Automate recurring data collection** — schedule daily or weekly runs to keep your classic car dataset fresh

### 📋 What data does ClassicCars.com Scraper extract?

ClassicCars.com Scraper returns structured data with the following fields:

|                          |                                    |
| ------------------------ | ---------------------------------- |
| 🔗 Listing URL and title | 🏷️ Make, model, and year           |
| 💰 Asking price (USD)    | 🛣️ Odometer mileage                |
| 📍 Seller location       | 🏪 Dealer or private seller name   |
| 📸 Primary image URL     | 🏷️ Listing type (classified/auction) |

> 💡 Fields like mileage and seller name require **detail page scraping** (enabled by default). Disable it for faster card-only extraction.

#### Full field reference

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique listing ID on ClassicCars.com (or AutoHunter for auctions) |
| `url` | string | Direct URL to the listing page |
| `title` | string | Full listing title (e.g. "1967 Ford Mustang Fastback") |
| `brand` | string | Car manufacturer (e.g. "Porsche", "Chevrolet") |
| `model` | string | Model name (e.g. "911", "Corvette") |
| `model_year` | integer | Year of manufacture |
| `price` | number | Asking price in USD (null if "Call for Price") |
| `price_currency` | string | Always `"USD"` |
| `mileage_value` | number | Odometer reading (requires detail scraping) |
| `mileage_unit` | string | Always `"mi"` (miles) |
| `location` | string | Seller city and state (e.g. "Palm Desert, California") |
| `seller_name` | string | Dealer name or "Private Seller" (requires detail scraping) |
| `image_url` | string | Primary listing image URL |
| `listing_type` | string | `"classified"` or `"auction"` (AutoHunter listings) |
| `scraped_at` | string | ISO 8601 timestamp of extraction |
| `source` | string | Always `"classiccars.com"` |

### 🚀 How to use ClassicCars.com Scraper

Extracting 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 ClassicCars.com Scraper** in Apify Console or click **Try for free** on this page
3. **Add your URLs** — browse [ClassicCars.com](https://classiccars.com/listings/find), apply filters (make, model, year, price), and paste the URL into Start URLs
4. **Set your limits** — choose how many results and whether to scrape detail pages
5. **Click Start** and wait — 100 listings take about 2 minutes
6. **Download your results** in JSON, CSV, Excel, or XML — or access them via API

#### 💡 Tip: Let the site do the filtering

Instead of configuring filters in the scraper, use ClassicCars.com's own search page to narrow down exactly what you want. Then just copy the URL from your browser and paste it into **Start URLs**. The scraper handles pagination automatically.

**Example URLs you can paste directly:**

- All Porsche 911s: `https://classiccars.com/listings/find/all-years/porsche/911`
- Ford Mustangs 1965–1970: `https://classiccars.com/listings/find/1965-1970/ford/mustang`
- All Ferrari listings: `https://classiccars.com/listings/find/all-years/ferrari`
- Everything on the marketplace: `https://classiccars.com/listings/find`

### ⚙️ Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | array | ❌ | — | One or more ClassicCars.com URLs (search pages or individual listings) |
| `make` | string | ❌ | — | Quick filter: car make (e.g. `porsche`, `ford`). Ignored if Start URLs are set |
| `model` | string | ❌ | — | Quick filter: car model (e.g. `911`, `mustang`). Ignored if Start URLs are set |
| `year_min` | integer | ❌ | — | Quick filter: earliest year to include |
| `year_max` | integer | ❌ | — | Quick filter: latest year to include |
| `max_items` | integer | ❌ | 100 | Maximum number of listings to extract |
| `max_pages` | integer | ❌ | — | Maximum search result pages to process |
| `scrapeDetails` | boolean | ❌ | `true` | Fetch detail pages for mileage and seller info (disable for 3× speed) |
| `proxyConfiguration` | object | ❌ | Apify Proxy | Proxy settings for the run |

**Example input:**

```json
{
  "startUrls": [
    { "url": "https://classiccars.com/listings/find/all-years/porsche/911" }
  ],
  "max_items": 50,
  "scrapeDetails": true
}
```

### 📦 Output example

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

```json
{
  "id": "2093626",
  "url": "https://classiccars.com/listings/view/2093626/1988-chevrolet-camaro-for-sale-in-woodbury-new-jersey-08096",
  "title": "1988 Chevrolet Camaro",
  "brand": "Chevrolet",
  "model": "Camaro",
  "model_year": 1988,
  "price": 29989,
  "price_currency": "USD",
  "mileage_value": 78950,
  "mileage_unit": "mi",
  "location": "Woodbury, New Jersey",
  "seller_name": "Ebzzmotors.com LLC",
  "image_url": "https://photos.classiccars.com/cc-temp/listing/209/3626/60536318-1988-chevrolet-camaro-thumb.jpg",
  "listing_type": "classified",
  "scraped_at": "2026-07-28T22:39:42.064595+00:00",
  "source": "classiccars.com"
}
```

Download results in **JSON, CSV, Excel, XML, or HTML** from the Output tab, or pull them programmatically using the [Apify API](https://docs.apify.com/api/v2) (see the API tab for ready-to-use code snippets).

### 💰 How much does it cost to scrape ClassicCars.com?

ClassicCars.com Scraper runs on Apify's standard **Compute Unit (CU) pricing**. A typical run extracting ~100 listings with detail pages consumes approximately 0.01–0.02 CUs.

| Scenario | Estimated CUs | Approx. cost |
|----------|--------------|--------------|
| 100 listings (with details) | ~0.015 CU | ~$0.01 |
| 1,000 listings (with details) | ~0.15 CU | ~$0.08 |
| 1,000 listings (cards only) | ~0.05 CU | ~$0.03 |
| Full marketplace (~40K) | ~6 CU | ~$3.00 |

> 💡 **Tip**: Disable **Scrape detail pages** for a 3× speed boost and lower cost when you only need price, make, model, year, and location (no mileage or seller name).

Is scraping ClassicCars.com free? Your first $5 of usage is covered by Apify's free plan — enough to extract thousands of classic car listings at no cost.

### 🔄 Setting up recurring monitoring with ClassicCars.com Scraper

ClassicCars.com Scraper is designed for both one-time extractions and continuous monitoring:

1. **Save your input as a Task** in Apify Console
2. **Go to Schedules** and set the frequency: daily, weekly, or custom cron
3. **Add a webhook** to get notified via Slack, email, or your own endpoint when each run completes
4. **Compare datasets** across runs to spot new listings, price drops, or removed inventory

### 🔗 Related Rastriq Actors

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

| Actor | Description |
|-------|-------------|
| [Collecting Cars Scraper](https://apify.com/rastriq/collecting-cars-scraper) | Online classic car auction results and live bids |
| [Classic-Trader Scraper](https://apify.com/rastriq/classic-trader-scraper) | Premium European classic car marketplace |
| [Car and Classic Scraper](https://apify.com/rastriq/carandclassic-scraper) | UK-based vintage and classic car listings |

### ❓ Frequently Asked Questions

#### Is scraping ClassicCars.com legal?

ClassicCars.com Scraper only accesses **publicly available data** — information visible to any visitor without logging in. We respect the site's `robots.txt` and apply reasonable rate limiting to avoid overloading their servers.

As with any data collection activity, you are responsible for ensuring your use case complies with applicable laws (CCPA, state privacy laws) and ClassicCars.com'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 ClassicCars.com Scraper require an account or API key?

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

#### How many classic car listings can I scrape?

ClassicCars.com currently has approximately 40,000 active listings. ClassicCars.com Scraper can extract all of them in a single run (set `max_items` to 50000 and allow approximately 30 minutes with detail scraping enabled).

#### What proxy configuration should I use?

**Datacenter proxies** (the default, included in Apify Free plan) work reliably for ClassicCars.com. Switch to residential proxies only if you experience blocking on very large runs.

#### How do I integrate ClassicCars.com Scraper with my workflow?

ClassicCars.com Scraper integrates natively with Make (formerly Integromat), Zapier, Google Sheets, webhooks, and the Apify API. See the [Apify integrations page](https://apify.com/integrations) for 1,500+ app connections.

#### 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 one or more ClassicCars.com URLs. The scraper auto-paginates search pages and extracts full detail for each listing.<br><br><b>Accepted URL types:</b><br>• Search results: <code>https://classiccars.com/listings/find/all-years/porsche/911</code><br>• Filtered search: <code>https://classiccars.com/listings/find/1965-1970/ford/mustang</code><br>• Single listing: <code>https://classiccars.com/listings/view/1234567/...</code><br><br>💡 <b>Tip:</b> Use the site's own filters, then copy the URL from your browser.

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

Car make to search for.<br><br>Examples: <code>porsche</code>, <code>ferrari</code>, <code>mercedes-benz</code>, <code>jaguar</code><br><br>Leave empty to scrape all makes. Use the URL slug from the site (lowercase, hyphens).

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

Car model to filter by.<br><br>Examples: <code>911</code>, <code>corvette</code>, <code>mustang</code>, <code>e-type</code><br><br>Leave empty to scrape all models for the selected make. Use the URL slug from the site.

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

Earliest model year to include. Leave empty for no lower bound.

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

Latest model year to include. Leave empty for no upper bound.

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

Maximum number of listings to extract.<br>Start with <b>10</b> for a quick test, then increase for production runs.

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

Maximum number of search result pages to process. Leave empty to use <b>Max results</b> as the only limit.

## `scrapeDetails` (type: `boolean`):

Fetch each listing's detail page for full metadata (mileage, seller name, etc.).<br>Disable to scrape only card-level data — <b>3× faster</b> but fewer fields.

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

Select proxies for the scraping run. Datacenter proxy (default) works for most sites and is included in the Apify Free plan.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://classiccars.com/listings/find/all-years/chevrolet/corvette"
    }
  ],
  "max_items": 10,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset of scraped ClassicCars.com listings with vehicle specs, pricing, and seller information

# 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": [
        {
            "url": "https://classiccars.com/listings/find/all-years/chevrolet/corvette"
        }
    ],
    "max_items": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/classiccars-com-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": [{ "url": "https://classiccars.com/listings/find/all-years/chevrolet/corvette" }],
    "max_items": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/classiccars-com-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": [
    {
      "url": "https://classiccars.com/listings/find/all-years/chevrolet/corvette"
    }
  ],
  "max_items": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/classiccars-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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