# Booking.com Scraper: Hotel Prices by City & Date (`aleksandrbooking/booking-scraper`) Actor

Search Booking.com by city, region, district, landmark or airport and get every available hotel with its price for your dates, star rating, review score, free cancellation and location. Filters, sorting, up to 10,000 hotels per search. Plain HTTP, no browser. Not affiliated with Booking.com.

- **URL**: https://apify.com/aleksandrbooking/booking-scraper.md
- **Developed by:** [Aleksandr Kobtsev](https://apify.com/aleksandrbooking) (community)
- **Categories:** Travel, Real estate, E-commerce
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 hotel 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

Search Booking.com the way its own search box does, for any city, region, district, landmark, airport or country, and get every hotel that has rooms for your dates: the price for the stay and per night, star rating, review score and count, property type, free cancellation, meal plan, address, coordinates, distance from the centre and the hotel's page. One dataset row per hotel and check-in date, up to 10,000 hotels per place and date.

There is no login, no Booking.com account, no partner API and no browser. The Actor reads the same results list Booking.com's search page loads, over plain HTTP, which is why it runs in 512 MB, reads a hundred hotels in about a second and can be priced low. Run it once, put it on a schedule, or call it from the API, and forward the result to Google Sheets, Slack, Make, Zapier or an MCP client.

### Who is this Booking.com scraper for?

| You are | What you run | What you get |
|---|---|---|
| A hotel owner or revenue manager | your city, your star class, the next ten check-in dates | the market around you: who still has rooms, and at what price |
| A travel agency or deal site | a list of destinations, three dates | a price list per destination, in your currency |
| An analyst or researcher | one city, every hotel | the full supply of a city with ratings, types, coordinates and price spread |
| Building a product | places through the API | clean rows to forward to a sheet, a database or a model |

If you need to follow one named hotel on every date of the year, the companion [Booking.com Hotel Price Monitor](https://apify.com/aleksandrbooking/booking-hotel-price-monitor) is the tool. If you need every room rate of a hotel with its cancellation and prepayment terms, use the [Booking.com Hotel Price Calendar Scraper](https://apify.com/aleksandrbooking/booking-rate-calendar). This Actor answers a different question: which hotels are there, and what do they cost.

For what guests say about those hotels, the [Booking.com Reviews Scraper](https://apify.com/aleksandrbooking/booking-reviews-scraper) takes the `hotelId` column of this Actor's output and returns their reviews, one row per review.

### What makes this different from other Booking.com scrapers?

- **It reads a whole city.** Booking.com's results list stops giving new hotels after about 1,000, however big the city. The Actor repeats the search by price band and then by property type and merges the lists. Measured on London on 11 October 2026: one query shows about 1,000 hotels, Booking.com's own count says about 2,970, and this Actor returned 3,096 in three minutes from the Apify datacenter pool (3,291 from a home address).
- **Every row is checked before it is billed.** The dates Booking.com echoes back must be the dates you asked for, the price must be in your currency, and a hotel with no price is skipped. Your filters are checked again on every row, so nothing outside them is delivered or charged.
- **It says what the price contains.** Booking.com quotes some prices with local taxes and some without, depending on the property and on where the request comes from. Each row carries Booking.com's own note, `pricesIncludeTaxes`, the amount added on top, and `totalPriceWithTaxes`, so rows compare with each other.
- **It names the place it searched.** The matched place is in every row, and the run log lists the other places the name could have meant.
- **It is fast and cheap by construction.** Fifty hotels take about five seconds and a whole country of 4,400 hotels about four minutes, in under 120 MB of memory, so the price per hotel stays low. It is on this page.

### What data does it return?

One row per hotel and check-in date.

| Field | What it is |
|---|---|
| **destination**, **destinationType** | The place that was searched, as Booking.com names it, and its kind: city, region, district, landmark, airport or country. |
| **position** | The hotel's 1-based place in Booking.com's own list for your search. `null` for hotels found by the price-band re-search, which has no single order. |
| **hotelId**, **hotelName**, **hotelUrl** | The property. The link opens the hotel's page with your dates and guests already set. `hotelId` is the stable join key. |
| **accommodationTypeId**, **accommodationType** | Booking.com's property type: Hotel, Apartment, Guest house, Hostel and so on. `null` name for an id that is not in Booking.com's list. |
| **starRating** | 1 to 5, or `null` for an unrated property. |
| **reviewScore**, **reviewCount**, **reviewLabel** | The guest review score out of 10, how many reviews, and Booking.com's word for it ("Very good"). `null` when there are no reviews. |
| **address**, **city**, **countryCode**, **latitude**, **longitude** | Where it is. `city` is as the property wrote it, in whatever script. |
| **locationLabel**, **distance** | The neighbourhood line and the distance ("0.9 km from centre", or from the landmark or airport you searched). |
| **checkIn**, **checkOut**, **nights**, **adults**, **rooms**, **childrenAges**, **currency** | The stay this row priced. |
| **totalPrice**, **pricePerNight** | The lowest price for the whole stay as Booking.com printed it, and that divided by `nights`. |
| **priceBeforeDiscount** | The crossed-out price, when Booking.com shows one. |
| **pricesIncludeTaxes**, **taxesAndCharges** | Whether `totalPrice` already contains taxes and charges (`true`, `false`, or `null` when the answer says neither), and Booking.com's note. |
| **taxesAndChargesAmount**, **totalPriceWithTaxes** | The taxes added on top for the stay, and the price with them. `totalPriceWithTaxes` is `null` only when the answer states nothing about taxes. |
| **freeCancellation**, **freeCancellationUntil** | Whether the cheapest rate can be cancelled for free, and until when. |
| **mealPlan**, **roomsLeft** | The meal plan on the cheapest rate when it has one, and the number from "We have 3 left at this price". |
| **photoUrl** | The hotel's main photo. |
| **scrapedAt** | When it was collected, ISO-8601 UTC. |

```json
{
  "destination": "Batumi, Ajara, Georgia",
  "destinationType": "city",
  "position": 1,
  "hotelId": "1054549",
  "hotelName": "Hilton Batumi",
  "hotelUrl": "https://www.booking.com/hotel/ge/hilton-batumi.html?checkin=2026-11-20&checkout=2026-11-22&group_adults=2&no_rooms=1&group_children=0&selected_currency=USD",
  "accommodationTypeId": 204,
  "accommodationType": "Hotel",
  "starRating": 5,
  "reviewScore": 8.1,
  "reviewCount": 901,
  "reviewLabel": "Very good",
  "address": "Rustaveli Street #40",
  "city": "Batumi",
  "countryCode": "ge",
  "latitude": 41.6493385306349,
  "longitude": 41.6255879402161,
  "locationLabel": "Old Boulevard , Batumi",
  "distance": "0.9 km from centre",
  "checkIn": "2026-11-20",
  "checkOut": "2026-11-22",
  "nights": 2,
  "adults": 2,
  "rooms": 1,
  "childrenAges": [],
  "currency": "USD",
  "totalPrice": 292.03,
  "pricePerNight": 146.01,
  "priceBeforeDiscount": null,
  "pricesIncludeTaxes": true,
  "taxesAndCharges": "Includes taxes and charges",
  "taxesAndChargesAmount": null,
  "totalPriceWithTaxes": 292.03,
  "freeCancellation": false,
  "freeCancellationUntil": null,
  "mealPlan": null,
  "roomsLeft": 2,
  "photoUrl": "https://cf.bstatic.com/xdata/images/hotel/square600/502839301.webp?k=cf269ee5ca92c953a82c477928a068e631eb6a3fdc4905dc207478685aae86b5&o=",
  "scrapedAt": "2026-11-01T09:14:02.113Z"
}
```

**What to do with it.** Key rows on `hotelId` plus `checkIn`. Put the run on a daily schedule and keep every run's dataset to see a market move. Use `totalPriceWithTaxes` to compare hotels, `pricePerNight` and `starRating` to see the price spread of a class, and the coordinates to map it.

### How do I scrape Booking.com hotels by city?

1. Type a place into **Places to search**, one per line: `Batumi`, `Manhattan`, `London Heathrow Airport`. A pasted Booking.com search results link works too; only its destination is used.
2. Choose the check-in date, nights and guests. Leave the date empty for tomorrow.
3. Set **Hotels per place and date**. The default is 100.
4. Add filters if you want a slice: star ratings, minimum review score, property types, free cancellation, breakfast, price per night.
5. Run it. Download the dataset as JSON, CSV or Excel, or read it through the API.

| Field | Default | What it does |
|---|---|---|
| `destinations` | required | Places to search, one per line: cities, regions, districts, landmarks, airports, countries, or Booking.com search result links. Up to 50 per run. |
| `startDate` | tomorrow | First check-in date, `YYYY-MM-DD` (UTC). Today is allowed; a past date is moved to today. |
| `days` | 1 | Consecutive check-in dates from `startDate`, up to 30. Each date is its own search with its own rows. |
| `nights` | 1 | Length of stay. |
| `adults` | 2 | Adult guests. Occupancy changes the price and which hotels have rooms. |
| `rooms` | 1 | Rooms to price. |
| `childrenAges` | `[]` | Age of each child, e.g. `[5, 9]`. Booking.com prices children by age. |
| `currency` | `USD` | One of 12 currencies. A result priced in another is skipped and not charged. |
| `maxResults` | 100 | The most hotels per place and date, 1 to 10,000. Above what one query reaches the Actor re-searches by price band and property type. |
| `sortBy` | `popularity` | Booking.com's own orders: popularity, price, best reviewed and lowest price, top reviewed, stars either way, distance from the centre. |
| `starRatings` | all | Keep only these star ratings. Unrated properties cannot be asked for on their own. |
| `minReviewScore` | any | 6, 7, 8 or 9, as Booking.com's "Pleasant 6+" to "Superb 9+". Properties with no reviews are dropped when set. |
| `propertyTypes` | all | Booking.com's own groups: hotels, apartments, aparthotels, guest houses, hostels, bed and breakfasts, villas, holiday homes, homestays. They overlap by design. |
| `freeCancellationOnly` | `false` | Keep only hotels whose cheapest rate can be cancelled for free. |
| `breakfastIncluded` | `false` | Keep only hotels whose cheapest rate includes a meal plan with breakfast. |
| `minPricePerNight`, `maxPricePerNight` | none | The exact range of `pricePerNight`, in your currency. |
| `concurrency` | 2 | Place and date searches run at the same time. Pages of one search are read one after another. |
| `proxy` | Apify datacenter | What the Actor is priced on. See the section on prices and countries. |

### How much does it cost to scrape Booking.com hotels?

**One billed row is one hotel for one place and one check-in date.** Nothing else is charged except the platform's own two small events.

| Event | Price | When |
|---|---|---|
| Hotel result | $0.0015, falling to $0.001 by plan | Per hotel row that reaches the dataset |
| Actor start | $0.00005 | Once per run; at 512 MB it is a single start event |
| Result | $0.00001 | Per stored row, about one cent per thousand rows |

The hotel price steps down with your Apify plan: $0.0015 on the free plan and on Bronze, $0.00125 on Silver, and $0.001 on Gold and above.

What that means for real jobs, all three charges included:

| Job | Rows | Free plan | Gold and above |
|---|---|---|---|
| 100 hotels in one city | 100 | **$0.15** | **$0.10** |
| 1,000 hotels in one city | 1,000 | **$1.51** | **$1.01** |
| All of London, about 3,100 hotels | 3,100 | **$4.68** | **$3.13** |
| Five cities, 500 hotels each | 2,500 | **$3.78** | **$2.53** |
| 50 hotels in one city over 7 check-in dates | 350 | **$0.53** | **$0.35** |

Nothing is charged for a hotel without a price, in another currency, outside your filters, or for a page Booking.com refused to serve. Set **Maximum total charge** on the run to cap spending: the Actor stops cleanly at the budget and says so in the `FAILED_SEARCHES` record.

**How this compares.** On the Apify Store on 11 October 2026, Actors that return Booking.com search results charged between $0.001 and $0.005 per hotel on the free plan, some with extra events for details. Here the price above is the whole price of a row.

### How deep can it go?

Booking.com's results list is capped in practice: a query stops giving new hotels after about 1,000, and its pages then repeat. For a city with more available hotels than that, asking for a large `maxResults` makes the Actor do the rest:

1. read the first query as it is, in Booking.com's order, with real positions;
2. repeat the search under Booking.com's price filter, band by band, halving any band that is still too big, and merge by hotel id;
3. read each property type on its own, which reaches a slice the default list does not show: in London, about 200 holiday homes and 60 bed and breakfasts that no unfiltered list contained.

| London, 20 November 2026, one night, two adults | Hotels |
|---|---|
| One query | about 1,000 |
| Booking.com's own count for the search | about 2,970 |
| This Actor, from the Apify datacenter pool | 3,096 in 179 seconds |
| This Actor, from a home address in Georgia | 3,291 in 127 seconds |

Rows found after the first thousand come in price-band order, not in your `sortBy` order, and have `position: null`. A smaller `maxResults` stops early, and nothing is re-searched while the first query already holds enough.

### Prices, taxes and countries

Booking.com does not show everyone the same price. The country the request comes from decides which taxes are quoted on top and sometimes the price itself. What was measured on 11 October 2026, on 300 Batumi hotels for the same dates, asked from a Georgian home address and from the Apify datacenter pool:

- From the datacenter pool, 273 rows quoted prices without taxes (`pricesIncludeTaxes: false`) and 27 stated nothing. From the home address, 254 quoted prices with taxes and 46 without.
- 240 hotels were in both lists. For 21 the datacenter answer stated nothing about taxes. Of the other 219, after adding the taxes Booking.com listed, 152 agreed within 1 per cent, 137 of them within 0.05 per cent. 67 differed by 1 per cent or more: the median gap was zero, a quarter of the hotels were more than 8 per cent apart, and the extremes were 72 per cent dearer and 37 per cent cheaper from the datacenter. So Booking.com's price for a guest in Georgia is not always the datacenter price plus tax.

What this means for you:

- Compare hotels with each other using `totalPriceWithTaxes`, all from one vantage point. That is what a market comparison needs, and it does not change between rows.
- To see what a guest from a particular country would see, run through your own proxies in that country (**Proxy**, then Custom proxies). The country is a property of the exit address, and every row reports the regime it got.
- The price is the cheapest rate Booking.com lists for the stay and occupancy you asked for. It is not a room price: for every room and its terms use the Hotel Price Calendar Scraper.

### What does it not do?

- **Fully booked hotels are not in the list.** Booking.com does not list a property that has no room for your dates, so it is not returned and not charged. A hotel that was there yesterday and is missing today has no rooms. To follow named hotels with an explicit sold-out flag, use the Hotel Price Monitor.
- **One price per hotel.** The lowest rate, with its cancellation date and meal plan. Not every room type and rate.
- **Property types are Booking.com's.** The `propertyTypes` groups overlap, and `accommodationType` carries the exact type for the rest.
- **English only.** Names and labels come back in English. A property's own name and address stay in the script its owner wrote them in.
- **It does not collect guest reviews, photos beyond the main one, guest names or any personal data.**

### FAQ

**Can I search several places and dates at once?** Yes: up to 50 places and 30 check-in dates in a run. Each place and date is a separate search, and the dataset holds every row with its `destination` and `checkIn`.

**Why does free cancellation leave so few hotels?** The free window closes as check-in nears. Measured on Rome for a one-night stay starting the next day, 43 of 2,126 hotels still offered it; for dates six weeks out, 59 of the first 100 hotels in Batumi and 35 of the first 100 in Lisbon did. Ask for later dates, or leave the filter off and read `freeCancellation` and `freeCancellationUntil` on each row.

**What if the place name is ambiguous?** The Actor takes an exact match on the name, or else the first suggestion, as Booking.com's own search box would. Which place it matched is in every row, and the run log lists the other suggestions. To pick another, name it in full ("Georgia, United States") or paste its Booking.com search link.

**Why does the number of hotels differ from the count Booking.com prints?** The count varies by a few per cent from one request to the next and does not include every property the list can be read to: London was counted at about 2,970 and read at 3,096 to 3,291 distinct hotels. Rows here are the hotels that have a price for your stay, once each, merged by hotel id.

**Does it work for countries and regions?** Yes. Measured on Montenegro on 11 October 2026: 4,448 hotels in 223 seconds, 111 MB of memory. Set `maxResults` to what you need.

**Do I need a Booking.com account or an API key?** No.

**Is it legal to scrape Booking.com?** This is an unofficial tool, not affiliated with, endorsed by or connected to Booking.com or Booking Holdings Inc. It reads publicly visible prices and collects no personal data. Booking.com's terms of service restrict automated access, and you are responsible for making sure your use complies with those terms and with the law in your jurisdiction. See [Apify's stance on web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### Found a problem?

Open an issue on the Issues tab with the place, the dates and the run ID. Reports get read.

# Changelog

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

# Actor input Schema

## `destinations` (type: `array`):

Cities, regions, districts, landmarks, airports or countries, one per line, e.g. Batumi, Manhattan, London Heathrow Airport. A name is matched the way Booking.com's own search box matches it, and the matched place is shown in every row. You can also paste a Booking.com search results link: only its destination is used, the dates and filters in it are ignored.

## `startDate` (type: `string`):

YYYY-MM-DD (UTC). Leave empty to use tomorrow. Today is allowed; a date in the past is moved to today.

## `days` (type: `integer`):

Number of consecutive check-in dates, from the date above. Every date is a separate search with its own rows: 50 hotels over 7 dates is 350 billable rows.

## `nights` (type: `integer`):

Length of stay. Each row carries the price for the whole stay and the price per night.

## `adults` (type: `integer`):

Number of adult guests. Occupancy changes the price and the list of available hotels.

## `rooms` (type: `integer`):

Number of rooms to price for the same stay.

## `childrenAges` (type: `array`):

Age of each child as a JSON list, e.g. \[5, 9]. Booking.com prices children by age. Leave empty for adults only.

## `currency` (type: `string`):

Prices are verified to come back in this currency; a result priced in another is skipped and not charged.

## `maxResults` (type: `integer`):

The most hotels to collect for each place and each check-in date. One row is one billable hotel. Booking.com shows about 1,000 per search on one query; asking for more makes the Actor repeat the search by price band and by property type, which reads a large city in full (London: about 3,300 hotels in two minutes).

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

The order of Booking.com's own results page. With a limit below the number of hotels listed, this decides which hotels you get. Rows found by repeating the search by price band come after the first thousand, in band order.

## `starRatings` (type: `array`):

Keep only hotels with these star ratings. Leave empty for all, unrated properties included. Unrated properties cannot be asked for on their own.

## `minReviewScore` (type: `string`):

Keep only hotels reviewed at or above this score. Properties with no reviews are dropped when a score is set.

## `propertyTypes` (type: `array`):

Keep only these kinds of property, using Booking.com's own groups. The groups overlap by design: Hotels also lists aparthotels, and Apartments also lists hotels that sell apartments. Every row names its exact type in accommodationType, so you can narrow further.

## `freeCancellationOnly` (type: `boolean`):

Keep only hotels whose cheapest rate can be cancelled for free. The free window closes as check-in nears, so a search for tomorrow lists few of them (Rome, one night, 12 October 2026: 43 of 2,126 hotels).

## `breakfastIncluded` (type: `boolean`):

Keep only hotels whose cheapest rate includes a meal plan with breakfast.

## `minPricePerNight` (type: `number`):

In the currency above, as it appears in the row (pricePerNight). Hotels cheaper than this are dropped.

## `maxPricePerNight` (type: `number`):

In the currency above, as it appears in the row (pricePerNight). Hotels dearer than this are dropped.

## `concurrency` (type: `integer`):

How many place and date searches run at the same time. Each page of a search is read one after another.

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

Apify datacenter proxies are the default and what this Actor is priced on. Apify residential groups are not available here; a run that asks for one is refused in the first seconds, before any row is charged. For a specific country, or a residential address, choose Custom proxies and supply your own. The country decides whether Booking.com quotes prices with or without local tax, which each row reports as pricesIncludeTaxes.

## `dryRun` (type: `boolean`):

Produce data without charging events. Honored only for runs started by the Actor owner; ignored for everyone else.

## Actor input object example

```json
{
  "destinations": [
    "Batumi"
  ],
  "days": 1,
  "nights": 1,
  "adults": 2,
  "rooms": 1,
  "childrenAges": [],
  "currency": "USD",
  "maxResults": 50,
  "sortBy": "popularity",
  "minReviewScore": "0",
  "freeCancellationOnly": false,
  "breakfastIncluded": false,
  "concurrency": 2,
  "proxy": {
    "useApifyProxy": true
  },
  "dryRun": false
}
```

# Actor output Schema

## `hotels` (type: `string`):

No description

## `failedSearches` (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 = {
    "destinations": [
        "Batumi"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("aleksandrbooking/booking-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 = {
    "destinations": ["Batumi"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("aleksandrbooking/booking-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 '{
  "destinations": [
    "Batumi"
  ],
  "maxResults": 50
}' |
apify call aleksandrbooking/booking-scraper --silent --output-dataset

```

## MCP server setup

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