# Mecum Scraper \[$5/1K💰] | Barrett-Jackson | Sold Prices (`ahmed_jasarevic/mecum-scraper`) Actor

Scrape Mecum and Barrett-Jackson collector-car auction lots with VINs, estimates, hammer prices, sale dates and photo galleries. Build comparable-sales databases and value classic cars from real results.

- **URL**: https://apify.com/ahmed_jasarevic/mecum-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.80 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Mecum Scraper

Scrape Mecum Auctions and Barrett-Jackson collector-car lots — VINs, engine and transmission, estimates, hammer prices, sale dates and photo galleries — from both auction houses into one clean dataset.

### Build A Collector-Car Comparable-Sales Database

- Build a comparable-sales database across Mecum and Barrett-Jackson in one run
- Track hammer prices, estimates and sell-through by make, model or auction event
- Value a classic car with real auction results instead of asking prices
- Monitor upcoming catalogues and no-reserve lots before the sale
- Feed dealer pricing, insurer underwriting or marketplace inventory models

### How It Works

![How the Mecum Scraper turns an auction house and event into a dataset of collector-car lots with VINs, estimates and sold prices.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-mecum-scraper.webp)

The Actor collects publicly available collector-car auction lots from Mecum and Barrett-Jackson and normalizes them into one schema. Choose an auction house, event and lot type; it reads the published catalogue and results, then writes one row per lot.

- `source` selects Mecum, Barrett-Jackson or both.
- `mode` switches Barrett-Jackson between completed results and the upcoming docket.
- `auctionSlug` and `eventSlug` narrow the run to one event; `soldOnly` keeps only sold lots.

Each row is one auction lot with vehicle identity, VIN, drivetrain, mileage, colours, estimate range, high bid, hammer price, reserve status, sale date, event, venue and photo gallery. Export the dataset as JSON, CSV or Excel, or read it through the Apify API.

### Scrape Mecum And Barrett-Jackson Auction Results

`source` selects the auction house:

- `mecum` — Mecum catalogue and published results.
- `barrett-jackson` — completed sales or the upcoming catalogue.
- `both` — both houses in one job and a shared `maxItems` budget.

`mode` applies to Barrett-Jackson only: `results` returns completed auctions with sold prices, `docket` returns the upcoming catalogue. Mecum lots always come from the live catalogue plus published results.

### Track Hammer Prices, Estimates And Sell-Through

Every lot carries the numbers needed for market analysis:

- `estimateLow` / `estimateHigh` — the pre-sale estimate range in USD when the source publishes one
- `highBid` — the highest live bid, when the source exposes it
- `soldPrice` — the hammer/sold price published by the source; it is not recalculated and buyer-premium treatment is not normalized
- `reserve` — reserve status such as `No Reserve`
- `lotStatus` — `sold`, `unsold`, `withdrawn`, `upcoming`, `bid_goes_on` or `unknown`
- `saleResult` — the raw sale-result label from the source

Mecum estimates are only present on lots that carry them, so many rows have `null`. Barrett-Jackson does not publish a pre-sale estimate or live high bid, so those fields are `null` for B-J lots while `soldPrice` and `reserve` are populated.

### Filter By Event, Lot Type Or Sold Status

- `auctionSlug` limits Mecum to one event, e.g. `dallas-fort-worth-2026`, `kissimmee-2027` or `las-vegas-2026`.
- `eventSlug` limits Barrett-Jackson to one event, e.g. `scottsdale-2025`.
- `eventCount` (1–10) controls how many recent Barrett-Jackson events are scraped when no `eventSlug` is given.
- `lotType` accepts `auto`, `motorcycle`, `road-art` or `all`; `auto` covers collector cars and trucks.
- `soldOnly` keeps only lots with a hammer/sold price.

### Input

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `source` | string | No | `mecum` | `mecum`, `barrett-jackson` or `both`. |
| `mode` | string | No | `results` | Barrett-Jackson only: `results` (sold prices) or `docket` (upcoming catalogue). |
| `auctionSlug` | string | No | — | Mecum auction slug, e.g. `dallas-fort-worth-2026`. Empty = newest lots across all auctions. |
| `eventSlug` | string | No | — | Barrett-Jackson event slug, e.g. `scottsdale-2025`. Empty = newest event(s). |
| `eventCount` | integer | No | `1` | Recent Barrett-Jackson events to scrape when no slug is set. 1–10. |
| `lotType` | string | No | `auto` | Mecum category: `auto`, `motorcycle`, `road-art` or `all`. |
| `soldOnly` | boolean | No | `false` | Keep only lots that actually sold. |
| `maxItems` | integer | No | `100` | Hard cap on dataset items for the run. 1–5,000. |
| `includeImages` | boolean | No | `true` | Add the lot photo gallery to each row. |
| `maxImagesPerLot` | integer | No | `40` | Gallery cap per lot. 0–120. |
| `proxy` | object | No | — | Standard Apify proxy configuration. Off by default. |

Free users get a 10-lot preview per run; paying Apify users get the full `maxItems` allowance.

### Output

One row per auction lot.

| Field | Description |
| --- | --- |
| `source`, `itemId` | `mecum` or `barrett-jackson`, and the source lot id. |
| `lotNumber`, `title` | Lot number and listing title. |
| `year`, `make`, `model`, `trim`, `bodyType` | Decoded vehicle identity. |
| `vin` | VIN / serial number when published. |
| `engine`, `transmission` | Drivetrain details as listed. |
| `mileage`, `mileageUnit` | Odometer value and unit (`mi` or `km`). |
| `exteriorColor`, `interiorColor` | Colours as listed. |
| `estimateLow`, `estimateHigh` | Pre-sale estimate range in USD, or `null`. |
| `highBid` | Highest live bid in USD, or `null`. |
| `soldPrice`, `currency` | Hammer/sold price and currency. |
| `reserve` | Reserve status, e.g. `No Reserve`. |
| `saleDate` | Sale/run date when the source provides it. |
| `auctionEvent`, `auctionSlug` | Auction event name and slug. |
| `auctionLocation` | `venue`, `city`, `state`, `postalCode`, `country`. |
| `lotStatus`, `saleResult` | Normalized status plus the raw source label. |
| `description` | Lot description / condition notes. |
| `imageGallery`, `mainImage` | Gallery and cover image URLs. |
| `lotUrl`, `scrapedAt` | Canonical lot page and extraction timestamp. |

### Example Input

```json
{
  "source": "both",
  "mode": "results",
  "auctionSlug": "dallas-fort-worth-2026",
  "eventSlug": "scottsdale-2025",
  "maxItems": 200,
  "includeImages": true,
  "proxy": { "useApifyProxy": false }
}
```

### Example Output

```json
{
  "source": "mecum",
  "itemId": "824052",
  "lotNumber": "S298",
  "title": "1973 Chevrolet Corvette L82 Convertible",
  "year": 1973,
  "make": "Chevrolet",
  "model": "Corvette",
  "trim": "L82",
  "bodyType": "Convertible",
  "vin": "1Z67T3S418843",
  "engine": "350/250 HP V-8",
  "transmission": "4-Speed Manual",
  "mileage": 66547,
  "mileageUnit": "mi",
  "exteriorColor": "Mille Miglia Red",
  "interiorColor": "Black",
  "estimateLow": null,
  "estimateHigh": null,
  "highBid": null,
  "soldPrice": 38500,
  "currency": "USD",
  "reserve": "No Reserve",
  "saleDate": "2026-10-24",
  "auctionEvent": "Dallas/Fort Worth 2026",
  "auctionSlug": "dallas-fort-worth-2026",
  "auctionLocation": {
    "venue": "Dickies Arena",
    "city": "Fort Worth",
    "state": "Texas",
    "postalCode": "76107",
    "country": "USA"
  },
  "lotStatus": "sold",
  "saleResult": "sold",
  "lotUrl": "https://www.mecum.com/lots/1184814/1973-chevrolet-corvette-l82-convertible/",
  "scrapedAt": "2026-10-24T09:30:00.000Z"
}
```

### Schedule Auction Monitoring And Export Results

- **Weekly price tracking** — re-run after each auction weekend and diff `soldPrice` against your last snapshot.
- **Pre-sale shortlisting** — use `mode: "docket"` for Barrett-Jackson and the Mecum catalogue to review no-reserve lots before bidding.
- **Webhooks and integrations** — the Apify API, webhooks, Zapier and Make can push new rows to Google Sheets, Airtable, a CRM or a pricing model.
- **Scheduling** — a weekly run during auction season keeps a comparable-sales table current without manual exports.

### Related Actors

- [Mecum Auctions Scraper - Collector Car Lots & Results](https://apify.com/growth-installations/mecum-auctions-scraper) — Mecum-only alternative with change monitoring.
- [Bring a Trailer Scraper - Classic Car Auctions](https://apify.com/lulzasaur/bringatrailer-scraper) — online auction comps from Bring a Trailer.
- [CLASSIC.COM Scraper — Global Classic Car Aggregator](https://apify.com/rastriq/classic-com-scraper) — 800K+ aggregated classic-car listings.
- [Collecting Cars Scraper — Online Car Auctions](https://apify.com/rastriq/collecting-cars-scraper) — European online auction results.
- [Car and Classic Scraper — Vintage & Classic Cars](https://apify.com/rastriq/carandclassic-scraper) — UK and European classic marketplace listings.

### FAQ

#### Why use this Actor instead of the official Mecum or Barrett-Jackson API?

Neither auction house offers a public, documented lot feed for third-party data teams. This Actor collects the same publicly visible lot data their websites show, normalizes both into one schema, and adds pagination, event discovery and image handling. You get one dataset instead of two integrations.

#### What are the alternatives to this Actor?

For Mecum only, `growth-installations/mecum-auctions-scraper` covers lots and results. For other marketplaces, Bring a Trailer, CLASSIC.COM, Collecting Cars and Car and Classic Actors cover different slices of the collector-car market. This Actor is the one that combines Mecum and Barrett-Jackson in a single run.

#### Does this Actor include buyer's premium in sold prices?

`soldPrice` is the value the source publishes. The Actor does not add or remove buyer premiums, taxes or fees, and premium treatment is not normalized. Verify the convention on the lot page when it matters.

#### Can I scrape one auction event only?

Yes. Set `auctionSlug` for Mecum or `eventSlug` for Barrett-Jackson. When no slug is set, Mecum returns the newest lots across all auctions and Barrett-Jackson uses the newest event(s), controlled by `eventCount`.

#### Why are estimates or high bids null for some lots?

Mecum publishes estimates only on lots that carry them. Barrett-Jackson does not publish a pre-sale estimate or live high bid, so those fields stay `null` for B-J rows while `soldPrice` and `reserve` are populated. Barrett-Jackson mileage is parsed from the description when stated.

#### How fresh is the data?

Each run reads the live source at the moment it runs. Completed lots and upcoming catalogues change as auctions open and close, so schedule runs around auction dates if you need current prices.

#### Can I get a free preview?

Yes. Free Apify users receive the first 10 lots of a run; paying users receive the full `maxItems` allowance.

### For AI Agents & LLM Apps

Returns collector-car auction lots from Mecum and Barrett-Jackson as one row per lot.

Minimal input:

```json
{ "source": "mecum", "maxItems": 25 }
```

Both houses in one run:

```json
{ "source": "both", "mode": "results", "maxItems": 100 }
```

Upcoming Barrett-Jackson catalogue only:

```json
{ "source": "barrett-jackson", "mode": "docket", "eventCount": 2, "maxItems": 50 }
```

Output fields: `source`, `itemId`, `lotNumber`, `title`, `year`, `make`, `model`, `trim`, `bodyType`, `vin`, `engine`, `transmission`, `mileage`, `mileageUnit`, `exteriorColor`, `interiorColor`, `estimateLow`, `estimateHigh`, `highBid`, `soldPrice`, `currency`, `reserve`, `saleDate`, `auctionEvent`, `auctionSlug`, `auctionLocation`, `lotStatus`, `saleResult`, `description`, `imageGallery`, `mainImage`, `lotUrl`, `scrapedAt`.

Behaviors an agent should know:

- `mode` is ignored for Mecum; it only switches Barrett-Jackson between `results` and `docket`.
- With `source: "both"`, `maxItems` is a shared budget; one house can consume it before the other starts.
- `eventSlug` overrides `eventCount` for Barrett-Jackson.
- `estimateLow`, `estimateHigh` and `highBid` are always `null` for Barrett-Jackson rows.
- `maxImagesPerLot: 0` disables the gallery even when `includeImages` is true.
- Billing: $0.005 per lot plus the one-time Actor start event; free users are capped at 10 lots.

### Legal & Compliance Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by Mecum Auctions or Barrett-Jackson. It collects only publicly visible auction lot data that the auction houses' websites show to any visitor; it does not bypass a login, paywall or CAPTCHA, and it does not submit bids or change any account state. Auction lot data can include vehicle and event information but no seller or bidder personal data. You are responsible for complying with each auction house's Terms of Service and with applicable law when you store, republish or commercialize the data.

### SEO Keywords

mecum scraper, barrett-jackson scraper, mecum auction results, collector car auction data, classic car auction prices, mecum sold prices, barrett-jackson results, auction comps database, hammer price data, collector car market research, classic car valuation data, mecum auction api, barrett-jackson api, auction lot data, vehicle auction dataset, no reserve lots, mecum kissimmee results, scottsdale auction results, car auction price tracker

# Actor input Schema

## `source` (type: `string`):

Which auction house to scrape. Mecum uses its public WPGraphQL endpoint; Barrett-Jackson uses its public JSON API.

## `mode` (type: `string`):

Barrett-Jackson only. 'results' returns completed auctions with sold prices; 'docket' returns the upcoming catalogue.

## `auctionSlug` (type: `string`):

Limit Mecum lots to one auction, e.g. "dallas-fort-worth-2026", "kissimmee-2027" or "las-vegas-2026". Leave empty for the newest lots across all auctions.

## `eventSlug` (type: `string`):

Limit Barrett-Jackson lots to one event, e.g. "scottsdale-2025" or "las-vegas-2024". Leave empty to auto-pick the newest event(s).

## `eventCount` (type: `integer`):

When no event slug is given, how many of the most recent events to scrape.

## `lotType` (type: `string`):

Mecum lot type to include. 'auto' covers collector cars and trucks.

## `soldOnly` (type: `boolean`):

Keep only lots that actually sold (has a hammer/sold price).

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

Hard cap on the number of lots written to the dataset for this run.

## `includeImages` (type: `boolean`):

Add the lot photo gallery (list of image URLs) to each dataset item.

## `maxImagesPerLot` (type: `integer`):

Cap on gallery photos stored per lot.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "source": "mecum",
  "mode": "results",
  "eventCount": 1,
  "lotType": "auto",
  "soldOnly": false,
  "maxItems": 100,
  "includeImages": true,
  "maxImagesPerLot": 40,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/mecum-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 = { "proxy": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/mecum-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 '{
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/mecum-scraper --silent --output-dataset

```

## MCP server setup

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