# Manheim Scraper - Public Auction Cars, VINs and Photos (`recordsdata/manheim-scraper`) Actor

Scrape the Manheim public auction: live vehicle lots with VIN, make, model, year, mileage, condition grade, title status, photos, lane and run number, plus sale schedules and Manheim locations. Filter by make, year, mileage, grade, body type and sale day. Export JSON, CSV or Excel.

- **URL**: https://apify.com/recordsdata/manheim-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.00 / 1,000 auction lot records

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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Manheim Scraper: Public Auction Cars, VINs and Condition Grades

> Manheim Scraper is an Apify Actor that extracts vehicle lots from the Manheim Public Auction (publicauction.manheim.com), the lanes of 23 Manheim locations in the United States that are open to the public. Each lot row has the VIN, year, make, model, mileage, condition grade, title status, lane and run number, sale date, seller type and the photo list. It also returns sale schedules and Manheim location pages. No login, proxy or browser is needed. Pay per result.

Export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API. The actor does not touch the dealer-only Manheim products (Manheim Market, OVE, MMR valuations), which need a dealer login.

### What can you scrape from Manheim?

- **Auction lots (`lot`)**: the cars, trucks, vans and SUVs listed for the next public sale of each location, with VIN, odometer, condition grade, announcements, title status and brandings, AutoCheck summary, lane, run number, sale date and time, and the full photo list. On 2026-10-19 the feed held 2,163 lots at 9 of the 23 locations, 779 of them at Baltimore-Washington. On 2026-10-23 it held 1,279 lots at 6 locations.
- **Condition report and build (`lot-detail`, optional)**: the damage list, tires with tread depth, key count, paint type, interior odor, emissions and the decoded build (engine, transmission, equipment, MSRP, warranty).
- **Sales (`sale`)**: one row per location and sale day with the lot count, the lanes, and the top makes, body types and seller types.
- **Locations (`location`)**: the Manheim auction sites with address, coordinates, phone, fax, office and gate hours, sale days and social links. The site lists 83 United States locations.
- **Lot changes (`lot-change`)**: with monitoring on, a repeat run returns only new lots, and a lot whose status, sale day, lane, run number, grade or bid moved comes back with the previous values.

### Why use this Manheim scraper?

- **Public data only**: no login, no dealer licence, no proxy. A burst of 44 cloud requests without proxy on 2026-10-19 returned HTTP 200 every time.
- **Real filters**: 23 public auction locations, makes, model text, model year range, mileage range, minimum condition grade, body types, seller types, keyword, sale date and as-is lots, with 7 sort orders. Every filter was checked against the rows it returns.
- **Complete scans**: one location is read 100 lots per page with a sort that has no ties, so a 779-lot sale comes back with no lot missing and none repeated.
- **Look up by VIN or lot id**: paste 17-character VINs, lot addresses or lot ids. A lot of a sale that is already over still answers, with status `Sold` or `No Sale`.
- **Honest mileage**: when Manheim marks the true mileage as unknown or the vehicle as odometer exempt, `mileageNotActual` is `true` and the placeholder reading (999999 or 1) is left out.
- **Privacy built in**: seller names are shown for businesses such as lenders, fleets and agencies. The name of an individual seller is never output.

### How to scrape Manheim public auction lots in four steps

1. Open the actor on Apify and choose **What to collect**, usually **Auction lots (vehicles)**.
2. Pick one or more **Public auction locations**, or leave them empty for all 23, and set filters such as make, model year or condition grade.
3. Set the maximum number of items and click **Start**.
4. Download the dataset from the **Storage** tab.

A minimal input that returns the best-graded late-model Toyota and Honda lots at Baltimore-Washington:

```json
{
  "mode": "lots",
  "locations": ["BWAE"],
  "makes": ["Toyota", "Honda"],
  "yearFrom": 2020,
  "maxMileage": 60000,
  "minCondition": 3.5,
  "sortBy": "condition-best",
  "maxItems": 100
}
```

### Four ways to collect data

| Mode (`mode`) | Use it to | Record types |
|---|---|---|
| `lots` | List the lots of the chosen locations and filter them | `lot`, `lot-detail`, `lot-change` |
| `sales` | See one row per location and sale day with lanes and lot counts | `sale` |
| `locations` | List the Manheim sites with address, hours and sale days | `location` |
| `urls` | Read public auction addresses, single lots, lot ids, VINs or location pages that you list | `lot`, `lot-detail`, `location` |

A location with no sale scheduled returns no lots. Most of the 23 locations are empty between sale weeks, so leave the locations field empty or choose the ones that sell this week.

### What data do you get from Manheim?

Every row has a `recordType`: `lot`, `lot-detail`, `lot-change`, `sale` or `location`. Fields that do not apply to a record type are left out, never filled with empty values.

| Field | Description |
|---|---|
| `listingId`, `url`, `title`, `imageUrl` | Lot id such as `Simulcast.BWAE.14084279`, address, title and cover photo |
| `year`, `make`, `model`, `trim`, `vehicleType` | Vehicle identity and type such as `car`, `truck`, `van` or `motorcycle` |
| `bodyType`, `driveType`, `fuelType`, `transmission`, `engineSize`, `engine`, `doors`, `seats`, `color`, `interiorColor` | Build and colors |
| `vin`, `owners`, `features` | VIN, owner count from AutoCheck and the option list |
| `mileage`, `mileageUnit`, `mileageNotActual` | Odometer reading, its unit, and a flag when the reading is not the true mileage |
| `conditionGrade`, `conditionReportUrl`, `lights`, `announcements` | Grade, report link, light colors and auction announcements |
| `titleStatus`, `titleBrandings`, `isSalvage`, `hasFrameDamage`, `hasPriorPaint`, `isDrivable`, `isInop`, `isCertified`, `asIs` | Title and damage flags |
| `autocheckScore`, `accidentCount`, `odometerCheckOk`, `titleCheckOk`, `usageCheckOk` | AutoCheck summary |
| `auctionId`, `auctionName`, `saleId`, `saleName`, `saleType`, `saleDate`, `auctionStartTime`, `auctionEndTime` | Location code and name, sale and its schedule |
| `laneNumber`, `runNumber`, `laneName`, `status`, `isClosedSale`, `isSold` | Place in the sale and lot status (`Live`, `Sold`, `No Sale`) |
| `price`, `currentBid`, `bidIncrement`, `currency` | Filled only when the feed carries a bid or a sale amount |
| `sellerName`, `sellerType`, `sellerCity`, `sellerState`, `consignor` | Business seller, its type and home city |
| `locationName`, `address`, `city`, `region`, `postalCode`, `latitude`, `longitude` | Where the lot is parked |
| `images`, `imageCount`, `publishedAt`, `updatedAt`, `scrapedAt` | Photo list, photo count, listing dates and extraction time |

#### Sample output

A real `lot` row from a cloud run (photo list and options shortened):

```json
{
  "imageUrl": "https://images.cdn.manheim.com/20261005134521-da773330-8be1-4481-a9dd-9891cf45d455.jpg",
  "recordType": "lot",
  "title": "2023 Kia Forte LXS",
  "listingId": "Simulcast.BWAE.14084279",
  "url": "https://publicauction.manheim.com/locations/BWAE#/details/3KPF24AD9PE589368/Simulcast",
  "sourceSite": "manheim.com",
  "vehicleType": "car",
  "year": 2023,
  "make": "Kia",
  "model": "Forte",
  "trim": "LXS",
  "fuelType": "Gasoline",
  "transmission": "CVT",
  "mileage": 56743,
  "mileageUnit": "mi",
  "vin": "3KPF24AD9PE589368",
  "features": ["Driver Air Bag", "Power Windows", "AM/FM Stereo"],
  "auctionId": "BWAE",
  "auctionName": "Manheim Baltimore-Washington",
  "saleDate": "2026-10-20",
  "laneNumber": 8,
  "runNumber": 1,
  "status": "Live",
  "conditionGrade": 3.6,
  "lights": ["green"],
  "autocheckScore": 88,
  "sellerName": "Glenmont Financial Services",
  "sellerType": "Finance",
  "region": "MD",
  "images": ["https://images.cdn.manheim.com/20261005134521-da773330-8be1-4481-a9dd-9891cf45d455.jpg"],
  "imageCount": 38,
  "scrapedAt": "2026-10-19T15:39:54.924Z"
}
```

Lots are listed before their lane runs, so `currentBid` and `price` carry a value only when the feed has one. None of the 2,163 lots read on 2026-10-19 had a bid or a price. Once a sale is over, its lots leave the search and only a lookup by lot id still answers, with `status` `Sold` or `No Sale` and no amount.

### Monitor new lots and lot changes

Switch on **Only new rows (monitor)** and the actor remembers every lot it delivered, in a named key-value store of your own account. Scheduled runs of the same search return only unseen lots. Add **Report lot changes** and a lot whose status, sale day, lane, run number, grade or bid changed comes back as a `lot-change` row with the previous values. Skipped lots are never charged, so keep scheduled searches narrow and run them once or twice a day before each sale.

### How does it compare with other Manheim scrapers?

Rival read on 2026-10-19: [getdataforme/maheim-details-spider](https://apify.com/getdataforme/maheim-details-spider) is the only Store actor that mentions the Manheim domain. It has 4 users in total and 0 in the last 30 days, 17 output fields about the page owner (organization name, logo, social links) and no vehicle fields, and its main event costs $0.09 per result plus $0.05 per start.

| | Manheim Scraper | getdataforme Manheim spider |
|---|---|---|
| Source | Manheim Public Auction and Manheim location pages | Manheim domain pages |
| Record types | Lots, condition reports, sales, locations, lot changes | One page record |
| Vehicle fields (VIN, mileage, grade, photos) | Yes | No |
| Filters | Location, make, model, year, mileage, grade, body, seller, keyword, sale day | None stated |
| VIN lookup and monitoring | Built in | Not in its output |

Choose this actor for public auction lots with condition grades, AutoCheck summaries and sale schedules. It does not return dealer-only data such as MMR valuations.

### Is it legal to scrape Manheim? Limits and responsible use

The actor reads the public pages and the public search endpoint of the Manheim Public Auction web app. It does not log in, hold a dealer account or bypass any protection, and it makes one request at a time with a short pause. The Manheim terms bind registered buyers, and no terms for anonymous visitors were found when this actor was built. Seller names are shown only for businesses, and staff contacts of locations appear only when you switch on **Include contact details**. You are responsible for using the data in line with the site terms and United States data protection law.

Limits:

- Only the 23 public auction locations are covered. Dealer-only inventory is out of reach.
- The actor does not request or output MMR, retail valuation or invoice figures.
- Lots exist only before and during the sale week of a location. Empty locations return no rows.
- Bids and prices are not published before the sale, and lots disappear from the search once the sale is over.
- Free Apify plans are limited to 10 items per run.

### Use with AI agents (MCP)

Connect the Apify MCP server to Claude, Cursor or another MCP client and this actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/manheim-scraper`.

Example prompt: "List the 20 best-graded Toyota and Honda lots from 2020 or newer at Manheim Baltimore-Washington with under 60,000 miles, and show VIN, grade, mileage and lane." The agent sends `{ "mode": "lots", "locations": ["BWAE"], "makes": ["Toyota", "Honda"], "yearFrom": 2020, "maxMileage": 60000, "sortBy": "condition-best", "maxItems": 20 }` and analyzes the rows.

### Run it from code

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/manheim-scraper').call({
    mode: 'lots',
    locations: ['BWAE'],
    makes: ['Toyota'],
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].conditionGrade, items[0].laneNumber);
```

You can also use the Python client, Make, Zapier or n8n, or schedule the actor from the Apify Console.

### Frequently Asked Questions

#### Which Manheim vehicles can I scrape?

The lots of the Manheim Public Auction, the lanes that 23 Manheim locations open to the public across the United States. Each row names its location in `auctionId`. Dealer-only inventory that needs a licence is not covered, because it is not public.

#### Do I need a proxy, a login or an API key?

No. The actor makes plain HTTP requests to the public auction app and needs no proxy, browser or Manheim account. You only need an Apify account, and the free plan returns up to 10 items per run.

#### Is it legal to scrape Manheim?

The actor reads publicly visible auction lots and does not log in. The Manheim terms bind registered buyers and no terms for anonymous visitors were found, but you remain responsible for how you use the data. Seller names are shown only for businesses, and personal contacts stay out unless you switch them on for location pages.

#### How much does a run cost?

The actor is billed per result: one event for each lot, condition report, lot change, sale and location row. The Pricing tab of the actor page shows the live rate. Error rows, empty searches and monitoring skips are never charged.

#### Why does a location return no lots?

Public auction lots exist only around the sale week of each location. On 2026-10-23 Baltimore-Washington had 595 lots, Ohio 462, Fredericksburg 93, Harrisonburg 70, Maryland 49 and Cleveland 10, and the other 17 locations had none. An empty search ends as succeeded with an empty dataset and charges nothing.

#### Can I get the final sale price of a lot?

No price is published before the sale and the search drops the lots once the sale ends. A lookup by lot id of a finished sale returns `status` `Sold` or `No Sale` without an amount. Monitor mode with **Report lot changes** tells you when the status, lane or bid of a lot moves.

#### How many lots can I get in one run?

All the lots of the chosen locations. The largest sale read, Baltimore-Washington on 2026-10-19, had 779 lots and came back complete in one run. Set **Maximum items** to what you need.

#### Can I get only the lots added since my last run?

Yes. Switch on **Only new rows (monitor)** and keep the same search settings or the same **Monitor name**. Add **Report lot changes** to also get a row when a lot changes. Skipped lots are never charged.

#### What is in the condition report rows?

Turn on **Add condition report and build details** and every lot also gives a `lot-detail` row with the damage list, tires, key count, grade text and the decoded build: engine, transmission, equipment, MSRP and warranty. It adds one row per lot and makes the run slower.

#### What happens when the search finds nothing or the input is wrong?

A search with no hits ends as succeeded with an empty dataset and charges nothing. A wrong input, for example a year range where the start is after the end, ends as succeeded with one free error row that explains the problem.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com. Reviews on the actor page help other people find it.

This actor is an independent tool and is not affiliated with Manheim or Cox Automotive.

# Actor input Schema

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

lots = the vehicles listed for the public auction of each location, found by the filters below. sales = one row per location and sale day (lanes, lot count, makes, body types). locations = the Manheim auction sites (address, hours, sale days). urls = lot, VIN, location or public auction addresses that you list.

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

Stops after this many rows (all record types together; with condition reports on, each lot gives two rows). Free plans are limited to 10 items per run.

## `locations` (type: `array`):

Manheim locations whose lanes are open to the public (lots and sales modes). Empty means all of them. A location with no sale scheduled returns no lots.

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

Keeps only lots of these makes, for example Toyota, Ford, BMW. Case and accents do not matter. Empty means every make. If none of the locations lists a make you typed, the run returns one note with the makes available now.

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

Keeps only lots whose model, trim or title contains this text, for example Camry, F-150 or Model 3. Works best together with a make. Empty means every model.

## `yearFrom` (type: `integer`):

Only vehicles of this model year or newer, for example 2020. Empty means no limit.

## `yearTo` (type: `integer`):

Only vehicles of this model year or older, for example 2024. Empty means no limit.

## `minMileage` (type: `integer`):

Odometer reading from this value up, in the unit the lot uses (miles for nearly all lots). Empty means no limit.

## `maxMileage` (type: `integer`):

Odometer reading up to this value, for example 60000. Empty means no limit.

## `minCondition` (type: `number`):

Manheim condition grade from 0 to 5, for example 3.5. Lots without a grade are left out when this is set. Empty means no limit.

## `bodyTypes` (type: `array`):

Body styles as Manheim writes them, for example SUV, Sedan, Pickup, Coupe, Van or Hatchback. Empty means every body type.

## `sellerTypes` (type: `array`):

Type of consignor, for example Fleet/Lease, Finance, Credit Union, Bank, Government Agency, Captive Finance, Independent. Empty means every type.

## `keyword` (type: `string`):

Free text searched in the lot data (make, model, trim, options, announcements), for example hybrid or leather. Empty means no text filter.

## `saleDate` (type: `string`):

Only lots that run on this day, written YYYY-MM-DD, for example 2026-10-27. Empty means every scheduled sale day.

## `asIsOnly` (type: `boolean`):

Only lots sold as is (no arbitration).

## `sortBy` (type: `string`):

Order of the lots inside each location. Sale order follows the lanes and run numbers of the auction.

## `includeConditionReport` (type: `boolean`):

On: every lot also gives an auction-lot-detail-record with the damage list, tires, keys, the decoded build (engine, transmission, equipment, MSRP, warranty) and the grade text. Slower runs and one extra row per lot. Off: lot rows only.

## `includeContactDetails` (type: `boolean`):

Locations mode: adds the staff names, titles, phone numbers and the email addresses printed on the location pages. Off keeps them out. Main line and fax numbers of a location are always included. Names of individual sellers are never output.

## `publicAuctionOnly` (type: `boolean`):

Locations mode: keeps only the sites that sell to the public through publicauction.manheim.com.

## `states` (type: `array`):

Locations mode: keeps only locations in these states, written as the two-letter code or the full name, for example MD or Maryland. Empty means every state.

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

urls mode. A public auction (https://publicauction.manheim.com/locations/BWAE), a lot (https://publicauction.manheim.com/listings/id/Simulcast.BWAE.14084279), a lot by VIN or a location page of site.manheim.com (https://site.manheim.com/locations/manheim-baltimore-washington/).

## `vins` (type: `array`):

urls mode. 17-character VINs. Each one is looked up in the public auction listings. A VIN that is not listed returns one note.

## `onlyNew` (type: `boolean`):

Skips every lot seen in an earlier run with the same monitor name, so scheduled runs return only the lots that are new.

## `trackChanges` (type: `boolean`):

Needs Only new rows. A lot seen before whose status, sale day, lane, run number, grade or bid changed comes back as a lot-change-record with the previous values.

## `stateKey` (type: `string`):

Name of the memory used by Only new rows. Use one name per saved search. Empty derives a name from your filters.

## `resetSeen` (type: `boolean`):

Clears the memory of the monitor name before this run.

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

Off by default: Manheim answers requests from Apify servers directly. Turn it on only if you see blocked requests in the log.

## Actor input object example

```json
{
  "mode": "lots",
  "maxItems": 10,
  "locations": [
    "BWAE"
  ],
  "makes": [],
  "model": "",
  "bodyTypes": [],
  "sellerTypes": [],
  "keyword": "",
  "saleDate": "",
  "asIsOnly": false,
  "sortBy": "lane-run",
  "includeConditionReport": false,
  "includeContactDetails": false,
  "publicAuctionOnly": false,
  "states": [],
  "startUrls": [],
  "vins": [],
  "onlyNew": false,
  "trackChanges": false,
  "stateKey": "",
  "resetSeen": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "maxItems": 10,
    "locations": [
        "BWAE"
    ],
    "makes": [],
    "bodyTypes": [],
    "sellerTypes": [],
    "states": [],
    "startUrls": [],
    "vins": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/manheim-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 = {
    "maxItems": 10,
    "locations": ["BWAE"],
    "makes": [],
    "bodyTypes": [],
    "sellerTypes": [],
    "states": [],
    "startUrls": [],
    "vins": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/manheim-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 '{
  "maxItems": 10,
  "locations": [
    "BWAE"
  ],
  "makes": [],
  "bodyTypes": [],
  "sellerTypes": [],
  "states": [],
  "startUrls": [],
  "vins": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/manheim-scraper --silent --output-dataset

```

## MCP server setup

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