# Google Trends Scraper & API: Related Queries, Trending Now (`tidewell/google-trends-api`) Actor

Compare up to 5 keywords on Google Trends for any country, time range, category and search type (web, news, images, YouTube, Shopping). Get interest over time, interest by region, top and rising related queries and topics, plus Trending Now by country. $3 per 1,000 search terms, no start fee.

- **URL**: https://apify.com/tidewell/google-trends-api.md
- **Developed by:** [Tidewell Software](https://apify.com/tidewell) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Trends Scraper & API: interest over time, regions, related queries, Trending Now

Get Google Trends data as clean JSON, CSV or Excel. Compare up to 5 keywords on the same 0-100 scale, for any country or region, any time range, any category and any Google search type: web, news, images, YouTube or Shopping. For each search term you get:

- **Interest over time**, with average, peak and latest values worked out for you
- **Interest by region**: countries, states, metros (DMA) or cities, plus each term's share per region when you compare terms
- **Related queries**, top and rising, with *Breakout* flags
- **Related topics**, top and rising, when Google returns them (see the FAQ)
- **Trending Now**: today's trending searches by country, with approximate search volume and the news stories behind them

**$3 per 1,000 search terms and $1 per 1,000 trending searches.** There is no start fee and no monthly rental. Terms that fail or have no data are free.

Docs, examples, MCP setup and an honest comparison with other actors: [plugin.benjaminbritton.co.uk/google-trends-api/](https://plugin.benjaminbritton.co.uk/google-trends-api/)

### Why use this Google Trends API

- **Maintained, with a clear status.** The actor follows the same request flow as the Trends website: explore, then widget tokens, then widget data. It paces its requests and backs off and retries when Google rate-limits. When Google changes something, the fix ships here.
- **You pay for results, not attempts.** A comparison that fails after all retries, or a term Google has "not enough data" for, is not charged. `RUN_SUMMARY` lists exactly what happened to every comparison.
- **Real comparisons.** Put `chatgpt, gemini, claude` on one line and all three come back on one shared scale, the way the Trends page shows them. Each term gets its own row, so you can sort and filter the results.
- **Two output shapes, same price.** Choose *one row per search term* (nested, best for APIs and AI agents) or *one row per data point* (long format that opens directly in Excel, Google Sheets, Looker Studio or Power BI). You are charged per search term either way, never per row.
- **Every Trends option.** Choose the geo (country or region), time range (past hour to 2004-present, or a custom date range), category, search type, region resolution, low-volume regions and language.
- **Many countries in one run.** Set `geo` to `US, GB, DE` and every comparison runs for each country.
- **No personal data.** Google Trends data is aggregated and anonymised. The actor doesn't log in and collects nothing about individuals.

### Use cases

- **SEO and content planning:** find rising queries and breakout topics before they peak, and check seasonality before you commit to a content calendar.
- **Brand and competitor tracking:** compare your brand with 4 competitors every week, per country.
- **Product and market research:** check demand for a product or category by region before launch, and compare demand across YouTube, Shopping and web search.
- **Newsrooms and social teams:** pull Trending Now for several countries every morning, with the news links behind each trend.
- **AI agents and automations:** call it from Make, Zapier, n8n, LangChain or Apify's MCP server, and get compact JSON with summary fields (`averageInterest`, `peakDate`, `latestInterest`) that an LLM can reason over.
- **Data science:** build long-run interest time series as features for forecasting models.

### How to use it

1. Add **Search terms**, one comparison per line. Put up to 5 comma-separated terms on a line to compare them, or a single term to fetch it on its own. Google topic IDs (such as `/m/0dl567`) work too.
2. Set **Country / region** (leave it empty for Worldwide), the **Time range**, and optionally the **Category** and **Search type**.
3. Optionally add **Trending Now countries**.
4. Click **Start**, then download the dataset as JSON, CSV, Excel or XML, or read it with the Apify API.

#### Input example: compare three AI assistants in the US over 12 months

```json
{
  "searchTerms": ["chatgpt, gemini, claude"],
  "geo": "US",
  "timeframe": "today 12-m"
}
```

#### Input example: YouTube interest in two phones, in the UK and Germany, as spreadsheet rows

```json
{
  "searchTerms": ["iphone 17, pixel 10"],
  "geo": "GB, DE",
  "timeframe": "today 3-m",
  "property": "youtube",
  "outputFormat": "rows"
}
```

#### Input example: custom date range, Computers & Electronics category, metro-level regions

```json
{
  "searchTerms": ["python", "rust, golang"],
  "geo": "US",
  "customTimeframe": "2024-01-01 2024-12-31",
  "category": 5,
  "regionResolution": "DMA"
}
```

#### Input example: Trending Now for five countries (no search terms needed)

```json
{
  "trendingGeos": ["US", "GB", "DE", "IN", "JP"]
}
```

#### Input fields

| Field | What it does |
|---|---|
| `searchTerms` | One comparison per line. Up to 5 comma-separated terms per line share one 0-100 scale. A line with more than 5 terms is split into groups of 5, and you get a warning |
| `geo` | `US`, `GB`, `US-CA`, `GB-ENG`... Empty means Worldwide. Separate several with commas to run each comparison per geo |
| `timeframe` | `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`, `today 3-m`, `today 12-m` (default), `today 5-y`, `all` |
| `customTimeframe` | Overrides `timeframe`: `2024-01-01 2024-12-31`, or hourly `2026-11-01T00 2026-11-07T23` |
| `category` | Trends category ID. `0` means all categories. Examples: 5 Computers & Electronics, 7 Finance, 18 Shopping, 20 Sports, 45 Health, 71 Food & Drink, 958 Jobs & Education. Sub-category IDs work too, for example 31 Programming |
| `property` | `""` web (default), `news`, `images`, `youtube`, `froogle` (Google Shopping) |
| `includeInterestOverTime`, `includeInterestByRegion`, `includeRelatedQueries`, `includeRelatedTopics` | Turn sections off for faster runs. The price per term stays the same |
| `regionResolution` | `auto`, `COUNTRY`, `REGION`, `DMA` (US metros), `CITY` |
| `includeLowSearchVolumeRegions` | Also list low-volume regions |
| `trendingGeos` | Country codes for Trending Now |
| `outputFormat` | `perTerm` (default) or `rows` (long format) |
| `language` | `en-US` (default), `de`, `fr`, `ja`... Sets the language of region names and topic titles |
| `proxyConfiguration` | Apify Proxy is on by default. If Google rate-limits a request, the actor retries it on a new proxy IP |
| `requestDelaySecs`, `maxRetries` | Request pacing and retry budget |

### Output

#### One row per search term (default)

```json
{
  "type": "searchTerm",
  "searchTerm": "chatgpt",
  "comparedWith": ["gemini", "claude"],
  "termIndex": 0,
  "geo": "US",
  "timeframe": "today 12-m",
  "category": 0,
  "property": "web",
  "hasData": true,
  "averageInterest": 74.0,
  "peakInterest": 100,
  "peakDate": "2025-11-02",
  "latestInterest": 76,
  "latestDate": "2026-11-01",
  "interestOverTime": [
    {"time": "2025-11-02T00:00:00Z", "date": "2025-11-02", "formattedTime": "Nov 2 – 8, 2025", "value": 100, "hasData": true, "isPartial": false}
  ],
  "interestByRegion": [
    {"geoCode": "US-CA", "geoName": "California", "value": 100},
    {"geoCode": "US-WY", "geoName": "Wyoming", "value": 89}
  ],
  "interestByRegionShare": [
    {"geoCode": "US-CA", "geoName": "California", "share": 57}
  ],
  "relatedQueriesTop": [
    {"rank": 1, "query": "chatgpt ai", "value": 100, "formattedValue": "100", "exploreUrl": "https://trends.google.com/trends/explore?q=chatgpt+ai&date=today+12-m&geo=US"}
  ],
  "relatedQueriesRising": [
    {"rank": 1, "query": "chatgpt codex", "value": 1300, "formattedValue": "+1,300%", "isBreakout": false, "exploreUrl": "https://trends.google.com/trends/explore?q=chatgpt+codex&date=today+12-m&geo=US"}
  ],
  "relatedTopicsTop": [],
  "relatedTopicsRising": [],
  "errors": [],
  "exploreUrl": "https://trends.google.com/trends/explore?q=chatgpt,gemini,claude&date=today%2012-m&geo=US",
  "scrapedAt": "2026-11-08T03:05:04Z"
}
```

| Field | Notes |
|---|---|
| `averageInterest` | Google's own average for the period (in comparisons), otherwise the mean of the points that have data |
| `peakInterest`, `peakDate` | Highest point in the period |
| `latestInterest`, `latestDate` | Last *complete* period. The current, partial week or day is flagged `isPartial: true` and skipped here |
| `interestByRegion[].value` | 0-100 within this term: 100 is the region where the term is most popular as a share of all searches there |
| `interestByRegionShare[].share` | Comparisons only: this term's percentage of the compared terms in that region (the coloured map on the Trends page) |
| `relatedQueriesRising[].value` | Percentage growth. `isBreakout: true` means growth above 5,000% (Google shows "Breakout") |
| `hasData` | `false` when Google has not enough data for the term. These rows are free |
| `errors` | Sections that failed after retries. The rest of the row is still returned |

#### One row per data point (`outputFormat: "rows"`)

Each search term gives one summary row (`type: "searchTerm"`, no nested arrays) plus:

- `interestOverTime` rows: `searchTerm, geo, date, time, value, isPartial`
- `interestByRegion` rows: `searchTerm, geoCode, geoName, value, share`
- `relatedQuery` rows: `searchTerm, rankType (top/rising), rank, query, value, formattedValue, isBreakout`
- `relatedTopic` rows: `searchTerm, rankType, rank, topicId, topicTitle, topicType, value`

#### Trending Now rows

```json
{
  "type": "trendingSearch",
  "geo": "US",
  "rank": 1,
  "query": "texas state vs oregon state",
  "approxTraffic": "2000+",
  "approxTrafficNumber": 2000,
  "startedAt": "2026-11-08T02:40:00Z",
  "pictureUrl": "https://encrypted-tbn2.gstatic.com/images?q=...",
  "pictureSource": "OregonLive.com",
  "news": [
    {"title": "Oregon State Beavers vs. Texas State Bobcats: Live updates today", "snippet": null, "url": "https://www.oregonlive.com/...", "source": "OregonLive.com", "pictureUrl": "https://..."}
  ],
  "exploreUrl": "https://trends.google.com/trends/explore?q=texas%20state%20vs%20oregon%20state&date=now%201-d&geo=US",
  "scrapedAt": "2026-11-08T03:05:01Z"
}
```

The dataset has three views: **Search terms**, **Trending Now** and **Data points (long format)**. The key-value store record `RUN_SUMMARY` lists each comparison's status, how many terms returned data, any errors, and HTTP statistics.

### Use from Claude / ChatGPT (MCP)

Run this actor from an AI assistant through Apify's hosted MCP server. This server URL loads only this actor:

```
https://mcp.apify.com/?tools=tidewell/google-trends-api
```

- **Claude (claude.ai and Claude Desktop):** Settings → Connectors → Add custom connector. Name it `Apify`, paste the URL, then sign in to Apify.
- **Claude Code:** `claude mcp add apify "https://mcp.apify.com/?tools=tidewell/google-trends-api" -t http`
- **ChatGPT:** add a custom MCP server named `Apify` with the URL above and OAuth. In the desktop app: Settings → MCP servers → Add server → Streamable HTTP.
- **Cursor, VS Code and other MCP clients:** `{"mcpServers": {"apify": {"url": "https://mcp.apify.com/?tools=tidewell/google-trends-api"}}}`. Clients without OAuth can add the header `Authorization: Bearer <APIFY_TOKEN>`.

Then ask in plain language, for example: *"Use tidewell/google-trends-api to compare chatgpt, gemini and claude in the US over the last 12 months and tell me which is rising fastest."* The actor appears as the tool `tidewell--google-trends-api`. Runs are billed to your Apify account at the prices below.

Full setup guide, examples and comparisons: [plugin.benjaminbritton.co.uk/google-trends-api/](https://plugin.benjaminbritton.co.uk/google-trends-api/)

### Pricing

Pay per event. You pay only for what comes back:

| Event | Price | When |
|---|---|---|
| Search term result | **$0.003** | Once per search term that returned data. A 3-term comparison costs $0.009, whatever the output format or number of sections |
| Trending search | **$0.001** | Once per Trending Now row. A country usually returns 10 rows, so $0.01 per country |

There is no start fee. Failed comparisons and terms with no data cost nothing. A run with an empty input (no search terms and no countries) returns Trending Now for the US as a sample, which costs $0.01. Set **Max cost per run** in the run options to cap spending: the actor stops cleanly before a comparison that would go over the limit.

Examples:

- 100 single keywords for one country: **$0.30**
- 20 comparisons of 5 brands in 3 countries (300 terms): **$0.90**
- Trending Now for 10 countries every day for a month: about **$3**

### Tips

- **Compare on one line.** Values are only comparable within one comparison, so put the terms you want side by side on the same line, up to 5.
- **Use a topic ID for ambiguous words.** "Python" the language and "python" the snake are different topics. Find the ID in the Trends URL after you choose a topic (`/m/05z1_`) and use it as the term.
- **Interest is relative.** 100 is the peak for the chosen terms, place and time, not an absolute search count. For absolute volumes, use a keyword-planner tool. Trending Now's `approxTraffic` is Google's own rough count.
- **Short time ranges need popular terms.** For `now 1-H` or `now 4-H`, low-volume terms often come back with `hasData: false`. You are not charged for those.
- **Big runs:** keep Apify Proxy on, and don't set `requestDelaySecs` below 1. One comparison takes about 5-20 seconds, depending on the number of terms and sections.

### FAQ

**Is scraping Google Trends legal? What about Google's terms?**
Google Trends data is public, aggregated and anonymised, and this actor collects no personal data. Google has no official public Trends API, though, and Google's Terms of Service restrict automated access to its services. Using this actor may therefore conflict with Google's terms, even though it only requests the same public data the Trends website shows, and paces its requests. You are responsible for how you use the data and for checking that your use fits your own legal and compliance requirements. If you need a contractual guarantee, apply for Google's official Trends API (in limited alpha since 2025) or use a licensed data provider. This is not legal advice.

**Why are related topics sometimes empty?**
Google often returns an empty related-topics list to automated requests, even when the Trends page shows topics in a browser. When that happens the actor returns empty `relatedTopicsTop` / `relatedTopicsRising` lists rather than guessing. Related queries are not affected. If you don't need topics, turn them off for faster comparisons.

**Will the numbers match what I see on trends.google.com?**
Usually yes, for the same terms, geo, time range, category and search type. Google samples its data, so values can move by a few points between requests and from day to day, and very low-volume terms can show 0 one day and data the next. The `exploreUrl` in each row opens the same view on Google Trends so you can check.

**What happens when Google rate-limits?**
The actor waits and retries with exponential backoff. With Apify Proxy on (the default), it moves to a fresh IP and session. If a request still fails after all retries, that comparison is reported in `RUN_SUMMARY` and not charged, and the run continues with the next one. If nothing at all comes back, the run fails with a clear message, so a schedule doesn't silently store empty data.

**Can I get daily data for more than 9 months?**
Google returns daily points for ranges up to about 9 months, weekly points up to 5 years, and monthly points beyond that. For a long daily series, run consecutive custom ranges with an overlap and rescale them using the overlapping days.

**Can I schedule it?**
Yes. Use Apify Schedules (for example, Trending Now every morning, or a weekly brand comparison) and connect the dataset to Google Sheets, Slack, a webhook, Make or Zapier.

**Something broke or looks wrong?**
Open an issue on the actor's Issues tab and include the run ID. Google changes Trends from time to time, and fixes are released quickly.

### Keywords

google trends api, google trends scraper, google trends python alternative, pytrends alternative, interest over time, interest by region, related queries, rising queries, breakout keywords, related topics, trending searches, trending now, daily trends, keyword trends, youtube trends, google shopping trends, google news trends, compare keywords, seasonality, seo keyword research

# Actor input Schema

## `searchTerms` (type: `array`):

One comparison per line. Put up to 5 terms on one line, separated by commas, to compare them on the same 0-100 scale (e.g. 'chatgpt, gemini, claude'). A line with one term is fetched on its own. Topic IDs such as /m/0dl567 work too. Each term that returns data is one charged result.

## `geo` (type: `string`):

Two-letter country code (US, GB, DE, IN), a region code (US-CA, GB-ENG), or leave empty for Worldwide. Separate several with commas to run every comparison for each one, e.g. 'US, GB, DE'.

## `timeframe` (type: `string`):

The period to fetch. Google picks the resolution: minutes or hours for 'now' ranges, days up to 9 months, weeks up to 5 years, months beyond that.

## `customTimeframe` (type: `string`):

Overrides 'Time range'. Dates as 'YYYY-MM-DD YYYY-MM-DD' (e.g. '2024-01-01 2024-12-31'), or hourly as 'YYYY-MM-DDTHH YYYY-MM-DDTHH' for windows up to 7 days.

## `category` (type: `integer`):

Google Trends category ID to narrow the meaning of a term. 0 = all categories. Top-level IDs: 3 Arts & Entertainment, 5 Computers & Electronics, 7 Finance, 8 Games, 11 Home & Garden, 12 Business & Industrial, 13 Internet & Telecom, 16 News, 18 Shopping, 20 Sports, 29 Real Estate, 44 Beauty & Fitness, 45 Health, 47 Autos & Vehicles, 65 Hobbies & Leisure, 66 Pets & Animals, 67 Travel, 71 Food & Drink, 174 Science, 958 Jobs & Education. Sub-categories work too (see the README).

## `property` (type: `string`):

Which Google search to measure.

## `includeInterestOverTime` (type: `boolean`):

The 0-100 time series, with average, peak and latest values.

## `includeInterestByRegion` (type: `boolean`):

Interest per country (Worldwide) or per subregion (country). When comparing terms, also the share of each term per region.

## `regionResolution` (type: `string`):

Level of the interest-by-region breakdown. 'Auto' uses Google's default (countries for Worldwide, subregions for a country). Metro (DMA) is US only.

## `includeLowSearchVolumeRegions` (type: `boolean`):

Also list regions with low search volume, as the checkbox on the Trends page does.

## `includeRelatedQueries` (type: `boolean`):

Top and rising related searches per term, with 'Breakout' flags.

## `includeRelatedTopics` (type: `boolean`):

Top and rising related topics per term. When comparing several terms this needs one extra explore per term. Google often returns an empty list here for automated requests.

## `trendingGeos` (type: `array`):

Country codes, one per line (e.g. US, GB, DE, IN). Returns the current trending searches with approximate search volume, start time and the news articles behind each. Charged per trending search.

## `outputFormat` (type: `string`):

'One row per search term' keeps each term's time series, regions and related queries together (best for JSON and APIs). 'One row per data point' writes long-format rows (date / region / query) that open directly in Excel, Sheets and BI tools. The price is the same: you pay per search term, not per row.

## `language` (type: `string`):

Language for region names and topic titles, e.g. en-US, en-GB, de, fr, ja.

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

Apify Proxy is recommended for runs with more than a few comparisons.

## `requestDelaySecs` (type: `number`):

Minimum gap between requests to Google. Lower is faster but more likely to be rate-limited.

## `maxRetries` (type: `integer`):

Retries for rate-limited (429) or failed requests, with exponential backoff.

## Actor input object example

```json
{
  "searchTerms": [
    "chatgpt, gemini, claude"
  ],
  "geo": "US",
  "timeframe": "today 12-m",
  "category": 0,
  "property": "",
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "regionResolution": "auto",
  "includeLowSearchVolumeRegions": false,
  "includeRelatedQueries": true,
  "includeRelatedTopics": true,
  "trendingGeos": [
    "US"
  ],
  "outputFormat": "perTerm",
  "language": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestDelaySecs": 1,
  "maxRetries": 5
}
```

# Actor output Schema

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

One row per search term (or per data point in long format), plus one row per trending search.

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

Per-comparison status, including anything that failed or was skipped.

# 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 = {
    "searchTerms": [
        "chatgpt, gemini, claude"
    ],
    "geo": "US",
    "timeframe": "today 12-m",
    "trendingGeos": [
        "US"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tidewell/google-trends-api").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 = {
    "searchTerms": ["chatgpt, gemini, claude"],
    "geo": "US",
    "timeframe": "today 12-m",
    "trendingGeos": ["US"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("tidewell/google-trends-api").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 '{
  "searchTerms": [
    "chatgpt, gemini, claude"
  ],
  "geo": "US",
  "timeframe": "today 12-m",
  "trendingGeos": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call tidewell/google-trends-api --silent --output-dataset

```

## MCP server setup

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

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/zSk0sTFQra7mBmsfb/builds/8YWTMBcOSKByBkcsf/openapi.json