# Google Trends Scraper & API: Interest, Related, Trending (`sunburst077/google-trends-reliable`) Actor

Reliable Google Trends data: interest over time, interest by region, related queries and topics, and Trending Now. Pay-per-event, no browser, partial results still succeed.

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

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Trends Scraper & API: Interest, Related, Trending

Get [Google Trends](https://trends.google.com) data (**interest over time**, **interest by region**, **related queries** and **topics**, and **Trending Now**) as clean JSON or CSV, without a browser. It talks to the same public JSON endpoints the Trends website uses. There is no browser, so there is no page-load timeout to abort the run.

Built to be a drop-in alternative to existing Store Actors: the familiar `searchTerms`, `isMultiple`, `timeRange`, `geo`, `category`, and `startUrls` fields still work. Failed widgets become error rows. The run still finishes **SUCCEEDED**.

### Why this Actor

Google Trends does not offer a public official API. The old Python library most tutorials recommend, pytrends, is archived. Browser-based scrapers stall on 429s and timeouts. This Actor is the opposite of that:

- **Direct endpoints.** `GET /trends/api/explore` for tokens, then one `widgetdata` call per chart. Trending Now uses the current `batchexecute` RPC (`i0OFE`), with the public RSS feed as fallback.
- **Retries that do not kill the run.** Exponential backoff with jitter, NID cookie warmup, request pacing, and per-widget retry. A missing related-topics block does not throw away the timeline you already paid to fetch.
- **Cheap to run.** No Chromium. Default 512 MB. Uses the automatic Apify Proxy. You are billed **$0.02 per run** and **$0.0015 per successful dataset row**. Failed items are free.
- **Store-test friendly.** The default input (`bitcoin`, US, past 12 months) returns non-empty interest-over-time and related-queries rows in seconds.

### What you get

| Data type | Google Trends UI | Notes |
| --- | --- | --- |
| Interest over time | Explore chart | Minute / day / week / month granularity follows the time range |
| Interest by region | Interest by subregion / city / metro | `resolution`: COUNTRY, REGION, CITY, DMA |
| Related queries | Top and rising | Returned in Google's own objects. Rising queries are decoy-filtered by default (see [Rising queries and decoys](#rising-queries-and-decoys)) |
| Related topics | Top and rising | Requested; Google often returns an empty list to scripted clients |
| Trending Now | trending.google.com/trending | Country + 4h / 24h / 48h / 7d window |

Compare up to **5 terms per request**. Many terms are batched automatically.

### Input

#### Default (daily Store test)

```json
{
  "searchTerms": ["bitcoin"],
  "timeRange": "today 12-m",
  "geo": "US",
  "property": "web",
  "dataTypes": ["TIMESERIES", "GEO", "RELATED_QUERIES"],
  "outputMode": "perDataType"
}
```

#### Compare terms on one scale

```json
{
  "searchTerms": ["openai, anthropic, google gemini"],
  "isMultiple": true,
  "timeRange": "today 3-m",
  "geo": "US",
  "property": "youtube"
}
```

#### Start from a Trends URL

```json
{
  "startUrls": [
    { "url": "https://trends.google.com/trends/explore?q=electric%20bike&geo=DE&date=today%2012-m" }
  ]
}
```

#### Trending Now only

```json
{
  "fetchTrendingNow": true,
  "trendingSearchesCountry": "US",
  "trendingSearchesTimeframe": "24",
  "trendingSearchesMaxItems": 50
}
```

#### Familiar fields (drop-in)

| Field | What it does |
| --- | --- |
| `searchTerms` | List of keywords. Required unless you use URLs, a sheet, or Trending Now. |
| `isMultiple` | Treat commas as comparison separators (max 5 per group). |
| `timeRange` | `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`, `today 3-m`, `today 12-m`, `today 5-y`, `all`. |
| `customTimeRange` | `YYYY-MM-DD YYYY-MM-DD`, overrides `timeRange`. |
| `geo` | Country or region code. Empty = worldwide. |
| `category` | Numeric Trends category id. Empty = all. |
| `property` / `gprop` | `web`, `news`, `images`, `youtube`, `froogle` (Shopping). |
| `startUrls` | Explore URLs; `q` / `geo` / `date` / `cat` / `gprop` win per URL. |
| `spreadsheetId` | Public Google Sheet, first column, row 1 is the header. |
| `viewedFrom` | Interface language (`en-US`). |
| `maxItems`, `maxConcurrency`, `maxRequestRetries` | Accepted. Concurrency defaults to 1 on purpose. |
| `skipDebugScreen`, `pageLoadTimeoutSecs` | Accepted and ignored (no browser). |

#### Extra fields this Actor adds

| Field | Default | What it does |
| --- | --- | --- |
| `dataTypes` | interest over time, region, related queries | Also `RELATED_TOPICS`, `TRENDING_NOW`. |
| `resolution` | Auto | `COUNTRY`, `REGION`, `CITY`, `DMA`. |
| `outputMode` | `perDataType` | `combined` for one nested row per term; `flat` for CSV. |
| `risingFilter` | `strict` | `strict`, `balanced`, or `off`. Filters decoy rising queries. See [Rising queries and decoys](#rising-queries-and-decoys). |
| `fetchTrendingNow` | false | Daily / real-time trending list. |
| `requestDelayMs` | 350 | Pacing between Google calls. |
| `proxyConfiguration` | Automatic Apify Proxy (`useApifyProxy: true`) | See [Proxy](#proxy). |

### Output

**`perDataType` (default)** — one clean dataset row per term per widget:

```json
{
  "dataType": "interest_over_time",
  "status": "ok",
  "searchTerm": "bitcoin",
  "searchTerms": ["bitcoin"],
  "geo": "US",
  "timeRange": "today 12-m",
  "property": "web",
  "itemCount": 53,
  "timeline": [{ "time": "1761436800", "value": [32], "formattedAxisTime": "Oct 26, 2025" }],
  "trendsUrl": "https://trends.google.com/trends/explore?q=bitcoin&geo=US"
}
```

**`combined`** — one nested row per term, with the field names other Store Actors already emit:

`interestOverTime_timelineData`, `interestOverTime_averages`, `interestBy` / `interestBySubregion` / `interestByCity` / `interestByMetro`, `relatedQueries_top`, `relatedQueries_rising`, `relatedTopics_top`, `relatedTopics_rising`.

**`flat`** — one row per time point, region, or related item. Easy to open in Google Sheets. Billed per row, so a 5-year weekly series costs more than `perDataType`.

Error rows look like this and are **not charged**:

```json
{
  "dataType": "related_topics",
  "status": "error",
  "errorCode": "NO_DATA",
  "error": "related_topics_empty: Google returned an empty rankedList for RELATED_TOPICS.",
  "searchTerm": "bitcoin"
}
```

### Pricing

Pay-per-event. You are not billed for platform compute on top of the event prices (standard PPE). Failed items are free.

| Event | Price | When |
| --- | --- | --- |
| `apify-actor-start` | **$0.00005** | Once per run (Apify platform start event) |
| `run-start` | **$0.02** | Once per run |
| `result` | **$0.0015** | Each successful dataset row |

A typical one-keyword explore (timeline + region + related queries) is about **$0.0246**. See [PRICING.md](PRICING.md) for compute/proxy cost and margin.

Set a max total charge on the run if you want the Actor to stop cleanly instead of overrunning a budget.

### Proxy

Default: **automatic Apify Proxy** (`useApifyProxy: true`, no group selected). It works on all Apify plans, including Free, and was sufficient for Trends JSON in our test runs with paced requests.

The `GOOGLE_SERP` group is **not** the default. Apify documents it as HTTP-only access to `www.google.com` Search and Shopping. It cannot fetch `trends.google.com`. If you select it (or any group your plan cannot access), the Actor falls back to the automatic Apify Proxy, then to direct egress.

Residential proxies work and cost much more. Use them only if 429s persist after retries.

Locally, or on the platform without a proxy password, the Actor runs **direct**. From a clean VM that is enough for paced requests.

### Reliability notes

1. Cookie warmup on `trends.google.com` to collect an `NID`.
2. GET explore (POST explore returned HTTP 500 in live checks).
3. One widget call at a time, retried on 429 / 5xx with jittered backoff and proxy rotation.
4. Partial success is still success. The dataset always has a row you can filter on `status`.
5. Related topics are requested and often empty. That is a Google-side gap, not a timeout. Related queries still arrive.

**Live test results (Apify platform, Oct 31, 2026, automatic Apify Proxy):** 16 of 16 runs succeeded, including the default input, keyword comparison, interest by region, and related queries. Run times ranged from 2.3 s to 15.2 s. The default input finished in 6.4 s with 3 result rows.

### Rising queries and decoys

Google labels every scripted Trends session `USER_TYPE_SCRAPER` (you can see it in the explore response as `userConfig.userType`). The widget token is signed over that label, so it cannot be changed: an edited request gets HTTP 401. Other Actors report the same label on residential IPs and in a real headless Chrome.

For sessions with that label, Google mixes **decoy queries into the rising list** of every keyword. They are generic phrases unrelated to your keyword, like "pet care tips", "how to cook pasta", "walmart near me", or "cheap flights 2024". Top queries, timelines, and regions match what a browser shows. This is not a parsing bug: the decoys are in Google's raw `relatedsearches` response.

Every related-queries row now includes:

- `googleUserType`: the label Google put on the session.
- `dataQualityWarning`: a plain-language warning when the label is `USER_TYPE_SCRAPER`.
- `risingFilter`: the filter mode used.
- `rising`: the rising queries that passed the filter.
- `suspectedDecoys`: removed entries, each with `decoyReasons` (`knownDecoy`, `repeatedAcrossKeywords`, `unrelatedToKeyword`). Nothing is deleted.

`risingFilter` modes:

| Mode | What it does |
| --- | --- |
| `strict` (default) | Moves an entry if it is a known decoy, if it was rising for an unrelated keyword earlier in the same run, or if it shares no meaningful word with the keyword or its top queries. |
| `balanced` | Moves only known decoys and cross-keyword repeats. Unrelated entries stay in `rising` with `"unverified": true`. Good for celebrity and news keywords, where real rising terms often share no words with the keyword. |
| `off` | Google's raw rising list. |

An entry that contains your keyword is never treated as a known decoy, so `pasta` still gets "how to cook pasta". In `flat` mode, decoy rows are left out, which means they are not billed, and a note gives the count. Treat rising queries as directional. Top queries are the more reliable list.

Live example (coffee, US, past 12 months, Oct 31, 2026): Google returned 25 rising queries. `strict` kept 8 that mention coffee and moved 17, including "pet care tips", "learn programming", and "best laptops 2025".

### Comparison to other Google Trends Actors

This is not a teardown of anyone else's work. It is a checklist of what to look for:

| | This Actor | Browser-based scrapers | Lightweight keyword/trending Actors |
| --- | --- | --- | --- |
| How it fetches | Public JSON endpoints | Headless Chrome | Mixed |
| Typical failure mode | Empty related-topics list | Timeouts, aborts, 429s | Missing widgets |
| Compare 5 terms | Yes | Yes | Sometimes one keyword |
| Trending Now | Current RPC + RSS fallback | Page scrape | Often the main product |
| Default output | One row per data type | One nested row | Custom shapes |
| You pay | $0.02 + $0.0015/row | Events **and** browser compute | Similar PPE, usually higher |

If you already have a Make/Zapier/API task pointed at another Actor, start with `outputMode: "combined"` and the same `searchTerms` / `timeRange` / `geo`. Then switch to `perDataType` if you want cleaner billing.

### FAQ

**Is there an official Google Trends API?**
Google has announced a limited official API with access by application. This Actor reads the public Trends website endpoints that any logged-out browser already calls.

**Are the numbers search volumes?**
No. 100 is the peak *within the selected terms, geo, and time range*. Use Trending Now's `searchVolume` field for Google's trending-bucket estimate, not for SEO volume.

**Is scraping Google Trends legal?**
You get publicly visible data. You are responsible for how you use it. Review Google's Terms of Service and your local law before large jobs.

**Why did rising queries include unrelated things like "how to cook pasta"?**
Google adds them on purpose for automated sessions. See [Rising queries and decoys](#rising-queries-and-decoys). The default `risingFilter: "strict"` moves them to `suspectedDecoys`.

**Why are related topics empty?**
Google often returns `rankedList: []` for the RELATED_TOPICS widget to non-browser clients. The Actor still records an uncharged error row so you can see it. Related queries are populated.

**Will the daily default input stay green?**
Yes, that is a design constraint. `bitcoin` + `US` + past 12 months + three widgets is well under 5 minutes and returns non-empty rows.

**Can I run it locally?**

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements-dev.txt
## uses storage/key_value_stores/default/INPUT.json
python -m src
pytest
GOOGLE_TRENDS_LIVE_TEST=1 pytest tests/test_live.py
```

### More actors from this developer

- [PDF to Markdown: DOCX, PPTX, XLSX, OCR & RAG Chunks](https://apify.com/sunburst077/document-to-markdown-rag): PDF, DOCX, PPTX, XLSX and HTML to clean Markdown and RAG-ready chunks.
- [Google News Scraper: Full-Text Articles to Markdown](https://apify.com/sunburst077/google-news-to-markdown): Google News articles as Markdown and RAG chunks for any topic or company.
- [Greenhouse, Lever, Ashby & Workable Jobs API](https://apify.com/sunburst077/multi-ats-jobs-feed): one clean jobs feed from company job boards, with salaries when posted.
- [Website Screenshot & URL to PDF API (Bulk, Full Page)](https://apify.com/sunburst077/website-screenshot-pdf): full-page and mobile screenshots (PNG, JPEG, WebP) and PDFs of any URL.
- [Wayback Machine API: Snapshots & Archived Pages](https://apify.com/sunburst077/wayback-machine-snapshots): every archived capture of a URL or domain, the snapshot closest to a date, and archived pages as Markdown.

### Develop and publish

See [PUBLISHING.md](PUBLISHING.md) for Docker build and `apify push` steps. You do not need Apify credentials to run the unit tests or the live smoke against Google.

### Changelog

See [CHANGELOG.md](CHANGELOG.md).

# Changelog

This Actor's version history is a separate document: https://apify.com/sunburst077/google-trends-reliable/changelog.md

# Actor input Schema

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

Keywords or topics to analyze. Each item is one request. Turn on Compare comma-separated terms to put up to 5 keywords on one shared 0–100 chart. Required unless you pass startUrls, a public spreadsheetId, or enable Trending Now.

## `isMultiple` (type: `boolean`):

When enabled, commas inside one search-terms line split it into a comparison group of up to 5 keywords (same as adding terms on trends.google.com). Extra keywords are batched into further groups of 5.

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

Paste explore URLs from trends.google.com. Each URL's q, geo, date, cat, and gprop values override the form fields for that job.

## `spreadsheetId` (type: `string`):

Optional. Load terms from a public sheet (first column, row 1 treated as a header). Accepted for drop-in compatibility with other Trends actors.

## `timeRange` (type: `string`):

Predefined Google Trends period. Ignored when a custom range is set. Empty means the past 12 months.

## `customTimeRange` (type: `string`):

Overrides Time range. Format: YYYY-MM-DD YYYY-MM-DD, for example 2024-01-01 2024-12-31.

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

Country or region code: US, GB, DE, US-CA, or empty for worldwide. Maps to interestBy / interestBySubregion / interestByCity depending on the resolution.

## `category` (type: `string`):

Google Trends category ID. Empty or 0 means all categories.

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

Which Google surface to measure, same as the Web / News / Images / YouTube / Shopping switch on Trends.

## `dataTypes` (type: `array`):

Which widgets to fetch. Leave the default for a complete explore pull. Trending Now does not need search terms.

## `resolution` (type: `string`):

Granularity for interest by region. Auto uses COUNTRY worldwide and REGION inside a country.

## `includeLowVolumeGeos` (type: `boolean`):

Ask Google to include low-search-volume geos in interest-by-region results.

## `outputMode` (type: `string`):

perDataType (default): one dataset row per term per widget. combined: one row per term in the familiar nested shape. flat: CSV-friendly one row per time point, region, or related item (billed per row).

## `risingFilter` (type: `string`):

Google tags automated sessions USER_TYPE_SCRAPER and mixes unrelated decoy queries (for example 'pet care tips' or 'how to cook pasta') into the rising list of every keyword. strict (default): move known decoys, cross-keyword repeats, and rising queries that share no word with the keyword or its top queries into suspectedDecoys. balanced: move only known decoys and repeats; keep unrelated entries but mark them unverified: true. off: return Google's raw rising list. Nothing is deleted in perDataType or combined mode; flat mode omits decoy rows, so they are not billed.

## `viewedFrom` (type: `string`):

Language for Google's formatted labels, for example en-US or de. Also accepted as viewedFrom for drop-in compatibility.

## `fetchTrendingNow` (type: `boolean`):

Pull the current Trending Now list for a country. You can run this with no search terms. Uses the public batchexecute RPC, with the RSS feed as fallback.

## `trendingSearchesCountry` (type: `string`):

ISO country code for Trending Now. Defaults to Geo, or US.

## `trendingSearchesTimeframe` (type: `string`):

4, 24, 48, or 168 (7 days).

## `trendingSearchesMaxItems` (type: `integer`):

Cap Trending Now rows. 0 means all items Google returned.

## `trendingSearchesCategories` (type: `array`):

Optional numeric category IDs to keep. Filtering is applied client-side; Google's RPC does not filter server-side.

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

Stop after this many search-term groups (URLs included). 0 means no limit.

## `maxConcurrency` (type: `integer`):

How many keyword groups to process at once. Keep at 1 for the highest success rate and lowest 429 risk.

## `maxRequestRetries` (type: `integer`):

Retries per HTTP call on 429/5xx, with exponential backoff, jitter, cookie re-warmup, and proxy rotation.

## `requestDelayMs` (type: `integer`):

Minimum pacing between Google Trends calls. 350 ms is a good default.

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

Apify Proxy. Default is datacenter (SHADER). The GOOGLE_SERP group only serves www.google.com Search/Shopping and cannot reach trends.google.com — if you select it, the Actor falls back to datacenter, then to direct egress.

## `skipDebugScreen` (type: `boolean`):

Accepted for drop-in compatibility. This Actor never opens a browser, so there are no screenshots.

## `pageLoadTimeoutSecs` (type: `integer`):

Accepted for drop-in compatibility. This Actor loads no pages.

## `mode` (type: `string`):

Accepted for compatibility with keyword/trending mode Actors. trending implies fetchTrendingNow.

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin"
  ],
  "isMultiple": false,
  "timeRange": "today 12-m",
  "geo": "US",
  "category": "",
  "property": "web",
  "dataTypes": [
    "TIMESERIES",
    "GEO",
    "RELATED_QUERIES"
  ],
  "resolution": "",
  "includeLowVolumeGeos": false,
  "outputMode": "perDataType",
  "risingFilter": "strict",
  "viewedFrom": "en-US",
  "fetchTrendingNow": false,
  "trendingSearchesCountry": "US",
  "trendingSearchesTimeframe": "24",
  "trendingSearchesMaxItems": 50,
  "maxItems": 0,
  "maxConcurrency": 1,
  "maxRequestRetries": 5,
  "requestDelayMs": 350,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "skipDebugScreen": true,
  "pageLoadTimeoutSecs": 60,
  "mode": ""
}
```

# Actor output Schema

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

Every successful row and uncharged error row from the run.

## `overview` (type: `string`):

No description

# 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": [
        "bitcoin"
    ],
    "timeRange": "today 12-m",
    "geo": "US",
    "property": "web",
    "dataTypes": [
        "TIMESERIES",
        "GEO",
        "RELATED_QUERIES"
    ],
    "outputMode": "perDataType",
    "viewedFrom": "en-US",
    "trendingSearchesCountry": "US",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sunburst077/google-trends-reliable").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": ["bitcoin"],
    "timeRange": "today 12-m",
    "geo": "US",
    "property": "web",
    "dataTypes": [
        "TIMESERIES",
        "GEO",
        "RELATED_QUERIES",
    ],
    "outputMode": "perDataType",
    "viewedFrom": "en-US",
    "trendingSearchesCountry": "US",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("sunburst077/google-trends-reliable").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": [
    "bitcoin"
  ],
  "timeRange": "today 12-m",
  "geo": "US",
  "property": "web",
  "dataTypes": [
    "TIMESERIES",
    "GEO",
    "RELATED_QUERIES"
  ],
  "outputMode": "perDataType",
  "viewedFrom": "en-US",
  "trendingSearchesCountry": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call sunburst077/google-trends-reliable --silent --output-dataset

```

## MCP server setup

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

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/HgG5y4ScS4TAxdnfA/builds/9WAZz5JtT2R52M8gb/openapi.json