# AutoScout24 Scraper - EU Car Listings & Prices, No login (`cliqtomedia/car-listings-scraper`) Actor

AutoScout24 scraper for car listings in 8 EU countries. Filter by make, model, year, price and mileage. Each row has price, mileage, year, fuel, power, photos and seller info. No AutoScout24 login needed. Use only-new mode with a schedule to see new cars.

- **URL**: https://apify.com/cliqtomedia/car-listings-scraper.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 saved listings

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

AutoScout24 Car Listings Scraper finds used and new car listings on AutoScout24 in 8 EU countries by make, model, year, price and mileage, and returns one clean row per car with price, mileage, first registration, fuel, gearbox, power, location, dealer and photos.
No login, cookies or API key are needed: type a make and a model, start, and 20 listings arrive in about 10 seconds for $0.0073.

![AutoScout24 Car Listings Scraper: set make, model and country, get one row per listing with price, mileage, fuel, power and dealer](https://api.apify.com/v2/key-value-stores/wko3qCEsM8N5orFpW/records/hero.png)

### Table of contents

- [What it does](#what-it-does)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Output](#output)
- [Pricing and limits](#pricing-and-limits)
- [API, export and integrations](#api-export-and-integrations)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Support](#support)

### What it does

The Actor reads the public search results of [AutoScout24](https://www.autoscout24.com/) for Germany, Austria, Belgium, Spain, France, Italy, Luxembourg and the Netherlands. You choose a make, a model and filters. The Actor saves one Dataset row for each car listing it finds, in the order AutoScout24 shows them.

#### Good fit

- Track asking prices and mileage for one model in one or more countries.
- Watch for new listings of a car you want to buy (schedule + **Only new listings**).
- Build a list of dealers that sell a model, with their rating and location.
- Collect a price sample for valuation or market research.

#### Not a fit / limits

- No full listing page: no description text, equipment list, colour, CO2 or seller phone numbers.
- No private seller contacts. For private sellers you get only city, zip and country.
- At most 2,000 listings per run. AutoScout24 shows up to 4,000 results per search; split big searches by country, year or price.
- Other AutoScout24 markets (for example Switzerland) and other car sites are not covered.

### Quick start

1. Open the **Input** tab.
2. Type a **Make** (`make`), for example `BMW`, and a **Model** (`model`), for example `3 Series`.
3. Keep the prefilled **Country** `de` (Germany) and **Maximum listings** `20`, or change them.
4. Click **Start**.
5. Open the **Output** tab and check `title`, `price` and `mileageKm`.

Expected result: 20 rows of BMW 3 Series cars offered in Germany, newest listings first.

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Price check for one model | `make`, `model`, `country` | Car listing | `price`, `mileageKm`, `year`, `priceRating` | Export to CSV or Excel |
| Alert on new cars | `onlyNew: true` + schedule | New car listings only | `url`, `price`, `firstRegistration` | Webhook or integration on run finish |
| Dealer list for a model | `make`, `model`, `country` | Car listing from a dealer | `dealerName`, `dealerId`, `dealerRating`, `location` | Spreadsheet or CRM import |
| Narrow buying search | `yearFrom`, `priceTo`, `mileageMax`, `condition` | Car listing | `price`, `mileageKm`, `fuel`, `transmission` | API call from your app |

### Input

#### Input fields

| Field | Plain name | Type | Required | Default / prefill | Allowed values | Effect | Example | Recommendation |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `make` | Make | string | no | prefill `BMW` | Make name as on AutoScout24; `VW`, `Mercedes` also work | Limits the search to one brand | `Volkswagen` | Empty searches all makes |
| `model` | Model | string | no (needs `make`) | prefill `3 Series` | Model line (`3 Series`, `C-Class`) or model (`320`, `Golf`, `X5`) | Limits the search to one model or model line | `Golf` | An unknown name fails with suggestions |
| `country` | Country | string | no | default `all`, prefill `de` | `all`, `de`, `at`, `be`, `es`, `fr`, `it`, `lu`, `nl` | Where the car is offered | `nl` | `all` covers all 8 markets |
| `yearFrom` / `yearTo` | First registration from / to | integer | no | none | 1900–2100 | Filters by year of first registration | `2019` | `yearFrom` must not be larger than `yearTo` |
| `priceFrom` / `priceTo` | Price from / to | integer | no | none | 0–10,000,000 (EUR) | Filters by asking price | `30000` | |
| `mileageMax` | Maximum mileage | integer | no | none | 0–2,000,000 (km) | Filters by odometer | `100000` | |
| `condition` | Condition | string | no | `any` | `any`, `used`, `new` | New, used or both | `used` | |
| `sort` | Sort order | string | no | `newest` | `newest`, `price_asc`, `price_desc`, `mileage_asc`, `year_desc`, `relevance` | Order of results | `price_asc` | Keep `newest` for monitoring |
| `maxItems` | Maximum listings | integer | no | default `100`, prefill `20` | 1–2,000 | Stops after this many listings | `500` | You pay per saved listing |
| `onlyNew` | Only new listings | boolean | no | `false` | `true`, `false` | Returns only listings not seen in earlier runs of the same search | `true` | Use with a schedule |
| `stateKey` | History name | string | no | none | letters, digits, `-`, `_` | Name for the **Only new listings** history | `bmw-3-de` | Set it to keep the history when you change filters |

An empty input searches all makes in all 8 countries and returns the 100 newest listings.

#### Interacting settings

| When | Input A | Input B | Effective behavior | Example | Cost/result effect |
| --- | --- | --- | --- | --- | --- |
| Monitoring | `onlyNew: true` | `sort: newest` | Reading stops at the first page with no new listings | Second run of the same search | Unchanged search costs only the run start |
| Monitoring, other order | `onlyNew: true` | `sort` other than `newest` | Reading stops after 5 pages in a row with no new listings; new cars further down can be missed | `price_asc` | Unchanged search costs only the run start |
| History name | `onlyNew: true` | `stateKey` | Without `stateKey`, each set of filters has its own history; with it, the history stays when filters change | `stateKey: "bmw-3-de"` | none |
| Model | `model` | `make` | `model` needs `make`; it is matched inside that make | `make: "Mercedes-Benz"`, `model: "C-Class"` | none |
| Spending cap | `maxItems` | Max cost per run (Apify option) | The run stops at whichever comes first | `maxItems: 2000`, cap $0.10 | Rows above the cap are not saved and not charged |

#### Input examples

##### Price check for one model

```json
{
  "make": "BMW",
  "model": "3 Series",
  "country": "de",
  "maxItems": 20
}
```

Expected behavior: the Actor reads the first search page for BMW 3 Series in Germany.
Expected output: 20 car listings with `price`, `mileageKm`, `firstRegistration`, `fuel`, `dealerName`.
Limit or cost note: about 10 seconds, $0.0073.

##### Daily alert for new cars

```json
{
  "make": "Volkswagen",
  "model": "Golf",
  "country": "nl",
  "yearFrom": 2020,
  "priceTo": 20000,
  "maxItems": 200,
  "onlyNew": true
}
```

Expected behavior: the first run saves up to 200 newest listings and remembers them. Later runs save only listings that were not there before.
Expected output: new car listings only; an unchanged search gives an empty Dataset and status `NO_RESULTS`.
Limit or cost note: an unchanged run costs $0.0025 (run start only).

### Output

#### Output fields

| Field | Meaning | Type | Can be empty? | Example / enum | Source / notes |
| --- | --- | --- | --- | --- | --- |
| `id` | AutoScout24 listing id | string | no | `ffb3f43b-…` | From the listing URL |
| `url` | Listing page | string | no | `https://www.autoscout24.com/offers/…` | |
| `title` | Make, model and version | string | no | `BMW 320 d Touring Advantage` | |
| `make` | Make | string | yes | `BMW` | Spelling as on AutoScout24 (`Skoda`) |
| `model` | Model | string | yes | `320` | null when AutoScout24 lists the car under the make only |
| `modelGroup` | Model family | string | yes | `3 Series` | |
| `version` | Version text from the seller | string | yes | `d Touring Advantage` | |
| `price` | Asking price | integer | yes | `19299` | null when no price is shown, never 0 |
| `currency` | Currency | string | yes | `EUR` | |
| `priceRating` | AutoScout24 price rating | string | yes | `top-price`, `good-price` | Only when shown |
| `mileageKm` | Odometer, km | integer | yes | `112257` | Pre-registered cars can have 0 km |
| `firstRegistration` | First registration | string | yes | `2021-02` | `YYYY-MM`; null for new cars without registration |
| `year` | Year of first registration | integer | yes | `2021` | |
| `fuel` | Fuel type | string | yes | `Diesel`, `Gasoline`, `Electric/Gasoline` | |
| `transmission` | Gearbox | string | yes | `Automatic`, `Manual` | |
| `powerKw` / `powerHp` | Engine power | integer | yes | `140` / `190` | |
| `engineCc` | Engine size, cm3 | integer | yes | `1995` | Often null for electric cars |
| `offerType` | Offer type | string | yes | `used`, `new`, `demonstration`, `pre_registered`, `employee_car`, `classic` | |
| `location` | Where the car is | object | no | `{"countryCode":"DE","zip":"21614","city":"Buxtehude"}` | `street` only for dealers |
| `sellerType` | Seller type | string | yes | `dealer`, `private` | |
| `dealerName` / `dealerId` | Dealer | string | yes | `Example Autohaus` | Always null for private sellers |
| `dealerRating` / `dealerReviewCount` | Dealer rating | number / integer | yes | `5` / `9` | Only when shown |
| `images` / `imageCount` | Photo URLs (720×540) and their count | array / integer | no (can be `[]`) | | From the search result |
| `source` | Source | string | no | `autoscout24` | |
| `fetchedAt` | When the row was read | string | no | `2026-10-15T00:54:34Z` | ISO 8601, UTC |

#### Output entities and surfaces

| Situation | Dataset/API/KVS/live view | Result shape | User action |
| --- | --- | --- | --- |
| Normal item | Dataset (**Output** tab) | One row per car listing | Open, export or call the API |
| No listings match | Dataset empty; `RUN_SUMMARY` status `NO_RESULTS` | Run SUCCEEDED | Widen the filters |
| Nothing new (`onlyNew`) | Dataset empty; `RUN_SUMMARY` status `NO_RESULTS` | Run SUCCEEDED | Nothing to do; next run checks again |
| Stopped early (time or spending cap) | Dataset with saved rows; `RUN_SUMMARY` status `PARTIAL`, reason `TIME_LIMIT` or `CHARGE_LIMIT` | Run SUCCEEDED | Raise the cap or split the search |
| Wrong make or model | `RUN_SUMMARY` status `INVALID_INPUT` with suggestions | Run FAILED, no rows | Fix the name and start again |
| AutoScout24 not reachable | `RUN_SUMMARY` status `ERROR`, or `PARTIAL` with reason `SOURCE_ERROR` when rows were saved; saved rows stay | Run FAILED | Start again later |

#### Output example

```json
{
  "id": "ffb3f43b-6b16-4b35-84f1-e1ac2706c187",
  "url": "https://www.autoscout24.com/offers/bmw-320-d-touring-advantage-hifi-dab-spur-diesel-black-cat_ma13mo1641-ffb3f43b-6b16-4b35-84f1-e1ac2706c187",
  "title": "BMW 320 d Touring Advantage / HIFI / DAB / Spur",
  "make": "BMW",
  "model": "320",
  "modelGroup": "3 Series",
  "version": "d Touring Advantage / HIFI / DAB / Spur",
  "price": 19299,
  "currency": "EUR",
  "priceRating": "top-price",
  "mileageKm": 112257,
  "firstRegistration": "2021-02",
  "year": 2021,
  "fuel": "Diesel",
  "transmission": "Automatic",
  "powerKw": 140,
  "powerHp": 190,
  "engineCc": 1995,
  "offerType": "used",
  "location": { "countryCode": "DE", "zip": "21614", "city": "Buxtehude", "street": "Example Street 3" },
  "sellerType": "dealer",
  "dealerName": "Example Autohaus",
  "dealerId": "44450405",
  "dealerRating": 5,
  "dealerReviewCount": 9,
  "images": ["https://prod.pictures.autoscout24.net/listing-images/ffb3f43b-…/720x540.webp"],
  "imageCount": 15,
  "source": "autoscout24",
  "fetchedAt": "2026-10-15T00:54:34.255Z"
}
```

This example is one row from the price-check input above, trimmed to one photo; the dealer name and street are replaced. `null` means AutoScout24 does not show the value for that car; it never means 0.

The key-value store record `RUN_SUMMARY` has the status (`COMPLETE`, `PARTIAL`, `NO_RESULTS`, `INVALID_INPUT`, `ERROR`, `CANCELLED`), the reason, the AutoScout24 search URL, the number of matching listings (`search.totalAvailable`), counts of saved, charged and skipped listings, and request statistics.

### Pricing and limits

#### Pricing unit

This Actor uses pay-per-event pricing. Platform usage (compute, proxy, storage) is included; you pay only for these events:

| Event | When | Free plan | Bronze | Silver | Gold and above |
| --- | --- | ---: | ---: | ---: | ---: |
| Run start | Once per run | $0.0025 | $0.0025 | $0.0025 | $0.0025 |
| Saved listing | Each row saved in the Dataset | $0.00024 | $0.00023 | $0.00022 | $0.0002 |

- A run that finds no listings, a filter with no matches and an unchanged **Only new listings** run cost only the run start, $0.0025.
- Listings already seen in **Only new listings** mode are skipped and not charged.
- A run with a wrong make or model fails fast and costs only the run start.
- If the run stops at your spending cap or time limit, you pay only for the rows that were saved.

#### Cost examples

Free plan prices; measured runs at the default 512 MB.

| Scenario | Input scope | Saved listings | Charge | Time | Stop/cap behavior |
| --- | --- | ---: | ---: | ---: | --- |
| Small | one model, `maxItems: 20` | 20 | $0.0073 | ~5–10 s | stops at `maxItems` |
| Normal | one model, `maxItems: 100` | 100 | $0.0265 | ~10–15 s | stops at `maxItems` |
| Large | one model, `maxItems: 1000` | 1,000 | $0.2425 | ~1 min | stops at `maxItems` |
| Maximum | `maxItems: 2000` | 2,000 | $0.4825 | ~2 min | stops at `maxItems` |
| Unchanged monitor | `onlyNew: true`, nothing new | 0 | $0.0025 | ~5 s | stops when no new listings |

The default run timeout is 900 seconds. If AutoScout24 is slow, the run stops itself before the timeout and keeps the saved rows (status `PARTIAL`, reason `TIME_LIMIT`).

### API, export and integrations

- **API:** start the Actor with the same JSON input through the [Apify API](https://docs.apify.com/api/v2) and read rows from the run's default Dataset.
- **Export:** download the Dataset as JSON, CSV, Excel, XML or HTML from the **Output** tab.
- **Scheduling:** create a schedule with `onlyNew: true` to get only new cars each day; keep the same input (or the same `stateKey`).
- **Webhooks / no-code:** add a webhook or an Apify integration (for example Make, Zapier, Google Sheets) on run finish and read `url`, `price` and `title` from the Dataset.

#### Use with AI agents (MCP)

- MCP server URL with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/car-listings-scraper`.
- Smallest useful input: `{"make": "BMW", "model": "3 Series", "country": "de", "maxItems": 20}`.
- Key output fields: `title` (car), `price` (EUR, null if not shown), `mileageKm`, `firstRegistration` (`YYYY-MM`), `url` (listing page).
- A typical 20-listing call finishes in about 10 seconds and costs $0.0073. Maximum 2,000 listings per run. Unknown make or model names fail with a list of valid names to choose from.

### Troubleshooting

#### The run failed with "Unknown model"

Symptom: run FAILED, status `INVALID_INPUT`, message "Unknown model … Did you mean: …".
Likely reason: the model name is not in the AutoScout24 list for this make.
Check: the suggestions in the message.
Action: use one of the suggested names, for example `3 Series` or `320`.

#### The run failed with "covers several models"

Symptom: run FAILED, status `INVALID_INPUT`, message "Model … covers several models; pick one: …".
Likely reason: AutoScout24 groups several models under this name (for example `EQE`).
Action: pick one model from the list.

#### The Dataset is empty

Symptom: run SUCCEEDED with 0 rows, status `NO_RESULTS`.
Likely reason: no listings match the filters, or (with **Only new listings**) nothing new appeared.
Check: open `search.url` from `RUN_SUMMARY` in the browser.
Action: widen the price, year or mileage filters, or set `country` to `all`.

#### The run failed with "Source is failing or too slow"

Symptom: run FAILED, status `ERROR` (or `PARTIAL` with reason `SOURCE_ERROR`), message "Source is failing or too slow" or "stopped retrying".
Likely reason: AutoScout24 did not answer or was very slow for about 2 minutes in total.
Check: rows saved before the error stay in the Dataset; `RUN_SUMMARY.http` shows retries and timeouts.
Action: start the run again later. The run stops early on purpose, so a source outage costs only the run start and the saved rows.

#### Fewer rows than Maximum listings

Symptom: status `COMPLETE` with fewer rows.
Likely reason: AutoScout24 has fewer matching listings, or repeated sponsored listings were skipped (`counts.skippedDuplicate`).
Action: none needed; `search.totalAvailable` shows how many matched.

### FAQ

#### Do I need an AutoScout24 account, cookies or an API key?

No. The Actor reads public search results only.

#### Do I get seller phone numbers?

No. The Actor does not collect phone numbers or other contacts. For private sellers it keeps only city, zip and country.

#### Why is `firstRegistration` null for some cars?

New cars often have no registration date yet. `null` means AutoScout24 shows no value.

#### How fresh is the data?

Every run reads AutoScout24 live. `fetchedAt` shows when each row was read. Prices and listings can change after that.

#### Can I get more than 4,000 listings for one search?

AutoScout24 shows at most 4,000 results per search, and the Actor saves at most 2,000 per run. Split a big search by country, year or price range.

### Support

Use the Actor's **Issues** tab for questions, bugs or feature requests. Include the run ID and the status from `RUN_SUMMARY`. Do not send API tokens or cookies.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/car-listings-scraper/changelog.md

# Actor input Schema

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

Car brand as shown on AutoScout24, e.g. "BMW", "Volkswagen" (or "VW"), "Mercedes-Benz", "Toyota". Leave empty to search all makes.

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

Model or model line, e.g. "3 Series" (covers 316, 318, 320 ...), "C-Class" (also "C-Klasse"), "320", "Golf", "X5". Needs a make. An unknown name fails with suggestions instead of returning an empty list.

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

Where the car is offered. "all" covers all 8 AutoScout24 markets.

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

Earliest year of first registration, e.g. 2019.

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

Latest year of first registration.

## `priceFrom` (type: `integer`):

Minimum asking price in euros.

## `priceTo` (type: `integer`):

Maximum asking price in euros.

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

Only cars with at most this many kilometres.

## `condition` (type: `string`):

New, used, or both.

## `sort` (type: `string`):

Order of results. "Newest listings first" is best for monitoring with Only new listings.

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

Stop after this many listings. AutoScout24 shows at most 4,000 results per search; split big searches by country, year or price.

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

Return only listings that appeared since the previous run of the same search (with "Newest listings first", reading stops at the first page with no new listings; other orders stop after 5 such pages in a row). Use with a schedule to monitor new cars. The first run returns the newest listings up to Maximum listings and remembers them.

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

Name for the Only new listings history (letters, digits, - and \_). Leave empty to use one history per set of filters; set it to keep history when you tweak filters.

## Actor input object example

```json
{
  "make": "BMW",
  "model": "3 Series",
  "country": "de",
  "condition": "any",
  "sort": "newest",
  "maxItems": 20,
  "onlyNew": false
}
```

# Actor output Schema

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

AutoScout24 listings as a table.

## `runSummary` (type: `string`):

Status, search URL, totals available, counts and request statistics.

# 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 = {
    "make": "BMW",
    "model": "3 Series",
    "country": "de",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/car-listings-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 = {
    "make": "BMW",
    "model": "3 Series",
    "country": "de",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/car-listings-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 '{
  "make": "BMW",
  "model": "3 Series",
  "country": "de",
  "maxItems": 20
}' |
apify call cliqtomedia/car-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/car-listings-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/EwRCxbvW64s6mVDPQ/builds/b6VNf99Crf2hUPSjj/openapi.json