# Google Shopping Scraper - Prices, Stores & Offers, No Login (`cliqtomedia/google-shopping-scraper`) Actor

Scrape Google Shopping for your search phrases: product title, price as a number with currency, store, rating, reviews and product link. Turn on offers to get every store's price for each product. Pick a country, up to 60 products per search. No login.

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

## Pricing

from $0.95 / 1,000 products

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

Add product searches, pick a country, and get Google Shopping results as one row per product: title, price as a number with currency, store, rating, reviews and the Google product link. Turn on offers to get the price of every store that sells the product. No Google login, no API key; the prefilled search with 10 products costs about $0.033.

Use it for price monitoring, competitor and store research, and product catalog checks. The prefilled search `wireless earbuds` (10 products, US) finishes in about 10 seconds.

![Google Shopping Scraper: searches in, Google Shopping products with price, currency, store and rating out, one row per product](https://api.apify.com/v2/key-value-stores/efvrTsmTobZ7rpoei/records/google-shopping-readme-banner-20261015)

### Table of contents

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

### What it does

For each search phrase, the Actor opens the public Google Shopping results page in the country you choose and reads the products in page order (up to 60). It saves:

- **product card**: position, title, price (number), price text, old price, currency (ISO code), store, "& more stores" flag, rating, number of reviews, delivery and returns notes, condition, Google product IDs and the Google product page link;
- **offers** (optional): for each product, the list of stores from the Google product page, with price, currency, availability, store rating, delivery, returns and a link.

Every row has the search phrase and a status, so you can filter and sort in the Dataset, in a spreadsheet or by API.

#### Good fit

- Check prices of your products and competitors in one country.
- See which stores sell a product and for how much.
- Collect product lists for a category or keyword with ratings and reviews.
- Watch price changes with a daily or weekly schedule.

#### Not a fit / limits

- One Google Shopping page per search: up to 60 products. Google does not give more pages in this format.
- No sorting or price filters: Google ignores them for this kind of request.
- No product images: Google puts small images inside the page code, not as links.
- Rating and reviews are as shown on the Google product card. For some products Google shows the rating of one store listing, so it can differ from other sites.
- The local-currency check covers 61 countries. In other countries results are saved as Google shows them.
- Store links in offers are Google redirect links (`google.com/goto?...`), not direct store URLs.
- In the EU (for example France), Google often does not open the product page. Products are still saved, but their offers are `null` and the row status is `partial` (see [Troubleshooting](#troubleshooting)).

### Quick start

1. Open the **Input** tab.
2. In **Product searches** (`queries`), keep the prefilled `wireless earbuds` or add your own phrases, one per line.
3. Keep **Country** `us` (default) or choose another country.
4. Keep **Products per search** (`maxItems`) at `10` (prefill), or set up to `60`.
5. Click **Start**.
6. Open the **Output** tab and check `title`, `price`, `currency`, `merchant` and `rating`.

Expected result: 10 product rows in USD in about 10 seconds.

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Price monitoring | `queries` (product names or models), `countryCode` | product row | `price`, `currency`, `merchant`, `oldPrice` | Schedule + Google Sheets or API |
| Store comparison | `queries`, `includeOffers: true` | product row with `offers` | `offers[].merchant`, `offers[].price`, `offers[].availability` | Export JSON / Excel |
| Category research | `queries` (category words), `maxItems: 60` | product row | `title`, `rating`, `reviewsCount`, `position` | Export CSV |
| Country check | same `queries`, different `countryCode` | product row | `price`, `currency`, `countryCode` | Compare in a spreadsheet |

### Input

#### Input fields

| Field | Plain name | Type | Required | Default / prefill | Allowed values | Effect | Example |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `queries` | Product searches | array of text | yes | prefill `["wireless earbuds"]` | 1–200 phrases, up to 256 characters each | One Google Shopping page per phrase. Duplicates (ignoring case and extra spaces) and empty lines are removed. | `["iphone 16 case", "dyson v15"]` |
| `countryCode` | Country | text | no | default `us` | 2-letter Google country codes from the list, e.g. `us`, `gb`, `de`, `ca`, `au`, `fr` (`uk` means `gb`) | Google country, store list and currency. In 61 countries the Actor checks that prices are in the local currency. | `"de"` |
| `languageCode` | Language | text | no | default `en` | Google language codes from the list, e.g. `en`, `de`, `fr`, `pt-BR` | Language of the Google page | `"de"` |
| `maxItems` | Products per search | integer | no | default `20`, prefill `10` | 1–60 | How many products to save per phrase, in page order. Google may show fewer. | `40` |
| `includeOffers` | Include offers from other stores | true/false | no | default `false` | true, false | Opens the Google product page of each product and saves all stores. Slower: about 5 seconds per product. | `true` |

Tip: use the language of the country (`de` for Germany, `fr` for France) for the best match. An empty `queries` list, a `maxItems` outside 1–60 or an unknown country stops the run before it starts, with no charge. A list with only empty lines fails at once; only the start fee can be charged.

#### Interacting settings

| When | Input A | Input B | Effective behavior | Cost effect |
| --- | --- | --- | --- | --- |
| Google shows fewer products | `maxItems` | the phrase | Fewer rows than `maxItems` | Only saved products are charged |
| Offers on | `includeOffers: true` | `maxItems` | One extra Google page per product | `product-offers` per product with at least one store |
| Product page not available | `includeOffers: true` | country (often EU) | Row status `partial`, `offers: null` | No `product-offers` charge for that product |
| Many phrases | `queries` (over 30) | run timeout | 300 seconds fits about 30 phrases without offers | Set a longer timeout; price does not change |

#### Input examples

##### Prices for 3 products in Germany

```json
{
  "queries": ["kopfhörer bluetooth", "kaffeemaschine", "staubsauger roboter"],
  "countryCode": "de",
  "languageCode": "de",
  "maxItems": 20
}
```

Expected behavior: 3 Google Shopping pages, up to 20 products each, prices in EUR.
Expected output: `query`, `position`, `title`, `price`, `currency`, `merchant`.
Cost note: 3 searches + 60 products + 1 start = $0.12 on the Free plan.

##### All stores for 5 products

```json
{
  "queries": ["robot vacuum"],
  "countryCode": "us",
  "maxItems": 5,
  "includeOffers": true
}
```

Expected behavior: 5 products, then each Google product page with its stores.
Expected output: `offers` list (store, price, availability), `offersCount`.
Cost note: 1 search + 5 products + 5 offers + 1 start = $0.077 on the Free plan.

### Output

One Dataset row per product. A phrase with no products gets one `not_found` row; a phrase that could not be loaded gets one `error` row.

#### Output fields

| Field | Meaning | Type | Can be empty? | Example / enum |
| --- | --- | --- | --- | --- |
| `query` | Your search phrase | text | no | `"wireless earbuds"` |
| `position` | Place on the Google Shopping page (1 = first) | number | null on `not_found`/`error` rows | `1` |
| `title` | Product name | text | yes | `"JLab Go Air Pop True Wireless Earbuds"` |
| `price` | Price as a number | number | yes, when Google shows no price | `17.99` |
| `priceText` | Price as shown | text | yes | `"$17.99"` |
| `oldPrice` | Price before discount | number | yes | `27` |
| `currency` | ISO currency code | text | yes | `"USD"` |
| `condition` | Condition, when not new | text | yes | `"Refurbished"` |
| `merchant` | Store on the product card | text | yes | `"Best Buy"` |
| `moreMerchants` | Google shows "& more" stores | true/false | yes | `true` |
| `rating` | Rating 0–5, as on the card | number | yes | `4.3` |
| `reviewsCount` | Number of reviews | number | yes | `33000` |
| `delivery` | Delivery note | text | yes | `"Free delivery"` |
| `returns` | Returns note | text | yes | `"30-day returns"` |
| `productUrl` | Google product page with all stores | text | yes | `"https://www.google.com/search?...&udm=28&ibp=oshop&prds=..."` |
| `offers` | Stores for this product: `[{merchant, merchantId, price, priceText, oldPrice, currency, title, availability, merchantRating, delivery, returns, url}]` | array | `null` without `includeOffers` or when the product page was not available; `[]` when the page had no stores | see example |
| `offersCount` | Number of offers | number | null when `offers` is null | `5` |
| `ids` | Google IDs: `catalogId`, `gpcId`, `offerDocId`, `productDocId` | object | each ID can be null | |
| `countryCode`, `languageCode` | Country and language used | text | no | `"us"`, `"en"` |
| `searchUrl` | Google page that was read | text | no | |
| `status` | `complete`, `partial`, `not_found` or `error` | text | no | `complete` |
| `statusReason`, `errorCode` | Reason for `partial`/`not_found`/`error` rows | text | yes | `PRODUCT_PAGE_UNAVAILABLE` |
| `fetchedAt` | When the page was read (ISO 8601) | text | no | |

`null` means Google did not show this value. It is not zero and not an error.

#### Output entities and surfaces

| Situation | Where | Shape | What to do |
| --- | --- | --- | --- |
| Normal product | Dataset | one row per product, `status: complete` | Use `price`, `currency`, `merchant` |
| No products for a phrase | Dataset | one `not_found` row | Check the spelling or try other words |
| Offers not loaded | Dataset | product row, `status: partial`, `offers: null` | Run the phrase again later or in another country |
| Some phrases failed | Dataset + `RUN_SUMMARY` | `error` rows, run status PARTIAL | Run the failed phrases again |
| Run stopped by time or charge limit | `RUN_SUMMARY` | status CAPPED, rows so far are kept; not processed phrases get `error` rows | Raise the limit or split the phrases |

The **Products** view in the Output tab shows the main columns. `RUN_SUMMARY` in the Key-value store has the run status (`COMPLETE`, `PARTIAL`, `NO_RESULTS`, `CAPPED`, `ERROR`), the stop reason, totals (searches, products, charged events, not found, errors, offers not loaded, requests) and, per phrase, its status (`results`, `not_found`, `error`, `not_processed`) and product counts.

The Apify run itself shows SUCCEEDED for `COMPLETE`, `PARTIAL`, `NO_RESULTS` and `CAPPED`. It shows FAILED for invalid input and when Google refused all phrases; rows already saved stay in the Dataset.

#### Output example

First row of the prefill run (`wireless earbuds`, US, 10 products):

```json
{
  "query": "wireless earbuds",
  "position": 1,
  "title": "JLab Go Air Pop True Wireless Earbuds",
  "price": 17.99,
  "priceText": "$17.99",
  "oldPrice": 27,
  "currency": "USD",
  "condition": null,
  "merchant": "Best Buy",
  "moreMerchants": true,
  "rating": 4.3,
  "reviewsCount": 33000,
  "delivery": "Free delivery",
  "returns": null,
  "productUrl": "https://www.google.com/search?q=JLab+Go+Air+Pop+True+Wireless+Earbuds&udm=28&ibp=oshop&prds=catalogid%3A8372463217625314514%2Cgpcid%3A9146411353573113826%2CheadlineOfferDocid%3A452194635528668653%2CproductDocid%3A10114522055954158630&gl=us&hl=en&uule=w+CAIQICINVW5pdGVkIFN0YXRlcw",
  "offers": null,
  "offersCount": null,
  "ids": {
    "catalogId": "8372463217625314514",
    "gpcId": "9146411353573113826",
    "offerDocId": "452194635528668653",
    "productDocId": "10114522055954158630"
  },
  "countryCode": "us",
  "languageCode": "en",
  "searchUrl": "https://www.google.com/search?q=wireless+earbuds&tbm=shop&hl=en&gl=us&uule=w+CAIQICINVW5pdGVkIFN0YXRlcw",
  "status": "complete",
  "statusReason": null,
  "errorCode": null,
  "fetchedAt": "2026-10-15T05:53:19.024Z"
}
```

With `includeOffers: true`, `offers` holds the stores (trimmed, `robot vacuum`, US):

```json
{
  "title": "Dyson Spot+Scrub Ai Wet and Dry Robot Vacuum",
  "price": 849.95,
  "currency": "USD",
  "merchant": "Home Depot",
  "offersCount": 5,
  "offers": [
    {
      "merchant": "Home Depot",
      "merchantId": "8740",
      "price": 849.95,
      "priceText": "$849.95",
      "oldPrice": null,
      "currency": "USD",
      "title": "Dyson Spot+Scrub Ai 10.63 in. Robot Vacuum with smart navigation ...",
      "availability": "In stock online",
      "merchantRating": 4.6,
      "delivery": "Free delivery",
      "returns": "90-day returns",
      "url": "https://www.google.com/goto?url=..."
    }
  ]
}
```

#### Field names in other Google Shopping tools

Some tools use other names. Here is the mapping:

| Other name | This Actor |
| --- | --- |
| `price` as text (`"$19.89"`) | `priceText`; the number is `price`, the currency is `currency` |
| `source` | `merchant` |
| `link` | `productUrl` |
| `productId` | `ids.catalogId` (can be null) |
| `ratingCount` | `reviewsCount` |
| `imageUrl` | not available |

### Pricing and limits

#### Pricing unit

You pay per **Google Shopping page** loaded for a phrase (`search`), per **product** row saved (`product`), and, only with offers on, per **product with loaded stores** (`product-offers`). There is also a small start fee per run. Platform usage (proxy, compute) is included in the price.

| Event | Free | Bronze | Silver | Gold+ |
| --- | ---: | ---: | ---: | ---: |
| Run start (`apify-actor-start`) | $0.006 | $0.006 | $0.006 | $0.006 |
| Search page (`search`) | $0.016 | $0.016 | $0.016 | $0.016 |
| Product (`product`) | $0.0011 | $0.00105 | $0.001 | $0.00095 |
| Product offers (`product-offers`) | $0.01 | $0.01 | $0.01 | $0.01 |

- A phrase with no products costs one search page: Google was asked and answered.
- `error` rows are free. Products with `partial` status (offers not loaded) are charged as a product, not as offers.
- If you set a maximum charge for the run, the Actor stops before it, keeps the rows and ends with status CAPPED.

#### Cost examples (Free plan)

| Scenario | Input scope | Products | Charge |
| --- | --- | ---: | ---: |
| Prefill | 1 phrase, 10 products | 10 | $0.033 |
| About 100 products | 2 phrases, 50 products | 100 | $0.148 |
| About 1,000 products | 20 phrases, 50 products | 1,000 | $1.43 |
| With offers | 1 phrase, 5 products, offers on | 5 | $0.077 |
| Phrase without products | 1 phrase | 0 | $0.022 |

Google decides how many products a page has; the charge follows the real number of saved products.

#### Limits

- Up to 200 phrases and 60 products per phrase in one run. A test with 200 phrases and 60 products each (about 10,000 rows) took about 14 minutes.
- The default timeout is 300 seconds: enough for about 30 phrases without offers (in tests, 10 US phrases took about 60 seconds and 50 German phrases about 160 seconds), or about 50 products with offers. For bigger runs set a longer timeout (for 200 phrases, 1,200 seconds). At the time limit the run stops with status CAPPED and keeps all rows.
- With offers on, each product needs one more Google page, about 5 seconds per product.

### API, export and integrations

- **API:** start the Actor with the same JSON input and read the Dataset items. See the **API** tab for ready code.
- **Export:** download the Dataset as JSON, CSV, Excel or HTML from the **Output** tab.
- **Scheduling:** create a Schedule with your product list to check prices every day or week.

#### Use with AI agents (MCP)

- MCP server with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/google-shopping-scraper`
- Smallest input:

```json
{ "queries": ["wireless earbuds"], "maxItems": 10 }
```

- Key output fields: `title`, `price`, `currency`, `merchant`, `rating`, `reviewsCount`, `productUrl`.
- One phrase takes about 10 seconds and costs $0.033 with 10 products. Keep `includeOffers` off for quick answers.

### Troubleshooting

#### Rows have status `partial` and `offers: null`

Symptom: `includeOffers` is on, but some products have no offers.
Likely reason: Google did not open the product page (`PRODUCT_PAGE_UNAVAILABLE`). This happens often in EU countries. After several such pages the Actor stops asking for offers in this run.
Action: the product rows are fine and offers are not charged. Try again later or in another country.

#### Some phrases have `error` rows

Symptom: the run is PARTIAL, some phrases have one `error` row (`SOURCE_BLOCKED`, `SOURCE_WRONG_REGION`, `SOURCE_TIMEOUT`).
Likely reason: Google refused the page or answered for another country several times.
Action: run only the failed phrases again later. Error rows are not charged.

#### Fewer products than `maxItems`

Symptom: you asked for 60, got 35.
Likely reason: Google showed fewer products for this phrase or country.
Action: nothing to fix; only saved products are charged.

#### The run stopped with CAPPED

Symptom: `RUN_SUMMARY` has `CAPPED` and some phrases have `error` rows "Not processed".
Likely reason: the run timeout or your maximum charge was reached.
Action: set a longer timeout or a higher charge limit, or split the phrases into several runs.

#### Results look different from my browser

Likely reason: your browser shows results for your location and account. The Actor gets results for the chosen country without an account, and Google changes the list often.

### FAQ

#### Do I need a Google account or API key?

No. The Actor reads public Google Shopping pages without login or cookies of any account.

#### Which countries work?

You can choose any country from the list, but Google Shopping does not work in every country. Tests used the US, UK, Germany, Canada, France and Australia. In 61 countries (for example the US, UK, Canada, Australia, the euro area, Japan, India and Brazil) the Actor checks that prices are in the local currency; if Google answers for another country, it tries again from a new IP address. In other countries it saves the results as Google shows them and writes `COUNTRY_NOT_CHECKED` in the `RUN_SUMMARY` warnings.

#### Why is `price` a number?

So you can sort and compare. The price as shown is in `priceText`, and the currency code is in `currency`.

#### What does `null` mean?

Google did not show that value, for example no rating or no old price. It is not zero and not an error.

### Related Actors

- [Google Autocomplete Scraper](https://apify.com/cliqtomedia/google-autocomplete-scraper) — find product search phrases to use as `queries`.
- [Website JSON-LD Structured Data Scraper](https://apify.com/cliqtomedia/website-jsonld-structured-data-scraper) — read product data (price, availability) from store pages.
- [Website Metadata & Open Graph Scraper](https://apify.com/cliqtomedia/website-metadata-open-graph-scraper) — get titles and images of store pages.
- [Website Screenshot & PDF](https://apify.com/cliqtomedia/website-screenshot-pdf) — save store pages as images or PDF.

### Support

For bugs, questions or feature requests, open the **Issues** tab of this Actor. Add the run ID, your input (phrases can be shortened) and the `statusReason` text. Never send tokens, cookies or passwords.

# Changelog

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

# Actor input Schema

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

What to search on Google Shopping, one per line, e.g. "wireless earbuds" or "iphone 17 pro 256gb". Up to 200 searches; duplicates are removed.

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

Google Shopping country (gl parameter): products, stores and prices for buyers in this country. In 61 countries (for example the US, UK, Canada, Australia, the euro area, Japan, India, Brazil) prices are checked against the local currency and a page answered for another country is asked again; in other countries results are saved as Google shows them. Google Shopping is not available in every country; then the query returns a not_found row. Default: United States.

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

Google interface language (hl parameter). It changes labels such as delivery and returns texts; prices stay in the local currency. Default: English.

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

How many products to save for each search, in Google's order. Google Shopping shows one page of about 40–60 products per search and has no further pages, so a search can return fewer.

## `includeOffers` (type: `boolean`):

Open each product and add the stores that sell it (store, price, availability, delivery, returns, store rating, link). Adds one event per product with at least one store. Slower: about 5 seconds per product on average (product pages open 5 at a time).

## Actor input object example

```json
{
  "queries": [
    "wireless earbuds"
  ],
  "countryCode": "us",
  "languageCode": "en",
  "maxItems": 10,
  "includeOffers": false
}
```

# Actor output Schema

## `products` (type: `string`):

Products as a table.

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

Status, per-search counts, charged events and request statistics.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "wireless earbuds"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/google-shopping-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": ["wireless earbuds"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/google-shopping-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": [
    "wireless earbuds"
  ],
  "maxItems": 10
}' |
apify call cliqtomedia/google-shopping-scraper --silent --output-dataset

```

## MCP server setup

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