# Google Hotels Scraper - Prices for Your Dates, Ratings (`mochiboo/google-hotels-prices-scraper`) Actor

Hotel prices from Google Hotels for any destination and your dates: the price per night as Google shows it, the stay total and per-night price with taxes and fees, guest rating, review count, star class, coordinates, check-in/out times, website and Google's hotel id. No login, no API key.

- **URL**: https://apify.com/mochiboo/google-hotels-prices-scraper.md
- **Developed by:** [mochi](https://apify.com/mochiboo) (community)
- **Categories:** Travel, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

## Google Hotels Scraper - hotel prices for your dates, ratings and Google hotel ids

Google Hotels prices for any destination and your dates, as a table. Give it destinations the way you would type them into Google Hotels ("hotels in Lisbon", "4 star hotels in Tokyo", "hostels in Berlin") and, if you like, a check-in date and a number of nights. For every destination it returns the hotels Google shows on its first results page (up to 20) with the price for the stay, guest rating, review count, star class, coordinates, check-in and check-out times, website and Google's own hotel id.

Price: Pay per result, at the rate shown in the pricing panel of this page, plus a very small per-run start fee. You are charged only for the results delivered.

### What you get

- **Prices for your dates.** Give a check-in date and the number of nights and every row is priced for exactly that stay. The actor checks on every destination that Google really priced your dates (see `datesNotApplied` below); a destination where Google ignored them returns no rows and costs nothing. Each row has the price per night and for the whole stay as Google shows them, and the stay total with taxes and fees (`totalPrice`) next to the amount before taxes and fees (`totalBeforeTaxesAndFees`).
- **Everything on the result card, as numbers.** Star class, guest rating and review count, latitude and longitude, check-in and check-out times, the hotel's own website and a photo link, for each hotel.
- **Built for tracking a destination.** Every row carries Google's stable hotel id (`googleHotelId`) and the link to the hotel's Google Hotels page, so a daily run can be joined to yesterday's. Schedule the same input every day with an Apify Schedule and chart destination-level figures (for example the median `pricePerNightAllIn`) from `scrapedAt`. Google shows a different selection of hotels on different requests, so the same hotels do not come back every time (see Limits). The actor keeps no memory between runs: every run is a fresh set of rows.

### Input

| field | meaning | default |
|---|---|---|
| Destinations | what you would type into Google Hotels, one per line, up to 100 per run; blank lines and repeats (any capitalisation) are dropped | `hotels in Lisbon` |
| Check-in date | `YYYY-MM-DD`, today or later; leave empty to let Google pick the dates (a one-night stay; the dates differ by destination) | empty |
| Nights | length of stay, 1 to 30; used only with a check-in date | 1 |
| Max hotels per destination | 1 to 20; Google shows about 16 to 20 hotels on its first results page | 20 |
| Proxy configuration | Apify Proxy is on by default | Apify Proxy |

Starting the actor without changing anything looks up "hotels in Lisbon" with the dates Google picks: one destination, 16 to 20 rows (18 to 20 on the platform).

More than 100 destinations: the first 100 run and the rest are listed in `skippedOverLimit` of the run summary. No destination at all, or a check-in date that is in the past or not a real date, fails the run in about a second with a plain message (nothing is requested and nothing is charged).

### Output

One row per hotel and destination, in the order Google lists them. Fields: `query`, `position`, `name`, `googleHotelId`, `googleHotelsUrl`, `featureId`, `latitude`, `longitude`, `countryCode`, `hotelClass`, `hotelClassText`, `rating`, `reviewCount`, `checkIn`, `checkOut`, `nights`, `adults`, `currency`, `pricePerNight`, `pricePerNightText`, `totalPrice`, `totalPriceText`, `totalBeforeTaxesAndFees`, `pricePerNightAllIn`, `checkInTime`, `checkOutTime`, `website`, `thumbnailUrl`, `scrapedAt`.

- `query`: your destination text, as you typed it (not the date phrase the actor sends to Google). `position`: the hotel's place (1, 2, 3 ...) among the hotels Google listed for it.
- `googleHotelId`: Google's id of the hotel, the same from run to run. `googleHotelsUrl`: the hotel's Google Hotels page (`https://www.google.com/travel/hotels/entity/<id>/prices`). `featureId`: Google's place feature id (empty for a few hotels).
- `latitude`, `longitude`, `countryCode`: where Google puts the hotel (`PT`, `US`, ...). The rows carry no address, only `name`, `countryCode` and the coordinates (`latitude`, `longitude`).
- `hotelClass`, `hotelClassText`: the star class (for example 4 and `4-star hotel`); `null` for hotels Google does not class (apartments, guest houses, hostels - roughly 30% of the hotels in our largest runs).
- `rating`, `reviewCount`: Google's guest rating (1 to 5) and the number of reviews behind it.
- `checkIn`, `checkOut`, `nights`: the stay Google priced. With a check-in date in the input they are your dates on every row; without one they are the dates Google chose for that destination.
- `adults`: the number of guests Google priced for. The actor does not set it: it is Google's default, 2 adults.
- `currency`: the currency code of the prices, as Google sent it. See "Currency" below.
- `pricePerNight`, `pricePerNightText`: the nightly price **as Google shows it on the result card**, as a number (two decimals) and as printed (`$177`).
- `totalPriceText`: the stay total as Google prints it on the card.
- `totalPrice`: the stay total **with taxes and fees**, as a number.
- `pricePerNightAllIn`: `totalPrice` divided by `nights`, two decimals: what the guest pays per night with taxes and fees. `null` when either is missing.
- `totalBeforeTaxesAndFees`: the same stay before taxes and fees.
- `checkInTime`, `checkOutTime`: the hotel's check-in and check-out times as Google prints them (`3:00 PM`); `null` when Google has none.
- `website`: the hotel's own website as Google gives it (it may carry `utm_` tracking parameters); `null` for some hotels. `thumbnailUrl`: a small photo.
- `scrapedAt`: when the row was made (UTC).

A hotel for which Google shows no price for the stay is still a row, with `null` prices, and is billed like any other row. In one of our 100-destination runs that was 4 of 1,741 rows, but small places and peak dates have many more: 11 of 18 hotels for Hallstatt over New Year and 7 of 20 for Marfa, Texas (QA runs, 2026-10-30).

#### Which price to use

`pricePerNight`, `pricePerNightText` and `totalPriceText` are the price as Google displays it for the market, which in the US is usually before taxes and fees. On Apify's servers (US, dollars) Google showed the price **before taxes and fees for most hotels**: in our runs `pricePerNight` times `nights` equalled `totalBeforeTaxesAndFees` for most hotels, and the printed total (`totalPriceText`) was at or near it. In a capture from a Singapore address the card prices already included taxes and fees. `totalPrice` is the all-in figure in both cases, and `pricePerNightAllIn` is the same figure per night, so **to compare hotels on what the guest pays, use `totalPrice` or `pricePerNightAllIn`**; use `pricePerNight` when you want what the card shows.

Example (one row; the photo link is shortened here):

```json
{
  "query": "hotels in Lisbon",
  "position": 3,
  "name": "Brown's | Avenue Hotel",
  "googleHotelId": "ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE",
  "googleHotelsUrl": "https://www.google.com/travel/hotels/entity/ChkIhLCQwvjO2IYWGg0vZy8xMXE0bTZieDkyEAE/prices",
  "featureId": "0xd193339fd7c9273:0x160d627788441804",
  "latitude": 38.7220236,
  "longitude": -9.1456424,
  "countryCode": "PT",
  "hotelClass": 5,
  "hotelClassText": "5-star hotel",
  "rating": 4.6,
  "reviewCount": 283,
  "checkIn": "2026-11-27",
  "checkOut": "2026-11-29",
  "nights": 2,
  "adults": 2,
  "currency": "USD",
  "pricePerNight": 176.79,
  "pricePerNightText": "$177",
  "totalPrice": 392.62,
  "totalPriceText": "$354",
  "totalBeforeTaxesAndFees": 353.59,
  "pricePerNightAllIn": 196.31,
  "checkInTime": "3:00 PM",
  "checkOutTime": "12:00 PM",
  "website": "https://www.brownshotelgroup.com/browns-avenue/",
  "thumbnailUrl": "https://lh3.googleusercontent.com/grass-cs/AABkmLeB9lofmD3m...=s150-w92-h150-n-k-no",
  "scrapedAt": "2026-10-28T14:31:57.146Z"
}
```

Only public data is read: the Google Hotels search page that a browser shows, with no login, no account, no cookies and no API key. The rows contain hotel names, ratings, prices, coordinates and the hotel's website as Google lists it; no email addresses and no phone numbers (we scanned every text value of a 1,741-row run: none).

### Limits you should know

- **Up to 20 hotels per destination.** The actor reads Google's first results page, which showed 16 to 20 hotels in our runs (18 in most). It does not page further and does not return the prices of the individual booking sites behind a hotel.
- **2 adults.** Google's default party size; there is no input for guests or rooms.
- **Currency.** Google picks the currency from the location of the proxy address the request comes from, and the actor cannot choose it: adding a currency or a country to the request URL changed nothing in our tests. With the default Apify proxy of our test account (US addresses) Google priced in **US dollars (`USD`) in every run we made**. The proxies of your account may sit in another country and then bring another currency, so read the currency code Google sent, which every row carries in `currency`. `RUN_SUMMARY.currency` holds the one currency seen in the run, or a list if there was more than one. A proxy country that your proxy group does not have makes every request fail (HTTP 407), and the run ends without rows (tested on 2026-10-30 with `GB`).
- **Google always returns hotels.** A misspelled or unknown destination silently returns popular hotels from somewhere else (in a test, the text "pizza" returned hotels in New York and Houston), and the row still carries your text in `query`. So check the spelling of your destinations and where the hotels are (`countryCode`, `latitude`, `longitude`, `name`), above all when the destinations come from user input.
- **Your dates must be priced.** If Google returns different dates than you asked for, the destination gets no rows, costs nothing, and the run summary shows `datesNotApplied` with the dates Google priced. It happens for particular destination and date combinations: in one of our runs Google did not understand the dates for "hotels in London" (17 to 20 December 2026) and answered with hotels in the United States priced for its own default night, so those hotels were not delivered as London; the same text gave the same answer when we asked again, and other dates for London worked.
- **Prices move.** Google's prices change during the day; a second run an hour later can differ. That is the point of a daily run.
- **The list changes from run to run.** Google shows a different selection and order of hotels on different requests: nine identical runs for "hotels in Lisbon" on 2026-10-28 shared on average 49% of their hotels, and only 3 of the 66 hotels seen were in every run (two runs for "hotels in München" nine minutes apart shared 6 of 18). To follow particular hotels, keep their `googleHotelId`s, join on them, and expect gaps.
- **Stars, websites and times are not always there.** Google leaves them out for some hotels; they are then `null`.

### How a run behaves

- **Pace.** One request at a time, with at least 3 seconds between requests, one request per destination. A destination takes about 6 seconds in practice (the pause plus Google's answer; the median in our three 100-destination runs was 5.6, 5.7 and 6.2 seconds). Now and then Google answers slowly or not at all within 30 seconds and the actor has to retry, so plan for about 8 to 11 seconds a destination on average: 100 destinations took 13 to 18 minutes (the slowest run had 11 requests that Google did not answer within 30 seconds). The default run time limit of one hour is plenty.
- **Time limit.** If a very large run is near its time limit, it stops cleanly: `terminationReason: "time_budget"`, `complete: false`, the rows written so far stay in the dataset, and the destinations not reached are marked `notRun` in `RUN_SUMMARY`.
- **If Google refuses.** A refusal stops the run at once with `terminationReason: "blocked"`: an HTTP 403, a redirect to Google's "unusual traffic" page, or an HTTP 200 page without the hotel data that shows a consent, "unusual traffic", captcha or /sorry/ marker. One kind of page gets a second chance: an HTTP 200 page without the hotel data and without any such marker (an odd page, seen once in about 460 requests) is asked once more after about 10 seconds, from a new proxy address, and the retry is counted in `retriedNonResultPages`; if the second answer is not the results page either, the run stops as above. The rows already written are kept; apart from that one second ask the actor does not retry or work around a refusal. If it refused before any row was written, the run is marked failed. `RUN_SUMMARY.blockEvidence` says which destination it was and what the page looked like (status, size, title, first text), so a consent page can be told from a changed layout.
- **Retries.** A network error, HTTP 429 or a server error (5xx) is retried up to three times, after 2, 4 and 8 seconds (never sooner than the 3 second pause), each time from a new proxy address. A destination that still gets no answer is marked `requestFailed` and the run goes on; three destinations in a row without an answer stop the run (`request_failed`).
- **Pages without hotels.** Google lists hotels even for a place it does not know, so an answer with no hotel at all is unusual (2 of 100 destinations answered that way at the first ask in each of our three 100-destination runs). The actor asks such a destination once more, from a new proxy address (that second ask returned hotels for Hong Kong and for Chicago in two of our runs); if that answer is empty too, the destination is `noHotels`: no rows and no charge. Havana was empty every time we asked, with and without dates, so a destination can be empty for good. Star-class and hostel searches are empty at the first ask more often: 2 of 3 in our QA runs ("4 star hotels in Düsseldorf" was rescued by the second ask, "hostels in Tbilisi" stayed empty; "hostels in Berlin" was fine). If every destination of a run ends that way, the run fails with `no_hotels` instead of finishing with an empty dataset, because it means Google's page no longer looks the way the actor reads it.
- **Platform restarts.** If the platform moves the run to another server, the run restarts itself and carries on: a destination that was already delivered is not requested, written or charged a second time.

### Run summary

The key-value store record `RUN_SUMMARY` holds:

- `complete`: true only when every destination was handled (`finished`).
- `terminationReason`: `finished`, `charge_limit` (your maximum cost per run was reached), `time_budget` (the run timeout was near), `blocked` (Google refused), `request_failed` (one or more destinations got no answer after the retries, so the result is partial), `no_hotels` (every destination came back empty and nothing was written; the run is marked failed), `invalid_input` (the input was unusable; nothing was written) or `error` (an unexpected failure; the run is marked failed).
- `rowsPushed`: the number of rows in the dataset.
- `currency`: the currency seen, or a list of currencies, or `null` when no row had a price.
- `queries`: one entry per destination, in your order, with `query`, `state`, `rows`, `pageCheckIn` and `pageCheckOut` (the dates Google priced). `state` is `ok`, `noHotels` (Google showed no hotel, also on the second ask), `datesNotApplied` (no rows, see above), `requestFailed`, `blocked` (the destination on which Google refused) or `notRun` (not reached because the run stopped).
- `skippedOverLimit`: the destinations over the limit of 100 that were not run.
- `requests`, `retries`, `retriedNonResultPages` (how many of the retries were the second ask for an odd page), `seconds`, and `error` (null, or why the run stopped). `blockEvidence` (null, or after a refusal: the destination and what the page Google sent looked like - status, size, title, the first text on it - so you can tell a consent page from a changed layout). `restarts` only after the platform restarted the run; the last key. `requests` and `retries` count the requests the run made; after a platform restart they can miss the last requests of the earlier container.

### Measured on the platform

Measured on 2026-10-28 on Apify's servers with the default Apify Proxy (datacenter). Google's answer times depend on the moment; the numbers about refusals and fill are the ones to trust.

- **100 destinations in one run, three times** ("hotels in" and 100 cities, a 3-night stay, check-in 45 and 50 days ahead, 512 MB). First run: 835 seconds; 98 destinations returned 16 to 18 hotels (18 for 85 of them), 1,748 rows; two destinations (London, Havana) came back with a page without hotels; 103 requests, 3 of them retries, **no refusal**. Second run: 792 seconds; 98 destinations returned hotels (1,741 rows: 76 destinations with 18, 21 with 17, one with 16), Havana was empty again after the second ask, and London got `datesNotApplied` (Google ignored the dates for it); 104 requests, 4 retries (two requests that Google did not answer within 30 seconds, the second ask for Hong Kong, whose first answer had no hotels and whose second had 17, and the second ask for Havana); **no refusal**. Third run (build 1.0.8, 256 MB, a 2-night stay, check-in 46 days ahead): 1,089 seconds; 98 destinations returned 17 or 18 hotels (1,752 rows), London got `datesNotApplied` again (December dates), Havana was empty again, and Chicago's empty first answer was rescued by the second ask; 113 requests, 13 retries (11 requests that Google did not answer within 30 seconds, 2 second asks for empty pages), **no refusal**, peak memory 93 MB. In all three runs every row was priced for the requested stay, there was no duplicate and the only currency was `USD`. The median destination took 5.6, 5.7 and 6.2 seconds, the slowest 45, 46 and 55 seconds.
- **Refusals:** in all our platform runs together (about 460 requests) Google refused once: a 40-destination run ended `blocked` after 6 destinations because one answer was an HTTP 200 page without the hotel data; the 108 rows already written were kept and `RUN_SUMMARY` named the destination. We never saw an HTTP 403 or a redirect to Google's "unusual traffic" page. The same 40 destinations a few minutes later finished, all of them (695 rows; Havana was empty, as always).
- **Fill (1,748 and 1,741 rows):** name, Google hotel id, feature id, coordinates, country, check-in, check-out, nights, adults, currency and time stamp 100%; photo 99.7 to 99.8%; prices (`pricePerNight`, `totalPrice`, their texts, `totalBeforeTaxesAndFees`) 99.7 to 99.8%; rating and review count 98%; check-out time 92 to 93%; check-in time 91 to 92%; website 86%; star class 67 to 72%.
- **3 destinations with dates** (Lisbon, New York, 4 star hotels in Tokyo; check-in 30 days ahead, 2 nights): 54 rows, 18 per destination, every row with the requested check-in, check-out and 2 nights, `USD`, no duplicate; at 256, 512 and 1024 MB the same, in 19 to 46 seconds.
- **No dates** ("hotels in Rome"): 20 rows, 1 night, the dates Google picked (2026-11-23 to 2026-11-24). **Default input** (nothing changed): 18 rows in 6 seconds.
- **Time limit:** 100 destinations with a 45-second run timeout (three runs): each stopped by itself after 35 to 41 seconds with 38 to 96 rows from 2 to 5 destinations, `terminationReason: "time_budget"`, `complete: false`, the other destinations `notRun`, and wrote `RUN_SUMMARY`.
- **Platform restart:** an 8-destination run was rebooted once through the API after 36 rows (the restart the platform performs when it moves a run to another server): it ended with 144 rows in the dataset, 144 different hotel and destination pairs, no duplicate, `rowsPushed` 144 in `RUN_SUMMARY` and `restarts` 1; the destination delivered just before the reboot was not requested again. A second reboot run gave the same (143 rows, no duplicate).
- **Wrong input:** no destination (or only blank lines) and a check-in date in the past fail the run in about a second with the plain message and write no row; a date that is not `YYYY-MM-DD` is refused by the platform before the run starts.
- **Memory:** the peak was 43 to 93 MB at 256, 512, 1024 and 4096 MB (93 MB for a 100-destination run at 256 MB, 77 MB for one at 512 MB), and the speed was the same at all sizes: the pause and Google's answer take the time.

Keywords: google hotels scraper, google hotel prices, hotel price monitoring, hotel rate shopping, google travel hotels, hotel prices api, compare hotel prices.

# Actor input Schema

## `queries` (type: `array`):

What you would type into Google Hotels, one per line, e.g. "hotels in Lisbon", "4 star hotels in Tokyo", "hostels in Berlin". Up to 100 per run.

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

YYYY-MM-DD, today or later. Leave empty to let Google pick the dates (one night; the dates Google picks differ by destination).

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

Length of stay (1-30). Used only with a check-in date.

## `maxHotelsPerQuery` (type: `integer`):

Google Hotels shows about 16-20 hotels on its first results page; this actor returns up to that many (1-20).

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

Apify Proxy is on by default.

## Actor input object example

```json
{
  "queries": [
    "hotels in Lisbon"
  ],
  "nights": 1,
  "maxHotelsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per hotel and destination: price per night and for the stay, rating, review count, star class, coordinates, check-in/out times, website and Google's hotel id.

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

What the run wrote and how it ended: one entry per destination (ok, noHotels, datesNotApplied, requestFailed, blocked, notRun), the currency seen and the termination reason (the RUN_SUMMARY record in the default key-value store).

# 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 = {
    "queries": [
        "hotels in Lisbon"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mochiboo/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 = {
    "queries": ["hotels in Lisbon"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("mochiboo/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 '{
  "queries": [
    "hotels in Lisbon"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call mochiboo/google-hotels-prices-scraper --silent --output-dataset

```

## MCP server setup

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