# Google Hotels Prices Scraper (`silentsuperpower/google-hotels-prices-scraper`) Actor

Hotel prices from Google Hotels for any city or hotel, any dates and guests. Optional prices from every booking site and a price-change monitor. Fast, no browser, low cost.

- **URL**: https://apify.com/silentsuperpower/google-hotels-prices-scraper.md
- **Developed by:** [Silent Superpower](https://apify.com/silentsuperpower) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 hotel rows

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

## Google Hotels Prices Scraper

Get hotel prices from Google Hotels for any city, area or named hotel, for any dates and any number of guests. One run can cover many places, a whole range of check-in dates, and (if you ask) the price on every booking site Google lists: Booking.com, Expedia, Hotels.com, Agoda, the hotel's own site and more. A built-in price monitor returns only the hotels that are new or whose price changed since your last run.

No browser and no login. The Actor talks to the same data service Google Hotels uses on its own pages, so a page of about 20 hotels costs one small request instead of a full page load. That makes it fast, cheap and steady.

### What you get

For every hotel and stay:

- Price per night and for the whole stay, with and without taxes and fees, in the currency you choose
- Hotel name, star class, Google guest rating, review count and the 1 to 5 star split
- Location (latitude, longitude, country), check-in and check-out times, description and photo
- Address, phone and website (when the hotel page is loaded)
- A link that opens the hotel in Google Hotels for the same dates and guests
- Optional: the price on every booking site, which one is cheapest, the price on the hotel's own site, free-cancellation flags, and the typical price range for the dates
- Optional price monitor fields: `changeType` (new, increase, decrease), previous price, change in money and percent

### Use cases

- **Rate monitoring for hotels and revenue managers.** Watch your competitors' prices every day and get only the changes.
- **Deal and travel sites.** Feed a "cheapest hotels in Lisbon next month" page, or a price-drop alert.
- **Trip planners and agencies.** Compare a city across several weekends in one run.
- **Parity checks.** See whether a hotel sells cheaper on Booking.com than on its own site.
- **Market research.** Price levels by city, star class and season.

### How to use it

1. Put one or more places in **Places to search** (`Paris`, `Hotels in Times Square, New York`), or hotels in **Hotels by name**.
2. Set the dates (a check-in date and nights, or leave the date empty to always look 14 days ahead) and the guests.
3. Press Start. Download the table as JSON, CSV or Excel, or read it through the API.

#### Input example

```json
{
  "searchQueries": ["Paris", "Lisbon, Portugal"],
  "checkInDate": "2026-11-14",
  "nights": 2,
  "adults": 2,
  "currency": "EUR",
  "maxHotelsPerSearch": 100,
  "minStars": 3
}
```

A date range (one stay per Friday for eight weeks):

```json
{
  "searchQueries": ["Austin Texas"],
  "checkInDate": "2026-11-06",
  "lastCheckInDate": "2026-12-25",
  "checkInStepDays": 7,
  "nights": 2,
  "maxHotelsPerSearch": 50
}
```

One hotel with the price on every booking site:

```json
{
  "hotelNames": ["Fairmont Austin Texas"],
  "checkInDate": "2026-11-14",
  "nights": 2,
  "currency": "EUR"
}
```

A daily price-drop feed (schedule the run every day):

```json
{
  "searchQueries": ["Rome"],
  "checkInInDays": 30,
  "nights": 3,
  "maxHotelsPerSearch": 200,
  "onlyPriceChanges": true,
  "monitorName": "rome-30-days-out",
  "monitorBy": "hotel",
  "minPriceChangePercent": 3
}
```

#### Output example

```json
{
  "searchQuery": "Austin Texas",
  "position": 2,
  "hotelName": "Fairmont Austin",
  "entityToken": "ChgIkYfI0qG8ttiwARoLL20vMDExMTB6NnMQAQ",
  "propertyType": "hotel",
  "starClass": 4,
  "rating": 4.6,
  "reviewCount": 7426,
  "checkInDate": "2026-11-14",
  "checkOutDate": "2026-11-16",
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "pricePerNight": 240.51,
  "pricePerNightWithTaxes": 287.89,
  "totalPrice": 481.02,
  "totalPriceWithTaxes": 575.78,
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChgIkYfI0qG8ttiwARoLL20vMDExMTB6NnMQAQ?...",
  "scrapedAt": "2026-10-10T16:00:00.000Z"
}
```

With booking-site prices on, each row also has `providerCount`, `cheapestProvider`, `cheapestPricePerNight`, `officialSitePricePerNight`, `typicalPricePerNight` and a `providers` list:

```json
{ "provider": "Traveluro", "isOfficial": false, "pricePerNight": 240.51, "pricePerNightWithTaxes": 287.89, "totalPrice": 481.02, "totalPriceWithTaxes": 575.78, "freeCancellation": null, "freeCancellationUntil": null }
```

### How the price monitor works

Turn on **Price monitor** and the Actor remembers the last price of every hotel in a named storage on your account. On the next run with the same **Monitor name**:

- a hotel it has not seen before comes back as `new`
- a hotel whose price moved comes back as `increase` or `decrease`, with the previous price, the change and the percent
- an unchanged hotel is skipped and **not charged**

Good to know:

- Use **one monitor name per schedule.** Two schedules with the same name would overwrite each other's baseline.
- **Stay** mode compares only the same check-in date and nights. **Hotel** mode compares with the last price whatever the dates, which fits "30 days from today" schedules.
- Google reshuffles its ranking between calls, so a hotel can drop out of the top results one day and return later as `new`. The monitor never reports a hotel as "removed".
- A hotel joins the history only after its row was saved, so a run that stops early never loses a change.
- "Remember prices, return nothing" sets a baseline without charging any hotel rows (the run start fee still applies).

### Pricing (pay per event)

You pay for hotel rows. Apify also charges its standard start event for every run ($0.00005 at 256 MB, the default memory of this Actor). Price per event by Apify plan:

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|---|---|---|---|---|---|---|
| `hotel` (one hotel row) | $0.00081 | $0.00081 | $0.00072 | $0.00063 | $0.00063 | $0.00063 |
| `provider-prices` (add-on: the price on every booking site, per hotel) | $0.01358 | $0.01358 | $0.01358 | $0.01198 | $0.01198 | $0.01198 |

Whole-job cost for the hotel rows alone, next to what the other Google Hotels Actors charge (taken from their public Store listings on 2026-10-10; the start event is included in our figures):

| Job | Tier | This Actor | zerobreak | vittuhy | johnvc (see note) | kestrel |
|---|---|---|---|---|---|---|
| 100 hotels | FREE | $0.081 | $0.50 | $0.105 | $0.120 | $0.40 |
| 100 hotels | GOLD | $0.063 | $0.30 | $0.105 | $0.090 | $0.40 |
| 1,000 hotels | FREE | $0.81 | $4.99 | $1.005 | $1.02 | $4.00 |
| 1,000 hotels | BRONZE | $0.81 | $4.32 | $1.005 | $0.92 | $4.00 |
| 1,000 hotels | SILVER | $0.72 | $3.66 | $1.005 | $0.82 | $4.00 |
| 1,000 hotels | GOLD | $0.63 | $2.99 | $1.005 | $0.72 | $4.00 |
| 10,000 hotels | FREE | $8.10 | $49.90 | $10.005 | $10.03 | $40.00 |
| 10,000 hotels | GOLD | $6.30 | $29.90 | $10.005 | $7.03 | $40.00 |

Hotels with the price on 16 booking sites each (the add-on), same sources:

| Job | Tier | This Actor | vittuhy | johnvc | kestrel |
|---|---|---|---|---|---|
| 100 hotels | FREE | $1.44 | $1.60 | $2.02 | $3.60 |
| 100 hotels | GOLD | $1.26 | $1.60 | $1.42 | $3.60 |
| 1,000 hotels | FREE | $14.39 | $16.00 | $20.03 | $36.00 |
| 1,000 hotels | GOLD | $12.61 | $16.00 | $14.03 | $36.00 |

Our price is at most 90% of the cheapest of the four at every job size (checked at all six plan tiers and at 100, 1,000 and 10,000 hotels). One place and date returns at most about 500 hotels (see Speed and limits), so a 10,000-hotel job means about 20 places or dates in one run. johnvc bills a setup fee and a fee per page of results; the table assumes 20 hotels per page, which was measured on one page. vittuhy bills $0.005 per run and $0.001 per result row, one hotel per run, and bills each booking site as its own row; the tables use its most generous reading. kestrel bills $0.004 per hotel and $0.002 per booking site.

Set a **Maximum cost per run** in the run options and the Actor stops cleanly when it is reached. Rows are saved before they are charged, a row the cost limit refused is never counted or charged, and a hotel that could not be loaded is never charged.

### Compared with other Google Hotels scrapers

| | This Actor | zerobreak | vittuhy | johnvc | kestrel |
|---|---|---|---|---|---|
| City or area search | yes | yes | no (one hotel per run) | yes | yes |
| Named hotels | yes | yes | yes | yes | yes |
| Prices on every booking site | yes, for city search too | no | yes, one hotel at a time, billed per booking site | yes, one property at a time | yes, billed per booking site |
| Price monitor (only new and changed) | yes | no | no | no | no |
| Several places in one run | yes | yes | no | no | yes |
| Date range in one run | yes | no | yes | no | yes |
| Children, currency, country, language | yes | currency, country, language | currency | yes | yes |
| Filters (stars, rating, price band, property type) | yes | no | no | yes | yes (no property type) |
| Reviews, photos | not included | no | no | extra paid events | partly |
| Start fee | Apify's default start event ($0.00005) | none listed | $0.005 per run | $0.02 setup plus start event | none listed |

"No" means the feature is not in that Actor's current input fields, pricing events or run output on 2026-10-10. It may exist in a form we could not see.

### Country, currency and language

Google shows the price a visitor from a country sees. Set **Country of the buyer** (`us`, `de`, `jp`) and **Currency**. The Actor starts with a direct connection, and only if Google blocks it does it switch to the Apify datacenter proxy and then to the residential proxy. Datacenter addresses are mostly in the US, so for a non-US point of sale choose a residential proxy in the same country under Advanced.

### Speed and limits

- About **19 new hotels per request**, one request every two seconds on a direct connection (faster behind a proxy). 500 hotels take about 45 requests, which measured 3 to 4 minutes.
- With booking-site prices on, each hotel costs one more request, so 500 hotels take about 550 requests.
- A named hotel takes two requests (name lookup, then prices); a hotel token takes one.
- A date range repeats the search for every date, so ten dates cost ten times the requests.
- Up to **500 hotels per place and date**. Google lists about 490 to 550 hotels per place and date, so asking for more could not return more, and a very large city can return slightly fewer than 500. When a search ends short because Google's list ended, the run log and the final status message say so (for example how many hotels Google listed and how many had no price). The status starts with "PARTIAL" only when something went wrong: an error, a blocked request, a name that matched no hotel or several, or the maximum cost reached.
- Up to 200 places and hotels per run, up to 62 dates.
- The run status shows these limits when the run starts and the reason for any shortfall when it ends, together with a link to the Actor's Issues tab.
- Memory: 256 MB is enough. The Actor never opens a browser.

### FAQ

**Where does the data come from?**
From Google Hotels, the same data service its own pages use. Nothing is estimated: the prices are the ones Google shows for your dates and guests.

**Is the price the real price I would pay?**
It is what Google lists at the time of the run. Hotels change prices all day, and the final price at checkout can differ. `pricePerNight` is the lowest price Google shows before taxes (it includes property fees). `pricePerNightWithTaxes` and `totalPriceWithTaxes` include taxes and fees when Google shows them.

**Why do some hotels not appear?**
Hotels with no price for your dates (sold out or not bookable) are skipped and not charged. The run summary counts them.

**A hotel name returned nothing. Why?**
A name that matches more than one hotel is skipped, and the run status says "more than one hotel matched". A name that matches no hotel says "no hotel matched" and asks you to check the spelling. Add the city (`Fairmont Austin Texas`) or paste the `entityToken` from an earlier result into **Hotel tokens**.

**Why are there fewer hotels than "total" says?**
Google reports a large total for a city but stops paging after about 490 to 550 hotels per place and date. Ask for what you need with **Max hotels per place** (up to 500). When Google's list ends first, the run status says how many hotels it listed and how many had a price. To cover more of a big city, search its districts (for example `Hotels in Montmartre, Paris`) as separate places.

**A place returned no hotels. Why?**
The run still succeeds and the status says "No hotels found for" your search. Check the spelling, add the country, or write it the way you would type it into Google Hotels, for example `Hotels in Times Square, New York`.

**Can I get reviews, photos or room-by-room rates?**
Not in this version. You get the rating, the review count and the star split, the main photo, and the price on each booking site.

**Will it break when Google changes something?**
The Actor checks every reply: it must be for the dates, guests and currency you asked, and the hotels must have the expected shape. If Google changes its format the run fails with a clear message instead of returning wrong numbers, and no rows are charged.

**Can I use it through the API or on a schedule?**
Yes. Start it from the Apify API, a schedule, Make, Zapier or n8n, and read the dataset when it finishes.

**What happens when Google blocks the connection?**
The Actor slows down, switches proxy address, and moves to the next proxy tier. It never tries to solve a CAPTCHA or get around a challenge. The proxy advice appears in the status only when Google really blocked requests during the run.

### Notes on accuracy

- Results depend on the point of sale (country of the visiting IP) and on the day.
- The list price can be for a different room type than a booking site's own page.
- Free-cancellation flags are best effort: `null` means Google did not say.
- Sorting is done by Google's own ranking (the `position` field). Sorting and filtering by price are on your side or through the filters above.

This Actor reads publicly visible prices. You are responsible for using the data in line with the law and Google's terms in your country.

# Actor input Schema

## `searchQueries` (type: `array`):

One per line. A city, area, neighborhood or landmark, written the way you would type it into Google Hotels: <code>Paris</code>, <code>Hotels in Times Square, New York</code>, <code>Lisbon, Portugal</code>. Each place returns its hotels, about 20 per page of results, with the price for your dates and guests.

## `hotelNames` (type: `array`):

Optional. One hotel per line, with the city to avoid mix-ups: <code>Fairmont Austin Texas</code>. Each name is looked up first and then priced with the full list of booking sites (Booking.com, Expedia, the hotel's own site and more). A name that matches more than one hotel is skipped with a warning; add the city or use a hotel token.

## `hotelTokens` (type: `array`):

Optional. Google hotel tokens (they start with <code>Ch</code>), one per line. The <code>entityToken</code> field of every result is one, so you can price the same hotels again without a name lookup. This saves one request per hotel.

## `checkInDate` (type: `string`):

Optional. First night of the stay as <code>YYYY-MM-DD</code>. Leave empty to use "Check-in in N days" below, which keeps scheduled runs looking ahead.

## `checkInInDays` (type: `integer`):

Used when "Check-in date" is empty: the stay starts this many days from the day of the run. Google shows prices up to about 330 days ahead.

## `checkOutDate` (type: `string`):

Optional. Last morning of the stay as <code>YYYY-MM-DD</code>. Leave empty to use "Nights" below.

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

Length of the stay when "Check-out date" is empty. 1 to 30 nights.

## `lastCheckInDate` (type: `string`):

Optional. To price many start dates in one run, set the last check-in date as <code>YYYY-MM-DD</code>. The run prices one stay per date from the check-in date to this one, so the same hotels come back once per date. Up to 62 dates. Each date repeats the search, so cost and requests grow with the number of dates.

## `checkInStepDays` (type: `integer`):

For a date range: price every N-th check-in date. 7 prices the same weekday each week.

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

Number of adults. Google shows the price for one room that fits all guests.

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

Optional. One age per line, from 0 to 17. Children can change the price and which hotels are shown.

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

Three-letter code for the prices, for example <code>USD</code>, <code>EUR</code>, <code>GBP</code>. Google converts the price when the hotel does not sell in this currency.

## `countryCode` (type: `string`):

Two-letter country code, for example <code>us</code>, <code>de</code>, <code>jp</code>. Google shows the prices a visitor from this country sees, and which booking sites it lists. Outside the US this works best with a residential proxy in the same country (see Advanced).

## `languageCode` (type: `string`):

Language of hotel descriptions and labels, for example <code>en</code>, <code>de</code>, <code>pt-BR</code>.

## `maxHotelsPerSearch` (type: `integer`):

Stop after this many matching hotels for each place and each date. If you leave it empty, 20 hotels are returned. Google lists about 490 to 550 hotels per place and date, so 500 is the most you can ask for, and a big city may return slightly fewer. A page of results holds about 20 hotels, and 500 hotels take about 25 requests. You are charged per hotel returned, so this also caps the cost.

## `minStars` (type: `integer`):

Keep only hotels with at least this star class. 0 keeps everything. Vacation rentals have no star class and are dropped when this is above 0.

## `minGuestRating` (type: `number`):

Keep only places whose Google guest rating is at least this value, on the 5-point scale. For example <code>4.2</code>. 0 keeps everything.

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

Optional. Drop hotels cheaper than this per night, in your currency.

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

Optional. Drop hotels more expensive than this per night, in your currency.

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

Which kinds of places to keep. Google Hotels lists both hotels and vacation rentals for most cities.

## `includeProviderPrices` (type: `boolean`):

For every hotel returned, also fetch the price on each booking site Google lists (about 10 to 40: Booking.com, Expedia, Hotels.com, the hotel's own site and more), with the cheapest site and the official-site price pulled out. Costs one extra request and one "provider-prices" charge per hotel. Hotels named in "Hotels by name" or "Hotel tokens" always include them.

## `includeBookingLinks` (type: `boolean`):

With booking-site prices on, also return the Google link that opens each offer. Links are long, so they are off by default.

## `onlyPriceChanges` (type: `boolean`):

Remember the last price of every hotel and return only hotels that are new or whose price changed since the previous run with the same monitor name. Unchanged hotels are skipped and not charged. Schedule the run daily for a price-drop feed. The first run returns everything, as "new".

## `monitorName` (type: `string`):

Name of the stored price history. Letters, digits and hyphens. Use a different name for each schedule so two schedules never share a history.

## `monitorBy` (type: `string`):

Stay compares a hotel only with its earlier price for the same check-in date and nights, which is right when your dates are fixed. Hotel compares with the last price seen for that hotel whatever the dates, which suits "N days from now" schedules.

## `monitorSeedOnly` (type: `boolean`):

Store today's prices as the starting point without returning or charging for any rows. Use it once to set a baseline.

## `minPriceChangePercent` (type: `number`):

Ignore price moves smaller than this percentage. For example 5 reports only changes of 5 percent or more. The baseline is only updated when a change is reported.

## `requestDelayMs` (type: `integer`):

How long to wait between requests to Google when no proxy is used. With a proxy the pause is a quarter of this.

## `maxRequests` (type: `integer`):

Hard limit on requests to Google for the whole run. The run stops and reports it when reached. Useful for tests.

## `maxResidentialMb` (type: `integer`):

Safety cap on residential proxy traffic, which is billed per gigabyte. The run stops when this is reached. Only matters when Google blocks the datacenter proxies and the run climbs to residential.

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

Optional. Leave empty and the run starts with a direct connection, then switches to Apify datacenter proxy and then to residential proxy only if Google blocks it. Pick a proxy here to force it from the start, for example a residential proxy in the country you set above.

## Actor input object example

```json
{
  "searchQueries": [
    "Paris"
  ],
  "checkInInDays": 14,
  "nights": 1,
  "checkInStepDays": 1,
  "adults": 2,
  "currency": "USD",
  "countryCode": "us",
  "languageCode": "en",
  "maxHotelsPerSearch": 10,
  "minStars": 0,
  "minGuestRating": 0,
  "propertyTypes": [
    "hotel",
    "vacation_rental"
  ],
  "includeProviderPrices": false,
  "includeBookingLinks": false,
  "onlyPriceChanges": false,
  "monitorName": "google-hotels-price-monitor",
  "monitorBy": "stay",
  "monitorSeedOnly": false,
  "minPriceChangePercent": 0,
  "requestDelayMs": 2000,
  "maxRequests": 1000000,
  "maxResidentialMb": 100
}
```

# Actor output Schema

## `results` (type: `string`):

One row per hotel and stay: price per night and for the whole stay, rating, location, and (if asked) the price on every booking site or the price change since the last run.

## `summary` (type: `string`):

Counts of rows, price changes, filtered hotels, requests and blocks, and why the run stopped if it stopped early.

# 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 = {
    "searchQueries": [
        "Paris"
    ],
    "maxHotelsPerSearch": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentsuperpower/google-hotels-prices-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 = {
    "searchQueries": ["Paris"],
    "maxHotelsPerSearch": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("silentsuperpower/google-hotels-prices-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 '{
  "searchQueries": [
    "Paris"
  ],
  "maxHotelsPerSearch": 10
}' |
apify call silentsuperpower/google-hotels-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,silentsuperpower/google-hotels-prices-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/Zikg3vSdu9vUtrJbF/builds/gpL0Bcc2JUs7b4t9t/openapi.json