# Google Maps Scraper | $0.25/1K Results 💰 (`scraperlink/google-maps-scraper`) Actor

🔥 $0.25/1K results🔥 **CHEAPEST** Google Maps Scraper on Apify — 10× cheaper than competitors. Proxies & platform costs included. Results in seconds. Extract names, phones, addresses, ratings, hours & more. Multi-query, up to 200 results per search.

- **URL**: https://apify.com/scraperlink/google-maps-scraper.md
- **Developed by:** [ScraperLink](https://apify.com/scraperlink) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 6,183 total users, 1,224 monthly users, 99.9% runs succeeded, 67 bookmarks
- **User rating**: 4.97 out of 5 stars

## Pricing

from $0.25 / 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.
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 Maps Scraper

**From $0.25 per 1,000 Google Maps results. Detail enrichment costs $0.25 per 1,000 places, and full reviews cost $0.25 per 1,000 reviews returned.**

Pull structured business data from Google Maps at a fraction of what other actors charge. Every Google Maps run is fast, lightweight, and billed only for Google Maps results you actually receive — each Google Maps business listing lands as its own row in the dataset.

Compass charges $4.00 per 1,000 places without a pricing discount and $1.50 at its highest discount tier. This actor costs $0.50 and $0.25 at the corresponding tiers — **6–8× cheaper**, with rich Google Maps data and straightforward result-based pricing.

***

### What makes this Google Maps scraper different

| | This Google Maps actor | Top competitor |
|---|---|---|
| Base price per 1,000 Google Maps results | **From $0.25** | $1.50+ |
| Detail enrichment: Place Details, images, and Popular Times | **+$0.25 per 1,000 places** | Varies |
| Full Google reviews | **+$0.25 per 1,000 reviews** | Often $0.30+ |
| Google Maps data fields per result | **80+** | ~20 |
| Google Maps output organized into tabs | **6 tabs** | Basic table |
| Bulk Google Maps queries in one run | **Yes** | Yes |
| Google Maps results as individual rows | **Yes** | Sometimes nested |
| Max Google Maps results per query | **200 normally; 500 with area search** | 120–200 |

Choose your searches and optional add-ons, then receive one structured dataset row per place.

***

### Google Maps data you get (80+ fields across 6 tabs)

#### Overview

Name, rating, review count, price level, category, full address, website, phone, and direct Google Maps URL — everything you need at a glance from Google Maps.

#### Contact Info

Full Google Maps address broken into components (street, number, neighborhood, city, postal code, state, country), domain, all three phone formats (international, formatted, digits-only), Google Maps coordinates (lat/lng), plus code, and the building or complex the business is located in.

#### Hours

Live Google Maps open/closed status, weekly opening hours, service-specific hours (lunch, dinner, brunch, happy hour, and more), and booking/reservation links from Google Maps.

#### Ratings & Reviews

Google Maps total score, star rating, rating count, review count, full 1–5 star distribution, price tier, and optional full reviews with reviewer metadata, dates, text, photos, ratings, and owner responses.

#### Media & Identity

Google Maps Place ID, Data ID, CID, FID, Google Maps URL, optional image galleries and contributor attribution, thumbnail, logo, owner information, menus, order links, and related places.

#### Metadata

Original Google Maps search query, rank and position, language, advertisement flag, timezone, temporarily/permanently closed flags, about text, dynamic Google place tags and attribute groups (service options, highlights, offerings, dining options, accessibility, amenities, atmosphere, crowd, planning, payments, parking, and any future groups Google returns), plus optional compact Popular Times and live busyness data.

***

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `query` | string list | | — | One or more Google Maps search queries; optional with URLs or Place IDs |
| `startUrls` | URL list | | — | Direct Google Maps place URLs; API object entries may include `userData`, returned as `inputUserData` |
| `placeIds` | string list | | — | Direct Google Maps Place IDs; API object entries may include `userData`, returned as `inputUserData` |
| `location` | string | | — | Named location separate from the search term; explicit geometry takes precedence |
| `locations` | string list | | — | Run every query in every listed location; replaces `location` when provided |
| `latitude`, `longitude` | number | | — | Precise Google Maps search center |
| `radiusKm` | number | | — | Search radius around the coordinates |
| `boundingBox` | object | | — | Area as `south`, `west`, `north`, `east` |
| `polygon` | array | | — | Area as `[latitude, longitude]` points |
| `customGeolocation` | object | | — | Area as a GeoJSON Polygon using `[longitude, latitude]` coordinates; takes precedence over `polygon` |
| `gridSpacingKm` | number | | `2` | Coverage spacing for area searches |
| `searchWorkers` | integer | | `4` | Concurrent map-center searches; from `1` to `4` |
| `skipClosedPlaces` | boolean | | `false` | Exclude temporarily or permanently closed places before saving or billing |
| `geoStrictMatch` | boolean | | `true` | Exclude results whose coordinates fall outside an explicit radius, bounding box, or polygon |
| `keepUnverifiedLocations` | boolean | | `true` | Keep service-area businesses and places for which Google exposes no address |
| `skipPlacesNotMatchingSearch` | boolean | | `false` | Keep only results whose title or Google categories match a meaningful search term |
| `num` | integer | | `200` | Unique results per query; up to `500` with an explicit area search |
| `gl` | string | | `us` | Country for Google Maps results — match this to the country you're searching in (`ca`, `gb`, `de`, etc.) |
| `hl` | string | | `en` | Interface language for Google Maps results (`fr`, `es`, `de`, etc.) |
| `languages` | string list | | — | Run every query or direct source once per language; replaces `hl` when provided |
| `placeDetails` | boolean | | `false` | Include descriptions, amenities, accessibility, menus, booking options, related places, and additional metadata. Adds $0.25 per 1,000 returned places. |
| `includeImages` | boolean | | `false` | Include available image galleries, dimensions, identifiers, and capture dates. Uses the same place add-on charge. |
| `includeImageAuthors` | boolean | | `false` | Include available contributor identifiers and Google Maps profile links. Uses the same place add-on charge. |
| `maxImages` | integer | | `20` | Maximum images retained per place, up to `100` |
| `popularTimes` | boolean | | `false` | Include Popular Times when Google provides it. Adds $0.25 per 1,000 places with Popular Times data; unavailable places are not charged unless another detail option is enabled. |
| `reviews` | boolean | | `false` | Fetch full Google review records. Adds $0.25 per 1,000 reviews actually returned. |
| `maxReviews` | integer | | `10` | Maximum reviews per place, up to `1,000` |
| `reviewsSort` | string | | `most_relevant` | `most_relevant`, `newest`, `highest_rating`, or `lowest_rating` |
| `fields` | string | | — | Comma-separated list of Google Maps fields to keep — leave blank to get everything |

#### Example: multi-city Google Maps lead generation

```json
{
  "query": [
    "personal injury lawyers in houston",
    "personal injury lawyers in dallas",
    "personal injury lawyers in austin"
  ],
  "num": 200,
  "gl": "us",
  "hl": "en"
}
```

#### Example: international Google Maps search

```json
{
  "query": ["coffee shops in london"],
  "num": 100,
  "gl": "gb",
  "hl": "en"
}
```

#### Example: multiple languages and a strict GeoJSON area

```json
{
  "query": ["restaurants"],
  "languages": ["en", "fr"],
  "gl": "ca",
  "num": 500,
  "geoStrictMatch": true,
  "customGeolocation": {
    "type": "Polygon",
    "coordinates": [[
      [-79.50, 43.60],
      [-79.20, 43.60],
      [-79.20, 43.80],
      [-79.50, 43.80],
      [-79.50, 43.60]
    ]]
  }
}
```

#### Example: include Popular Times

```json
{
  "query": ["restaurants in toronto"],
  "num": 200,
  "gl": "ca",
  "hl": "en",
  "popularTimes": true
}
```

#### Example: include place details and attributed images

```json
{
  "placeIds": ["ChIJ243-C381K4gRHMKWCGU86iM"],
  "placeDetails": true,
  "includeImages": true,
  "includeImageAuthors": true,
  "maxImages": 20
}
```

#### Example: include reviews

```json
{
  "query": ["restaurants in toronto"],
  "num": 100,
  "gl": "ca",
  "reviews": true,
  "maxReviews": 20,
  "reviewsSort": "newest"
}
```

#### Add-on pricing

Detail enrichment and full review records are optional paid add-ons. Add-on rates are fixed across every Apify plan.

| Apify pricing tier | Base results | Detail enrichment | Base + Detail enrichment |
|---|---:|---:|---:|
| No discount | $0.50 / 1,000 | $0.25 / 1,000 | $0.75 / 1,000 |
| Bronze | $0.45 / 1,000 | $0.25 / 1,000 | $0.70 / 1,000 |
| Silver | $0.40 / 1,000 | $0.25 / 1,000 | $0.65 / 1,000 |
| Gold | $0.25 / 1,000 | $0.25 / 1,000 | $0.50 / 1,000 |

Detail enrichment is charged once for each returned place when Place Details, Images, or image attribution is enabled. Place Details includes Google's payload-driven place tags and all available attribute groups rather than a hardcoded category list. Popular Times-only requests are charged only for places where Google returns Popular Times data. Enabling Popular Times together with another detail option does not multiply the charge. Google does not publish every field for every business, so some enriched values may be null.

Full reviews are charged separately at **$0.25 per 1,000 review records actually returned**. Billing uses the number of reviews received, not `maxReviews`, so unavailable reviews are never charged. Base result, Detail enrichment, and review charges are additive when enabled together.

`total cost = base result charge + optional Detail enrichment + actual review records × $0.00025`

***

### Sample Google Maps result

```json
{
  "query": "restaurants in toronto",
  "searchString": "restaurants in toronto",
  "rank": 1,
  "position": 1,
  "title": "Black+Blue Toronto",
  "categoryName": "Restaurant",
  "type": "Restaurant",
  "categories": [
    "Restaurant",
    "Brunch restaurant",
    "Event venue",
    "Fine dining restaurant",
    "Lounge bar",
    "Seafood restaurant",
    "Steak house",
    "Sushi restaurant",
    "Wine bar"
  ],
  "types": [
    "Restaurant",
    "Brunch restaurant",
    "Event venue",
    "Fine dining restaurant",
    "Lounge bar",
    "Seafood restaurant",
    "Steak house",
    "Sushi restaurant",
    "Wine bar"
  ],
  "address": "130 King St W, Toronto, ON M5X 2A2, Canada",
  "neighborhood": "Old Toronto",
  "street": "130 King St W",
  "streetNumber": "130",
  "city": "Toronto",
  "postalCode": "M5X 2A2",
  "state": "Ontario",
  "countryCode": "CA",
  "locatedIn": "Old Toronto",
  "timezone": "America/Toronto",
  "totalScore": 4.7,
  "rating": 4.7,
  "reviewsCount": 5589,
  "ratingCount": 5589,
  "reviewsDistribution": null,
  "priceLevel": "CA$100 or above",
  "phone": "+1 647-368-8283",
  "phoneNumber": "(647) 368-8283",
  "phoneUnformatted": "+16473688283",
  "website": "https://blackandbluesteakhouse.ca/toronto-home/",
  "domain": "blackandbluesteakhouse.ca",
  "placeId": "ChIJ243-C381K4gRHMKWCGU86iM",
  "dataId": "/g/11s9wnk_vb",
  "cid": "2587947340511232540",
  "cidHex": "0x882b357f0bfe8ddb:0x23ea3c650896c21c",
  "fid": "0x882b357f0bfe8ddb:0x23ea3c650896c21c",
  "googleMapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJ243-C381K4gRHMKWCGU86iM",
  "url": "https://www.google.com/maps/search/?api=1&query=Black%2BBlue+Toronto&query_place_id=ChIJ243-C381K4gRHMKWCGU86iM",
  "imageUrl": "https://lh3.googleusercontent.com/gps-cs-s/APNQkA...",
  "thumbnailUrl": "https://lh3.googleusercontent.com/gps-cs-s/APNQkA...",
  "logoUrl": "https://lh3.googleusercontent.com/-ih84iASeZ7Y/AAAAAAA.../photo.jpg",
  "owner": {
    "name": "Black+Blue Toronto (Owner)",
    "googleId": "102477914189084708456"
  },
  "location": {
    "lat": 43.6480996,
    "lng": -79.3831247
  },
  "latitude": 43.6480996,
  "longitude": -79.3831247,
  "plusCode": null,
  "temporarilyClosed": null,
  "permanentlyClosed": null,
  "openingHours": {
    "Friday": "11:30 AM–12 AM",
    "Saturday": "10:30 AM–12 AM",
    "Sunday": "10:30 AM–12 AM",
    "Monday": "11:30 AM–12 AM",
    "Tuesday": "11:30 AM–12 AM",
    "Wednesday": "11:30 AM–12 AM",
    "Thursday": "11:30 AM–12 AM"
  },
  "openingHoursDetailed": [
    { "day": "Friday",    "hours": ["11:30 AM–12 AM"] },
    { "day": "Saturday",  "hours": ["10:30 AM–12 AM"] },
    { "day": "Sunday",    "hours": ["10:30 AM–12 AM"] },
    { "day": "Monday",    "hours": ["11:30 AM–12 AM"] },
    { "day": "Tuesday",   "hours": ["11:30 AM–12 AM"] },
    { "day": "Wednesday", "hours": ["11:30 AM–12 AM"] },
    { "day": "Thursday",  "hours": ["11:30 AM–12 AM"] }
  ],
  "openingHoursState": "Open · Closes 12 AM",
  "serviceHours": {
    "Lunch":       { "Friday": "11:30 AM–2 PM" },
    "Happy hours": { "Friday": "2:30–5:30 PM" },
    "Kitchen":     { "Friday": "11:30 AM–12 AM" },
    "Dinner":      { "Friday": "3 PM–12 AM" },
    "Brunch":      { "Friday": "Closed" }
  },
  "bookingLinks": [
    "https://party-request.tripleseat.com/venues/8qsUeRbI/?rwg_token=...",
    "https://www.google.com/maps/reserve/v/dine/c/DUtUFyMlWBE?source=pa",
    "https://party-request.tripleseat.com/venues/8qsUeRbI/?rwg_token=..."
  ],
  "popularTimesStatus": "unavailable",
  "popularTimes": null,
  "popularTimesLiveText": null,
  "popularTimesLivePercent": null,
  "about": null
}
```

***

### Google Maps use cases

- **Lead generation** — Build targeted prospect lists from Google Maps by business type and location
- **Competitor research** — Monitor Google Maps competitor ratings, hours, and pricing across cities
- **Market analysis** — Map Google Maps business density and coverage in any region
- **Directory building** — Populate local business directories with verified Google Maps contact data
- **CRM enrichment** — Append Google Maps phone, website, coordinates, and hours to existing records

***

### Notes

- Multiple Google Maps queries run in one actor invocation — no need to start separate Google Maps runs per city or keyword.
- Set `gl` to match the country you're targeting for the most accurate local Google Maps results (`gl=ca` for Canada, `gl=gb` for UK, `gl=de` for Germany).
- Use `fields` to trim Google Maps output to only the columns you need — useful for large Google Maps runs where you want a lean dataset.
- When `popularTimes` is enabled, its output fields are included even when `fields` contains a custom field list.
- When place details or images are enabled, their output fields are included even when `fields` contains a custom field list.
- Popular Times is not available for every Google Maps place. Check `popularTimesStatus` for `available` or `unavailable`.
- Popular Times is returned as a compact `day -> hour -> occupancy percent` map.
- Direct Google Maps URLs and Place IDs can be used without a text query.
- Radius, bounding-box, and polygon inputs are processed incrementally and returned places are filtered to the requested area.
- Duplicate places from overlapping centers, continuation requests, or multiple inputs are returned and charged once per run. The `query` field identifies the first input that emitted the place.
- Results are written incrementally. The `CHECKPOINT` key-value-store record can resume an interrupted run without retaining full result rows in Actor memory.
- A restarted execution can paste a prior run's `CHECKPOINT` record into `resumeState`. The input fingerprint must match, and the new run continues at the saved query and map-center offset.
- The 500-place area limit applies per query, not per Actor run. A list of 100 queries continues through all 100 and can therefore emit up to 50,000 rows before run-wide deduplication.
- Review output is limited by `maxReviews`; fewer reviews may be returned when Google has fewer available.
- Failed or empty sources are logged and saved in the run's `ERRORS` key-value-store record; they are not written to the result dataset or billed as results.
- Rich details can include image galleries, contributor attribution, review links, descriptions, accessibility, amenities, menus, order links, and related places.

# Actor input Schema

## `query` (type: `array`):

Enter one search per line, for example `restaurants in Toronto`. Leave empty when using Google Maps URLs or Place IDs below.

## `location` (type: `string`):

Optional named location, for example `Toronto, Canada`. Explicit coordinates, radius, bounding box, or polygon take precedence.

## `locations` (type: `array`):

Optional location list. Every search query is run in every location; when provided, this replaces the single Location value.

## `num` (type: `integer`):

Maximum unique places per query. Ordinary searches are capped at 200; radius, bounding-box, and polygon searches are capped at 500.

## `gl` (type: `string`):

Two-letter Google geolocation country code, such as `us`, `ca`, or `gb`.

## `hl` (type: `string`):

Google interface language code, such as `en`, `fr`, or `de`. Ignored when Languages is provided.

## `languages` (type: `array`):

Optional language list. Each search or direct source is collected once per language.

## `placeDetails` (type: `boolean`):

Include richer hours, descriptions, amenities, accessibility, menus, booking options, related places, and additional metadata.

## `includeImages` (type: `boolean`):

Include available Google Maps place images, image dimensions, identifiers, and capture dates.

## `includeImageAuthors` (type: `boolean`):

Include available image author identifiers and Google Maps contributor links.

## `maxImages` (type: `integer`):

Maximum images retained for each place when image collection is enabled.

## `popularTimes` (type: `boolean`):

Include hourly visitor-traffic data when Google provides it.

## `reviews` (type: `boolean`):

Include reviewer metadata, review text, photos, ratings, dates, and owner responses.

## `maxReviews` (type: `integer`):

Maximum reviews to fetch for each place. Fewer may be returned when Google has fewer reviews available.

## `reviewsSort` (type: `string`):

Order in which Google reviews are requested before applying the maximum.

## `latitude` (type: `number`):

Latitude of the search center. Use together with longitude.

## `longitude` (type: `number`):

Longitude of the search center. Use together with latitude.

## `radiusKm` (type: `number`):

Limit the search area to this radius around the center coordinates.

## `boundingBox` (type: `object`):

Optional bounds with `south`, `west`, `north`, and `east` values.

## `polygon` (type: `array`):

Optional JSON array of `[latitude, longitude]` points defining the search area.

## `customGeolocation` (type: `object`):

Optional GeoJSON Polygon. Coordinates use GeoJSON order: `[longitude, latitude]`. This takes precedence over Polygon.

## `gridSpacingKm` (type: `number`):

Coverage spacing for area searches. Smaller values provide denser geographic coverage.

## `searchWorkers` (type: `integer`):

Number of map centers searched concurrently. Higher values reduce area-search runtime but increase request concurrency.

## `skipClosedPlaces` (type: `boolean`):

Exclude places Google marks temporarily or permanently closed before they are saved or billed.

## `geoStrictMatch` (type: `boolean`):

For radius, bounding-box, and polygon searches, exclude results whose coordinates fall outside the requested area.

## `keepUnverifiedLocations` (type: `boolean`):

Keep service-area and other businesses for which Google does not expose a verifiable street or locality address.

## `skipPlacesNotMatchingSearch` (type: `boolean`):

Exclude results whose title and Google categories do not contain any meaningful term from the search query.

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

Enter one direct Google Maps place or search URL per line.

## `placeIds` (type: `array`):

Enter one Google Maps Place ID per line.

## `fields` (type: `string`):

Optional comma-separated field names. Leave empty to return all available fields. Required add-on fields are included automatically.

## `resumeState` (type: `object`):

Advanced recovery option. Paste the CHECKPOINT record from an interrupted run using the same input.

## Actor input object example

```json
{
  "query": [
    "coffee shops in new york"
  ],
  "num": 200,
  "gl": "us",
  "hl": "en",
  "placeDetails": false,
  "includeImages": false,
  "includeImageAuthors": false,
  "maxImages": 20,
  "popularTimes": false,
  "reviews": false,
  "maxReviews": 10,
  "reviewsSort": "most_relevant",
  "gridSpacingKm": 2,
  "searchWorkers": 4,
  "skipClosedPlaces": false,
  "geoStrictMatch": true,
  "keepUnverifiedLocations": true,
  "skipPlacesNotMatchingSearch": false
}
```

# Actor output Schema

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

All scraped Google Maps business records, one row per place.

# 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 = {
    "query": [
        "coffee shops in new york"
    ],
    "gl": "us",
    "hl": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperlink/google-maps-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 = {
    "query": ["coffee shops in new york"],
    "gl": "us",
    "hl": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("scraperlink/google-maps-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 '{
  "query": [
    "coffee shops in new york"
  ],
  "gl": "us",
  "hl": "en"
}' |
apify call scraperlink/google-maps-scraper --silent --output-dataset

```

## MCP server setup

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