# 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
- **Features:** Limited permissions
- **Stats:** 6 total users, 3 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. Dealer-only products (OVE, MMR valuations) are not touched.

### 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, grade, title status, AutoCheck summary, lane, run number, sale time and photos. On 2026-10-19 the feed held 2,163 lots at 9 of the 23 locations.
- **Condition report and build (`lot-detail`, optional)**: the damage list, tires, key count and the decoded build (engine, 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 83 Manheim sites with address, coordinates, phone, hours, sale days and social links.
- **Lot changes (`lot-change`)**: with monitoring on, a repeat run returns only new lots, and a moved lot comes back with its previous values.

### Why use this Manheim scraper?

- **Public data only**: no login, no dealer licence, no proxy.
- **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.
- **Complete scans**: a 779-lot sale comes back with no lot missing and none repeated.
- **Look up by VIN or lot id**: a lot of a sale that is already over still answers, with status `Sold` or `No Sale`.
- **Honest mileage**: when the true mileage is unknown or the vehicle is odometer exempt, `mileageNotActual` is `true` and the placeholder reading is left out.
- **Privacy built in**: only business sellers are named, never an individual.

### 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.

Input for 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` |

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 are left out.

| 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`) |
| `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:

```json
{
  "recordType": "lot",
  "title": "2023 Kia Forte LXS",
  "listingId": "Simulcast.BWAE.14084279",
  "vehicleType": "car",
  "year": 2023,
  "make": "Kia",
  "model": "Forte",
  "trim": "LXS",
  "transmission": "CVT",
  "mileage": 56743,
  "mileageUnit": "mi",
  "vin": "3KPF24AD9PE589368",
  "auctionId": "BWAE",
  "saleDate": "2026-10-20",
  "laneNumber": 8,
  "runNumber": 1,
  "status": "Live",
  "conditionGrade": 3.6,
  "lights": ["green"],
  "autocheckScore": 88,
  "sellerType": "Finance",
  "region": "MD",
  "imageCount": 38,
  "scrapedAt": "2026-10-19T15:39:54.924Z"
}
```

The dataset has 149 fields across the 5 record types, and each row carries only the ones that apply. There are no price or bid fields: Manheim publishes no bid or price for a lot before its sale, and none of the 2,163 lots read on 2026-10-19 had one. 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.

### Input

The form has 27 inputs. These are the most used; the rest are in the input form of the actor page.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `mode` | string | `lots` | What to collect: `lots`, `sales`, `locations` or `urls` |
| `maxItems` | integer | 50 | Maximum results (free plans: 10) |
| `locations` | array | empty (all 23) | Public auction location codes such as `BWAE` |
| `makes` / `model` | array / string | empty | Makes and model text |
| `yearFrom` / `yearTo` | integer | none | Model year range |
| `minMileage` / `maxMileage` | integer | none | Odometer range in miles |
| `minCondition` | number | none | Minimum condition grade, for example 3.5 |
| `bodyTypes` / `sellerTypes` | array | empty | Body and seller type filters |
| `keyword`, `saleDate`, `asIsOnly` | string, string, boolean | empty, empty, `false` | Free text, sale day, as-is lots |
| `sortBy` | string | `lane-run` | One of 7 sort orders, for example `condition-best` |
| `includeConditionReport` | boolean | `false` | Add a `lot-detail` row per lot |
| `startUrls` / `vins` | array | empty | Lot links, auction pages, location pages, 17-character VINs (urls mode) |
| `onlyNew`, `trackChanges`, `stateKey`, `resetSeen` | mixed | off | Monitor settings |

### 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 return only unseen lots. Add **Report lot changes** and a changed lot comes back as a `lot-change` row with the previous values. Run it once or twice a day before each sale.

### How much does the Manheim Scraper cost?

Pay per result, no monthly fee. The Pricing tab of the actor page shows the live rate.

| Event | Charged for | Price per result | Per 1,000 results |
|---|---|---|---|
| Auction lot record | One public auction lot | $0.022 | $22.00 |
| Auction lot detail record | One condition report, from a lot link or a VIN | $0.0374 | $37.40 |
| Lot change record | One new or changed lot in monitor mode | $0.022 | $22.00 |
| Auction sale record | One location and sale day | $0.0176 | $17.60 |
| Auction location record | One Manheim location | $0.0176 | $17.60 |

Worked examples:

- 1,000 lots: 1,000 x $0.022 = $22.00.
- The whole Baltimore-Washington sale of 779 lots: 779 x $0.022 = $17.14.
- 100 lots with a condition report each: 100 x $0.022 + 100 x $0.0374 = $2.20 + $3.74 = $5.94.
- All 83 locations: 83 x $0.0176 = $1.46.

Error rows and empty searches are free.

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

No Store actor is dedicated to the Manheim Public Auction. Rivals read on 2026-10-23 from the Store API:

| | Manheim Scraper | memo23/copart-scraper | getdataforme/maheim-details-spider |
|---|---|---|---|
| Source | Manheim Public Auction | Copart auctions | Manheim domain pages |
| Users in the last 30 days | 0 | 41 | 0 |
| Vehicle fields (VIN, mileage, grade, photos) | Yes, 149 fields | Yes, other site | No, page-owner metadata |
| Main price | $0.022 per lot | about $0.00075 per item plus $0.009 per start | $0.09 per item plus $0.05 per start |
| Condition report, sales, locations, monitoring | Built in | Extra data is a paid add-on | No |

Our price per lot is higher than Copart's: a 50-lot Copart run costs about $0.00093 per lot, against $0.022 here. Copart is a different auction site, so it cannot return Manheim lots. The Manheim page-spider returns no vehicle data. Choose this actor for Manheim public auction lots with condition grades, AutoCheck summaries and sale schedules.

### 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 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. 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 and MMR or retail valuations are out of reach.
- Lots exist only around the sale week of a location. Empty locations return no rows.
- No bids or prices exist before the sale, and lots leave 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."

### 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'], maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].conditionGrade);
```

Python client, Make, Zapier, n8n and Apify schedules also work.

### 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, such as OVE and MMR valuations, is not covered and is not requested.

#### 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. A burst of 44 cloud requests without proxy returned HTTP 200 every time. 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 none for anonymous visitors were found, but you remain responsible for how you use the data. Only business sellers are named, never individuals, and staff contacts stay out unless you switch them on.

#### How much does a run cost?

The actor is billed per result. A lot row costs $0.022, which is $22.00 per 1,000 lots, and a condition report adds $0.0374 per lot. Sale and location rows cost $0.0176 each. A full Baltimore-Washington sale of 779 lots costs $17.14. Error rows, empty searches and monitoring skips are never charged, and the Pricing tab shows the live rate.

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

Public auction lots exist only around the sale week of each location. On 2026-10-23 six locations held lots (Baltimore-Washington 595, Ohio 462) and the other 17 had none. An empty search ends as succeeded with an empty dataset and charges nothing, so scheduling around sale weeks is safe and cheap to test.

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

No. Manheim publishes no price or bid for a lot before its sale, and the search drops the lots once the sale ends, so the actor has no price fields and promises no sold prices. A finished lot looked up by id returns `Sold` or `No Sale` without an amount. Monitor mode with **Report lot changes** tells you when the status, sale day, lane, run number or grade of a lot moves.

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

All the lots of the chosen locations, up to the inventory that is live. The largest sale read, Baltimore-Washington on 2026-10-19, had 779 lots and came back complete in one run. A 3-row run takes a median of 2.6 seconds. 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**. A second run with the same input returns 0 rows and charges nothing. Add **Report lot changes** to also get a `lot-change` row when a lot moves.

#### 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 and the decoded build: engine, transmission, equipment, MSRP and warranty. It adds one billed 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, such as reversed years or a malformed VIN, 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.

Last updated: 2026-10-23

# 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`):

How many rows to return, for example 100. Free plan: capped at 10 per run. With condition reports on, each lot gives two rows.

## `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.

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

Only lots selling that day. Example: 2026-10-27. Empty means every scheduled day.

## `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.

## `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.

## `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.

## `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.

## `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.

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

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

## `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.

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

Example: https://publicauction.manheim.com/locations/BWAE. Used only in the addresses mode.

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

Example: 1HGCM82633A004352. Used only in the addresses mode.

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

On: each lot also returns a detail row with damage list, tires, keys and decoded build. Doubles the rows (and billed events) per lot.

## `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"
  ],
  "saleDate": "",
  "makes": [],
  "model": "",
  "keyword": "",
  "bodyTypes": [],
  "sellerTypes": [],
  "asIsOnly": false,
  "sortBy": "lane-run",
  "states": [],
  "publicAuctionOnly": false,
  "includeContactDetails": false,
  "startUrls": [],
  "vins": [],
  "includeConditionReport": false,
  "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/KFqDeJJF8kokxbWH0/openapi.json