# Google Trends Trending Now (`autofacts/google-trends-trending-now`) Actor

What is trending on Google Search now, in each of the 125 countries Google covers: every trending search with its search volume, rise, start and end time, the searches it is made of, its categories and news count. Past hour, 4 hours, 24 hours, 48 hours or 7 days.

- **URL**: https://apify.com/autofacts/google-trends-trending-now.md
- **Developed by:** [Richard Feng](https://apify.com/autofacts) (community)
- **Categories:** SEO tools, News, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 trending searches

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 Trends Trending Now — What Is Trending in 125 Countries

[![What is trending on Google Search now, in each of the 125 countries Google covers: every trending search with its search volume, rise, start and end time, the searches it is made of, its categories and news count. Past hour, 4 hours, 24 hours, 48 hours or 7 days.](https://api.apify.com/v2/key-value-stores/S4muKkrIdA8DwXiWg/records/readme-hero-v1.png)](https://console.apify.com/actors/EihacoOh48AS6T0wq/input)

What is trending on Google Search right now, in any of the 125 countries Google publishes Trending
Now for — all of them in one run if you like. Each trending search comes back with Google's search
volume for it, how fast it rose, when it started and when it stopped trending, the searches it is
made of, its categories and how many news articles Google links to it. Read the past hour, 4 hours,
24 hours, 48 hours or 7 days. An independent tool, not affiliated with Google.

### 📖 What it does

- 🌍 **Every country Google covers**: the 125 countries of Google's Trending Now page, one, a few or
  all of them in a single run.
- 📈 **Five time windows**: the past hour, 4 hours, 24 hours, 48 hours and 7 days. Each is its own
  list, as on Google's page.
- 📊 **One row per trending search**: its place in the list, Google's search volume (such as
  "200K+"), the rise ("+1,000%"), when it started and, once it has, when it stopped, the searches
  Google groups under it, its categories and how many news articles Google links to it.
- 🔍 **Filters**: Google's 19 categories (Sports, Entertainment, Shopping …), only trends that are
  still active, the top so many per list, and a cap for the whole run.
- 🗂️ **Ready for a history**: the same trend has the same `itemKey` in every window and every run,
  so scheduled runs add up to a timeline of what each country searched for.
- 📦 **A run summary that tells empty from failed**: for every country and window, whether it was
  read, had nothing trending, was stopped by a limit you set, or could not be read and why.

### 🚀 Quick start

1. Pick the **Countries**, or switch on **All 125 countries**.
2. Pick the **Time windows**; the past 24 hours is the default.
3. Run. Each trending search is one row in the dataset.

To keep a history, schedule the run — hourly for the past hour or 4 hours, daily for the past 24
hours — and join the runs on `itemKey`.

### 💡 What people use it for

- **Content and SEO planning** — what people search for today, country by country, while the
  search is still rising.
- **Newsrooms and social teams** — the stories breaking in each market, with the searches behind
  each one and how much news covers it.
- **Marketing timing** — the rising searches in your own category, such as Shopping or Sports, while
  they are still active.
- **Research and data pipelines** — a scheduled, multi-country record of what the world searches
  for, one row per trend, ready for a database.

### 📋 Input

| Field | Type | Default | What it does |
| :--- | :--- | :--- | :--- |
| `countries` | array of country codes | `["US"]` | The countries to read, as two-letter codes (`US`, `GB`, `JP` …). Google publishes Trending Now for 125 countries; China is not among them. |
| `allCountries` | boolean | `false` | Read all 125 countries, whatever `countries` says. |
| `windows` | array | `["24h"]` | `1h` past hour, `4h` past 4 hours, `24h` past 24 hours, `48h` past 48 hours, `7d` past 7 days. Each window is its own list. |
| `categories` | array of category ids | all | Keep only the trends Google files under one of these categories (ids below). |
| `onlyActive` | boolean | `false` | Keep only the trends that are still rising. Off keeps the ones that have ended too, with their end time. |
| `maxItemsPerList` | integer | `0` | At most this many trends from each country and window, the top ones first. `0` keeps all. |
| `maxItems` | integer | `0` | Stop after this many trends in the whole run. `0` means no limit. |
| `proxy` | object | Apify datacenter proxy | Used for every request. |

Category ids: `1` Autos and Vehicles, `2` Beauty and Fashion, `3` Business and Finance, `20`
Climate, `4` Entertainment, `5` Food and Drink, `6` Games, `7` Health, `8` Hobbies and Leisure, `9`
Jobs and Education, `10` Law and Government, `11` Other, `13` Pets and Animals, `14` Politics, `15`
Science, `16` Shopping, `17` Sports, `18` Technology, `19` Travel and Transportation.

The active sports and entertainment trends of the past 24 hours in the United States and Germany,
the top 5 of each:

```json
{
    "countries": ["US", "DE"],
    "windows": ["24h"],
    "categories": ["17", "4"],
    "onlyActive": true,
    "maxItemsPerList": 5
}
```

### 📤 Output

One row per trending search in one country's list. The first of the United States' past 24 hours
on 6 October 2026:

```json
{
    "recordType": "trend",
    "platform": "google",
    "list": "trending_now",
    "listKey": "google|trending_now|US|24h|all|2026-10-06T11:04:52.334Z",
    "itemKey": "google|trending_now|US|robert kelker kelly|2026-10-05T17:50:00.000Z",
    "entityId": null,
    "rank": 1,
    "term": "robert kelker kelly",
    "termLanguage": null,
    "kind": "search",
    "category": null,
    "categories": [
        { "id": 4, "name": "Entertainment", "path": [{ "id": 4, "name": "Entertainment" }] }
    ],
    "metrics": [
        { "name": "searchVolume", "value": 200000, "unit": "searches", "label": "200K+", "nullReason": null },
        { "name": "increase", "value": 1000, "unit": "percent", "label": "+1,000%", "nullReason": null },
        { "name": "newsArticles", "value": 6, "unit": "articles", "label": "6", "nullReason": null }
    ],
    "primaryMetric": "searchVolume",
    "startedAt": "2026-10-05T17:50:00.000Z",
    "endedAt": null,
    "related": [
        "days of our lives",
        "bo brady days of our lives",
        "robert kelker-kelly",
        "bo brady",
        "robert kelker kelly cause of death",
        "robert kelker-kelly today",
        "robert kelker"
    ],
    "geo": "US",
    "geoScope": "country",
    "geoRequested": "US",
    "window": "24h",
    "observedAt": "2026-10-06T11:04:52.334Z",
    "url": "https://trends.google.com/trends/explore?date=now+1-d&geo=US&q=robert+kelker+kelly",
    "extra": {
        "searchVolume": "200K+",
        "increase": "+1,000%",
        "categoryNames": ["Entertainment"],
        "active": true,
        "country": "United States"
    }
}
```

The dataset's **Trending searches** view shows the same as a table: rank, search, country, window,
search volume, rise, start, whether it is active, categories and related searches.

### 🗂️ Data fields

| Field | What it is |
| :--- | :--- |
| `recordType` | Always `trend`. |
| `platform`, `list` | `google` and `trending_now`. |
| `listKey` | The same for every row of one country's list in one window as read in this run; matches an entry of the run summary. |
| `itemKey` | The same for the same trend in every window and every run: country, search and start time. |
| `rank` | The trend's place in Google's list, 1 first. Filters keep Google's places, so a filtered list may go 1, 4, 9. |
| `term` | The search, as Google shows it, in the country's own language and script. |
| `termLanguage` | `null`: Google does not state the language of a search. |
| `kind` | Always `search`. |
| `category` | `null`: Trending Now lists are not asked for by category. The filter keeps rows by `categories`. |
| `categories` | The categories Google files the trend under, each with its id and name. |
| `metrics` | `searchVolume`: Google's volume bucket, a lower bound (200000 is "200K+"). `increase`: the rise Google shows, in percent. `newsArticles`: how many news articles Google links to the trend. A number Google does not show is `null` with its `nullReason`, never 0. |
| `primaryMetric` | `searchVolume`. |
| `startedAt`, `endedAt` | When the trend started, and when it stopped trending; `endedAt` is `null` while it is active. |
| `related` | The searches Google groups under the trend, other than the trend itself. |
| `geo`, `geoRequested`, `geoScope` | The country, as a two-letter code; `geoScope` is `country`. |
| `window` | `1h`, `4h`, `24h`, `48h` or `7d`. |
| `observedAt` | When the list was read. |
| `url` | The search's page on Google Trends, over the matching time range. |
| `extra` | The same facts as text, for reading at a glance: `searchVolume`, `increase`, `categoryNames`, `active`, `country`. |

### 💳 Pricing

Pay per event: one price per trending search stored. A trend in two of the windows you pick is two
rows, charged in each. A list that is empty or could not be read costs nothing, nor does a trend
your filters leave out, nor the run summary. If Apify restarts a run, the lists it had stored are
not stored or charged again.

| Event | Free | Starter | Scale | Business and up |
| :--- | ---: | ---: | ---: | ---: |
| Trending search stored, per 1,000 | $0.80 | $0.70 | $0.60 | $0.50 |
| Actor start, per run | $0.00005 | $0.00005 | $0.00005 | $0.00005 |

How many rows to expect, as measured on 6 and 9 October 2026: the United States had 330 to 480
trending searches over 24 hours and 2,100 to 2,500 over 7 days; all 125 countries together had 700
to 1,100 over 4 hours, 4,200 to 8,200 over 24 hours, 8,900 over 48 hours (6 October) and 28,000 to
37,500 over 7 days. The counts move with the day and the hour. **Maximum trends per
list** and **Maximum trends in total** keep a run to the size you want, and the run's maximum cost
caps what it can charge: all 125 countries over 7 days comes to about $30 on the Free plan, so raise
the maximum cost for a run that large. A run that reaches it stores what fits and marks the rest
`not_reached`.

### ⚠️ Limitations

- **Search volume is Google's bucket**, a lower bound such as "200K+", not an exact count.
- **Google has no past-hour list.** The past hour is the trends of Google's 4-hour list that
  started within the hour, so it is short (21 in the United States on 6 October 2026), and its
  ranks are their places in the 4-hour list.
- **The longer lists leave out some small trends** of the shorter ones (in Britain the 7-day list
  had 30 of the 4-hour list's 35 on 5 October 2026), so read every window you need.
- **Trending Now reaches back 7 days.** For a longer history, schedule the run.
- **Small countries often have nothing trending** in a short window; the run summary marks those
  lists `empty`.
- **Google publishes no Trending Now for China**, so it is not offered.

### ❓ FAQ

**Is this the same as Google's Trending Now page?**
Yes: the same lists with the same numbers, as they stood when the run read them. `rank` is the
order Google gives them in, which is not by volume.

**Why does the same search appear in several windows?**
Each window is its own list, and a trend that started two hours ago is in the 4-hour, 24-hour,
48-hour and 7-day lists. Its `itemKey` is the same in all of them.

**How do I follow a trend over time?**
Schedule the run and join the rows on `itemKey`: the same trend in the same country keeps it in
every run, with its rank, volume and end time as they change.

**Do I need a proxy?**
The default, Apify's datacenter proxy, is enough: our test runs read every list with it. A request
Google refuses is sent again from another address.

**How long does a run take?**
One country and one window take a few seconds. All 125 countries over four windows took two to
three minutes on Apify in our tests: 41,561 rows over 4 hours, 24 hours, 48 hours and 7 days on 6
October 2026, and 46,890 over the past hour, 4 hours, 24 hours and 7 days on 9 October.

### 🤖 Use with AI agents

This Actor is callable as a tool by any MCP-capable agent — Claude, Cursor, VS Code — or by your
own code, with no wrapper and nothing extra to deploy.

**Connect over MCP**

```
https://mcp.apify.com?tools=autofacts/google-trends-trending-now
```

In a client that reads an `mcpServers` configuration block:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=autofacts/google-trends-trending-now",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

The agent reads this Actor's parameters and their descriptions straight from the input
schema, and the hosted server infers the result field types from the dataset schema — so a
model knows what to send and what comes back before it ever calls anything.

**Or call the API directly**

```bash
curl -X POST "https://api.apify.com/v2/acts/autofacts~google-trends-trending-now/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"countries": ["US"], "windows": ["24h"], "proxy": {"useApifyProxy": true}}'
```

The response body is the dataset rows described above, and nothing else: to tell an empty
list from a failure, start the run through `/runs` instead and read its `SUMMARY` record.

#### Run summary — `SUMMARY`

Every run that gets as far as reading writes a `SUMMARY` record to its default key-value store,
also when a list could not be read. A run stopped by its input writes none, nor does one that is
aborted or being restarted by Apify.

```
GET https://api.apify.com/v2/key-value-stores/{defaultKeyValueStoreId}/records/SUMMARY?token=$APIFY_TOKEN
```

A run for the United States and Turkmenistan over the past hour and the past 24 hours, 2 trends
per list:

```json
{
  "status": "SUCCESS",
  "note": "Everything asked for was read. A list marked `empty` had nothing in it.",
  "itemsStored": 6,
  "lists": [
    {
      "listKey": "google|trending_now|US|1h|all|2026-10-06T11:08:52.978Z",
      "platform": "google",
      "list": "trending_now",
      "geoRequested": "US",
      "geo": "US",
      "geoScope": "country",
      "window": "1h",
      "windowStart": "2026-10-06T10:08:52.978Z",
      "windowEnd": "2026-10-06T11:08:52.978Z",
      "category": null,
      "sourceAsOf": null,
      "observedAt": "2026-10-06T11:08:52.978Z",
      "served": 2,
      "total": 21,
      "filtered": false,
      "status": "ok",
      "reason": "The top 2 of 21 trends: the maximum per list you set.",
      "url": "https://trends.google.com/trending?geo=US&hours=4"
    },
    {
      "listKey": "google|trending_now|TM|1h|all|2026-10-06T11:08:52.978Z",
      "platform": "google",
      "list": "trending_now",
      "geoRequested": "TM",
      "geo": "TM",
      "geoScope": "country",
      "window": "1h",
      "windowStart": "2026-10-06T10:08:52.978Z",
      "windowEnd": "2026-10-06T11:08:52.978Z",
      "category": null,
      "sourceAsOf": null,
      "observedAt": "2026-10-06T11:08:52.978Z",
      "served": 0,
      "total": 0,
      "filtered": false,
      "status": "empty",
      "reason": "No trend started in the past hour.",
      "url": "https://trends.google.com/trending?geo=TM&hours=4"
    },
    {
      "listKey": "google|trending_now|US|24h|all|2026-10-06T11:08:54.285Z",
      "platform": "google",
      "list": "trending_now",
      "geoRequested": "US",
      "geo": "US",
      "geoScope": "country",
      "window": "24h",
      "windowStart": "2026-10-05T11:08:54.285Z",
      "windowEnd": "2026-10-06T11:08:54.285Z",
      "category": null,
      "sourceAsOf": null,
      "observedAt": "2026-10-06T11:08:54.285Z",
      "served": 2,
      "total": 331,
      "filtered": false,
      "status": "ok",
      "reason": "The top 2 of 331 trends: the maximum per list you set.",
      "url": "https://trends.google.com/trending?geo=US&hours=24"
    },
    {
      "listKey": "google|trending_now|TM|24h|all|2026-10-06T11:08:54.285Z",
      "platform": "google",
      "list": "trending_now",
      "geoRequested": "TM",
      "geo": "TM",
      "geoScope": "country",
      "window": "24h",
      "windowStart": "2026-10-05T11:08:54.285Z",
      "windowEnd": "2026-10-06T11:08:54.285Z",
      "category": null,
      "sourceAsOf": null,
      "observedAt": "2026-10-06T11:08:54.285Z",
      "served": 2,
      "total": 5,
      "filtered": false,
      "status": "ok",
      "reason": "The top 2 of 5 trends: the maximum per list you set.",
      "url": "https://trends.google.com/trending?geo=TM&hours=24"
    }
  ],
  "restarted": false,
  "startedAt": "2026-10-06T11:08:52.596Z",
  "finishedAt": "2026-10-06T11:08:56.397Z",
  "extra": {}
}
```

| `status` | Meaning | What to do |
| :--- | :--- | :--- |
| `SUCCESS` | Every list asked for was read, or stopped by a limit you set | Use the dataset |
| `PARTIAL_RESULTS` | Some lists could not be read | Use the dataset; run the rest again later |
| `NO_RESULTS` | The same, and nothing was stored | Run again in a few minutes |
| `RUN_FAILED` | The run stopped with an error | The rows already in the dataset are valid |

Each entry of `lists` is one country in one window: its `listKey` (the rows' own), the `window`
with the `windowStart` and `windowEnd` it covers and when it was read (`observedAt`) — all three
`null` for a list that was not read or not stored — the trends stored
from it (`served`) and the trends in Google's list (`total`; for the past hour, those that started
within it), whether your **Categories** or **Only active trends** left trends of the list out
(`filtered`), the list's page on Google Trends (`url`), and its `status`, with a `reason` where
there is something to say:

| `status` | Meaning |
| :--- | :--- |
| `ok` | Read. `served` may be less than `total` for your filters or limits; `reason` says which. |
| `empty` | Google lists nothing trending there in that window. |
| `not_reached` | Not stored: the run had stopped at **Maximum trends in total** or at the maximum charge you set, or the run was close to its time limit. |
| `failed` | Could not be read; `reason` says why. |

`stoppedBy`, only when the run stopped before reading everything, says why: `maxItems`, `chargeLimit` or `timeLimit`. `restarted` says whether the run picked up after Apify restarted it; a restarted run does not
store a list twice.

### 🧰 Other Actors by autofacts

Apify only auto-recommends Actors in the same category, so here are the ones that actually pair with this one:

| Actor | What it's for |
| :--- | :--- |
| [Google Trends](https://apify.com/autofacts/google-trends) | A trend's interest over time, its top and rising related searches and where it is searched most, or the top searches of any of Google's 928 categories |
| [Schema Markup Scraper & SEO Auditor](https://apify.com/autofacts/metadata-scraper) | What the pages that rank for a trending search say about themselves to search engines |
| [YouTube Subtitle & Transcript Scraper](https://apify.com/autofacts/youtube-subtitle-transcript-scraper) | What the videos about a trend say, as clean text |
| [TikTok Transcript & Subtitle Scraper](https://apify.com/autofacts/tiktok-subtitle-transcript-scraper) | The same for TikTok videos |
| [Bluesky Scraper](https://apify.com/autofacts/bluesky-scraper) | What people post about a trend |
| [Google Ads Scraper](https://apify.com/autofacts/google-ads-scraper) | The ads a trending brand runs on Google |

All of them: [apify.com/autofacts](https://apify.com/autofacts)

# Actor input Schema

## `countries` (type: `array`):

The countries to read. Google publishes Trending Now for these 125 countries; China is not among them.

## `allCountries` (type: `boolean`):

Read every country Trending Now covers, whatever Countries says.

## `windows` (type: `array`):

How far back each list reaches. Each window is its own list: Google drops some small trends from the longer lists. Past hour is the 4-hour list's trends that started within the hour.

## `categories` (type: `array`):

Keep only trends Google files under one of these categories. Leave empty for every trend.

## `onlyActive` (type: `boolean`):

Keep only trends that are still rising. Off keeps the ones that have ended too, with their end time.

## `maxItemsPerList` (type: `integer`):

At most this many trends from each country and window, the top ones first. 0 means all of them.

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

Stop after this many trends in the whole run. 0 means no limit.

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

Used for every request. Apify's datacenter proxies by default: Google did not refuse a Trending Now request from them in testing (2026-10-05), and a refused request is sent again from another address.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "allCountries": false,
  "windows": [
    "24h"
  ],
  "categories": [],
  "onlyActive": false,
  "maxItemsPerList": 0,
  "maxItems": 0,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `trends` (type: `string`):

One row per trending search in one country's list: its rank, search volume, rise, start and end, the searches it is made of, its categories and news count.

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

How each country's list went: read, empty (nothing trending), not covered by Google, not reached, or failed with the reason. Tells an empty list from a failure.

# 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 = {
    "countries": [
        "US"
    ],
    "windows": [
        "24h"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("autofacts/google-trends-trending-now").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 = {
    "countries": ["US"],
    "windows": ["24h"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("autofacts/google-trends-trending-now").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 '{
  "countries": [
    "US"
  ],
  "windows": [
    "24h"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call autofacts/google-trends-trending-now --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,autofacts/google-trends-trending-now"
        }
    }
}
```

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/EihacoOh48AS6T0wq/builds/91h1IQgkv29dZ97bo/openapi.json