# Google Trends Scraper — bulk, 5+ terms on one scale (`pampadata/google-trends-scraper`) Actor

Interest over time, by region, related queries and topics for thousands of terms, no browser. Any number of terms on one scale, optional daily data up to 5 years, a status per term; terms without data are not charged.

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

## Pricing

from $3.00 / 1,000 term with data

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 data for **many search terms at once**: interest over time, interest by region (countries, states, US metro areas, cities) and related queries. It reads Google's own data endpoints directly, **without a browser**, so it is fast and cheap to run. Terms Google has no data for, and terms that could not be read, are **delivered free with the reason**. You can also put **any number of terms on one 0-100 scale** (Google's chart stops at 5), and get **daily data for ranges up to 5 years** (Google switches to weekly after 270 days).

*Versión en español más abajo.*

### Quick facts

- **What it does:** Google Trends for many terms at once, without a browser: interest over time, interest by region, related queries (and topics); any number of terms on one 0-100 scale; daily data for ranges up to 5 years.
- **Use it for:** keyword and market research in bulk; comparing many terms on one scale; long daily series; regional interest (countries, regions, US metros, cities).
- **Not for:** absolute search volumes (Google's numbers are relative, 0-100); Trending Now; hourly stitching or daily data past 5 years (not in this version).
- **Input:** `searchTerms` (required; up to 5,000 term × location pairs per run); `geos` (Trends codes; empty = worldwide); `timeRange` (default `today 12-m`, or `YYYY-MM-DD YYYY-MM-DD`); optional `compareTogether` + `anchorTerm`, `dailyForLongRanges`, section switches, `regionResolution`, `category`, `searchType`.
- **Output:** one dataset row per term and location (rows without data come free, with `status` and the reason), and one `SUMMARY` record. Every field with its type is under *Output reference* below.
- **Charged events (pay per event):** `keyword` USD 0.003 per term with data (USD 3.00 per 1,000); `keyword-daily` USD 0.01 per term when `dailyForLongRanges` is on and the range is longer than 270 days (USD 10.00 per 1,000); a term is charged when its interest over time came back (or any section, if the timeline is off); plus Apify's standard start event `apify-actor-start`.
- **Never charged:** terms without data in Google (`noData`), terms that could not be read (`failed`), the SUMMARY record; there is no proxy or compute charge on top.
- **Limits:** up to 5,000 term × location pairs per run; stops at your maximum charge per run (SUMMARY `stoppedBy`); Google samples searches and adds small random noise, so another day can differ a little.
- **Run it from:** Apify Console, the Apify API or an AI agent through the Apify MCP server (Actor `pampadata/google-trends-scraper`), with schedules and integrations.

#### Minimal input

A small input that works, taken from this Actor's own tests; every other field is optional:

```json
{
  "searchTerms": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "geos": [
    "US"
  ]
}
```

### Why this one

- **Built for volume.** No browser: 175 terms (timeline, regions and related queries for each) in 5 minutes in one test, every one complete. When Google slows the run down, the Actor moves to fresh residential IPs by itself. You pay nothing extra for that: there is no proxy or compute charge on top of the price.
- **You pay only for data.** A term is charged when its interest over time came back (or, if you did not ask for the timeline, when any section did). A term with no data in Google, or one that could not be read after several tries, is still delivered so you know about it, with `status` `noData` or `failed` and the reason. It is **not charged**.
- **A status for every section.** Each row says, for the timeline, regions, related queries and related topics, whether it is `ok`, `empty` (Google answered with nothing), `failed` or `notOffered`. Empty lists never pass for data. The SUMMARY record lists every term that was not complete, with the reason.
- **More than 5 terms on one scale.** Turn on `compareTogether`. Up to 5 terms come from one Google chart. With more, every batch of 5 includes an **anchor term**, and its values tie the batches to one scale. Test on 2026-10-09 with 12 foods: the chained values of empanada and falafel were within 0.6 % of what Google shows when those terms are charted together. In Google's own 5-term chart with pizza, falafel is all 0. Values on the shared scale keep decimals.
- **Daily data for long ranges.** Turn on `dailyForLongRanges` to get one point per day for up to 5 years. Google only gives daily points for 270 days or less. The Actor reads overlapping daily windows and fits them to Google's own weekly series for the whole range. Every row includes the check (`stitchCheck`): the average gap to Google's weekly values on the 0-100 scale. In tests it was 1.0 point over 3 years and 2.6 over 5 years.
- **Any location code.** It takes any code Google Trends takes: countries (US, GB, KR…), regions (US-CA, GB-ENG, BR-SP), US metros (US-NY-501), or worldwide. There is no fixed list with broken entries.

### Input

| Field | What it does |
|---|---|
| `searchTerms` | Words or phrases (up to 5,000 term × location pairs per run). Google's syntax works ("a + b"; topic ids like /m/0vpj4_b). |
| `geos` | Location codes; empty = worldwide. Each term is read for each location. |
| `timeRange` | `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`, or your dates: `2024-01-01 2025-06-30`. |
| `compareTogether`, `anchorTerm` | All terms on one scale (up to 200 terms); the anchor ties batches of 5 (default: the first term). Best anchor: a term of middle popularity among yours. |
| `dailyForLongRanges` | Daily points for ranges up to 5 years (charged as `keyword-daily`). |
| `includeTimeline`, `includeByRegion`, `includeRelatedQueries`, `includeRelatedTopics` | Sections to read. Related topics are off by default: Google currently offers them empty to sessions that are not signed in. |
| `regionResolution` | `auto`, `COUNTRY` (worldwide only), `REGION`, `DMA` (US metros), `CITY`. `includeLowVolumeRegions` adds places with too little data. |
| `category`, `searchType` | Google Trends category number (0 = all); web, images, news, YouTube or Google Shopping search. |

### Output (one row per term and location)

`term`, `geo`, `timeRange`, `category`, `searchType`, `status`, `sections`; `resolution`; `interestOverTime` (`date` (UTC), `value`, `isPartial` on the last point while that period is still running), `averageInterest`, `peakDate`; `interestByRegion` (`geoCode`, `geoName`, `value`; `lat`/`lng` for cities); `relatedQueries` and `relatedTopics` (`top` and `rising`, with `breakout: true` when Google shows "Breakout"). When comparing, the row also has `comparedWith`, `sharedScale`, `anchorTerm` and `lowPrecision`. `lowPrecision` means Google's whole numbers carry a rounding of several %. With daily data, the row has `stitchCheck`.

```json
{
  "term": "bitcoin", "geo": "US", "timeRange": "today 12-m", "status": "ok",
  "sections": {"timeline": "ok", "byRegion": "ok", "relatedQueries": "ok"},
  "resolution": "WEEK", "averageInterest": 35.56, "peakDate": "2026-02-01",
  "interestOverTime": [{"date": "2025-10-05", "value": 39}, {"date": "2026-10-04", "value": 17, "isPartial": true}],
  "interestByRegion": [{"geoCode": "US-WY", "geoName": "Wyoming", "value": 100}],
  "relatedQueries": {"top": [{"query": "bitcoin price", "value": 100, "formattedValue": "100"}], "rising": []}
}
```

### Price

You pay per term with data: **USD 3.00 per 1,000 terms** (USD 0.003 each; one term in one location is one row), or **USD 10.00 per 1,000 terms with daily data for long ranges** (`dailyForLongRanges` on and a range longer than 270 days; USD 0.01 each). A term is charged when its interest over time comes back (or, if you turned the timeline off, when any section comes back). No charge per run beyond Apify's standard start event, and nothing for the SUMMARY record, terms without data in Google, or terms that could not be read. Set a maximum charge per run in Apify and the Actor stops there.

### How long it takes

3 terms in about 5 seconds; 175 terms in about 5 minutes. Daily data for 5 years: about 6 seconds per term.

### Good to know

- **Google's numbers are relative**, 0-100 within each chart: 100 is the highest point of that search, place and time. Rows read separately are each on their own scale. Use `compareTogether` to compare terms.
- **Region values are always on the term's own scale**, also when comparing. Google draws each term's map on its own.
- **Related queries are what Google limits hardest.** In a 60-term test, 3 terms came back without them after 8 tries. Those rows are `partial`, and the SUMMARY says which section is missing. They are charged, because their timeline came back.
- **The last point can be partial**: the week or day is still running. It is marked `isPartial` and left out of `averageInterest`.
- Times are UTC.

### Reliability

What was measured before publishing (2026-10-09), and what was not:

- **Runs:** every test run finished. 175 of 175 terms came back with their timeline, regions and related queries; in a later 60-term run, 3 terms came back without related queries after 8 tries (`partial`, timeline and regions present). A term that cannot be read is delivered with `status: failed` and the reason, and is **not charged**.
- **Blocking:** Google refuses one IP after about 25 terms in a row. The Actor then moves to fresh residential IPs by itself: 200 of 200 terms came back that way in a test. If Google also refuses those, the terms come back `failed` (free), not as a broken run.
- **Same question, same numbers:** asked twice the same day, and with shifted windows, Google gave identical weekly values (0 difference in 261 weeks). This was not measured across days. Google says Trends works on a sample of searches and adds "small and random fluctuations" to protect privacy, most visible for low-interest terms ([Google Trends Help](https://support.google.com/trends/answer/4365533)), so a run on another day can differ a little.
- **Whole numbers:** Google gives 0-100 as whole numbers. For a term that peaks under 10 that rounding is several %; such rows are marked `lowPrecision`.
- **Not measured yet:** the success rate on the Store over weeks of real use (published 2026-10-09). For comparison, the most used Google Trends Actor fails or times out in about 1 run of 4 (its public run statistics, read 2026-10-09).

### Not affiliated

Not affiliated with, endorsed by or sponsored by Google. "Google Trends" names the public data source.

### Output reference

#### Dataset: one row per term

| Field | Type | What it is |
|---|---|---|
| `term` | string | The search term. |
| `geo` | string | Location code, or "worldwide". |
| `timeRange` | string | Time range sent to Google. |
| `category` | integer | Google Trends category (0 = all). |
| `searchType` | string | web, images, news, youtube or shopping. |
| `status` | string | ok, partial (some section failed), noData or failed (noData/failed rows are not charged). |
| `sections` | object | Status per section: timeline, byRegion, relatedQueries, relatedTopics = ok, empty, failed or notOffered. |
| `resolution` | string or null | Point spacing (e.g. WEEK, DAY; "(stitched from daily windows)" with dailyForLongRanges). |
| `interestOverTime` | array of object | Points: date (UTC), value (0-100), isPartial (true on a still-running last point). |
| `averageInterest` | number or null | Average of the points (partial point left out). |
| `peakDate` | string or null | Date of the highest point. |
| `interestByRegion` | array of object | geoCode, geoName, value (0-100 on the term's own scale); lat/lng for cities. |
| `regionResolution` | string | Region level used (auto, country, region, dma, city). |
| `relatedQueries` | object | top and rising lists: query, value, formattedValue; on rising, breakout true when Google shows "Breakout" (over 5,000 %). |
| `relatedTopics` | object | Only when asked: top and rising topics (topic, topicType, topicId, value, formattedValue); Google often offers none to signed-out sessions. |
| `comparedWith` | array of string | Only with compareTogether: the terms on the same scale. |
| `sharedScale` | boolean | Only with compareTogether: true when the values are on the shared scale. |
| `anchorTerm` | string | Only with compareTogether and an anchor: the anchor term. |
| `lowPrecision` | boolean | Only when comparing: true when Google's whole numbers carry a rounding of several %. |
| `stitchCheck` | object | Only with dailyForLongRanges: the check against Google's weekly series (average gap on the 0-100 scale). |
| `note` | string | Explanation when a row has no usable data. |
| `error` | string | Only on failed rows: why the term could not be read. |
| `errors` | array of string | Section errors on partial rows. |

#### SUMMARY record (run's key-value store, never charged)

| Field | Type | What it is |
|---|---|---|
| `terms` | integer | Number of terms asked. |
| `locations` | array of string | Locations asked ("worldwide" when empty). |
| `timeRange` | string | Time range used. |
| `dailyStitched`, `compareTogether` | boolean | Modes used. |
| `anchorTerm` | string or null | Anchor used when comparing. |
| `rows` | object | Counts: ok, partial, noData, failed, notRun, deliveredWithData, charged. |
| `notDeliveredOrIncomplete` | array of object | Every term that was not complete: term, geo, status, why. |
| `warnings` | array of string | Warnings. |
| `requests` | object | Request counters of the run (requests, retries, refusals or blocks, failures; whether the run moved to residential IPs). |
| `finished` | boolean | true when the run ended normally. |
| `stoppedBy` | string or null | "your maximum charge per run was reached" when it stopped there. |

### More Actors by this developer

- [Google Ads Transparency Scraper](https://apify.com/pampadata/google-ads-transparency-scraper)
- [SEEK Jobs Scraper (Seek, JobStreet, Jobsdb)](https://apify.com/pampadata/seek-jobs-scraper)
- [Career Site Jobs Scraper (Workday, Greenhouse, Lever and 6 more)](https://apify.com/pampadata/career-site-jobs-scraper)
- [AliExpress Search Scraper](https://apify.com/pampadata/aliexpress-search-scraper)
- [Google News Scraper](https://apify.com/pampadata/google-news-scraper)
- [Sports Odds vs Prediction Markets (Kalshi, Polymarket)](https://apify.com/pampadata/sports-odds-vs-prediction-markets)
- [YouTube Transcripts in Bulk (whole channels, playlists)](https://apify.com/pampadata/youtube-transcripts-bulk)

***

### Versión en español

Datos de Google Trends para **muchos términos a la vez**: interés en el tiempo, interés por región (países, estados, áreas metropolitanas de EE. UU., ciudades) y búsquedas relacionadas. Lee directamente los datos de Google, **sin navegador**, así que corre rápido y cuesta poco. Los términos sin datos en Google, y los que no se pudieron leer, **se entregan gratis con el motivo**. También podés poner **cualquier cantidad de términos en una sola escala de 0 a 100** (el gráfico de Google llega a 5) y obtener **datos diarios de hasta 5 años** (Google pasa a semanales después de 270 días).

#### De un vistazo

- **Qué hace:** Google Trends para muchos términos a la vez, sin navegador: interés en el tiempo, por región, búsquedas relacionadas; cualquier cantidad de términos en una escala 0-100; datos diarios de hasta 5 años.
- **Sirve para:** investigación de palabras clave y mercados en volumen; comparar muchos términos en una escala; series diarias largas; interés por región.
- **No sirve para:** volúmenes absolutos de búsqueda (los números de Google son relativos); Trending Now; datos diarios de más de 5 años (no están en esta versión).
- **Entrada:** `searchTerms` (obligatorio; hasta 5.000 pares término × lugar); `geos`; `timeRange` (`today 12-m` por defecto); opcionales `compareTogether` + `anchorTerm`, `dailyForLongRanges`, secciones, `regionResolution`, `category`, `searchType`. Ejemplo mínimo en JSON: sección *Minimal input* de la parte en inglés.
- **Salida:** una fila por término y lugar (las filas sin datos van gratis, con `status` y el motivo) y un registro `SUMMARY`.
- **Eventos que se cobran:** `keyword` USD 0,003 por término con datos (USD 3,00 cada 1.000); `keyword-daily` USD 0,01 con `dailyForLongRanges` y un rango de más de 270 días (USD 10,00 cada 1.000); más `apify-actor-start`.
- **Nunca se cobra:** términos sin datos (`noData`), términos ilegibles (`failed`), el SUMMARY; no hay cargo extra de proxy ni de cómputo.
- **Límites:** hasta 5.000 pares por corrida; se detiene en tu costo máximo por corrida (`stoppedBy`).

#### Por qué este

- **Hecho para volumen.** Sin navegador: 175 términos en 5 minutos en una prueba, cada uno con su curva, sus regiones y sus búsquedas relacionadas, todos completos. Cuando Google frena la corrida, el Actor pasa solo a IPs residenciales nuevas, sin costo extra de proxy ni de cómputo.
- **Pagás solo lo que tiene datos.** Un término se cobra cuando vuelve su curva de interés (o, si no la pediste, cuando vuelve alguna sección). Un término sin datos en Google, o que no se pudo leer después de varios intentos, se entrega igual para que lo sepas, con `status` `noData` o `failed` y el motivo. **No se cobra.**
- **Un estado por sección.** Cada fila dice, para la curva, las regiones, las búsquedas relacionadas y los temas relacionados, si salió `ok`, `empty` (Google respondió sin nada), `failed` o `notOffered`. Una lista vacía nunca pasa por dato. El registro SUMMARY lista cada término que no salió completo y por qué.
- **Más de 5 términos en una escala.** Hasta 5 salen de un solo gráfico de Google. Con más, cada tanda de 5 lleva un **término ancla** que une las tandas. Prueba del 2026-10-09 con 12 comidas: los valores encadenados de empanada y falafel quedaron a menos de 0,6 % de lo que da Google con esos términos en un mismo gráfico. En el gráfico de 5 de Google con pizza, falafel sale todo en 0.
- **Datos diarios de rangos largos**, hasta 5 años. Cada fila trae el control contra la serie semanal de Google: 1,0 punto en 3 años y 2,6 en 5 años, en las pruebas.
- **Cualquier código de ubicación** que acepte Google Trends: países, regiones, metros de EE. UU. o mundial.

#### Precio

Pagás por término con datos: **USD 3,00 cada 1.000 términos** (USD 0,003 cada uno; un término en una ubicación es una fila), o **USD 10,00 cada 1.000 términos con datos diarios de rangos largos** (`dailyForLongRanges` activado y un rango de más de 270 días; USD 0,01 cada uno). Un término se cobra cuando vuelve su curva de interés (o, si apagaste la curva, cuando vuelve alguna sección). No hay cargo por corrida aparte del evento de inicio estándar de Apify, y no se cobran el registro SUMMARY, los términos sin datos en Google ni los que no se pudieron leer. Poné un cargo máximo por corrida en Apify y el Actor se detiene ahí.

#### Confiabilidad

Lo que se midió antes de publicar (2026-10-09), y lo que no:

- **Corridas:** todas las corridas de prueba terminaron. 175 de 175 términos volvieron con curva, regiones y búsquedas relacionadas; en otra corrida de 60 términos, 3 volvieron sin búsquedas relacionadas después de 8 intentos (`partial`, con curva y regiones). Un término que no se puede leer se entrega con `status: failed` y el motivo, y **no se cobra**.
- **Bloqueos:** Google rechaza una IP después de unos 25 términos seguidos. El Actor pasa solo a IPs residenciales nuevas: así volvieron 200 de 200 términos en una prueba. Si Google rechaza también esas, los términos vuelven `failed` (gratis), no como una corrida rota.
- **Misma pregunta, mismos números:** pedidos dos veces el mismo día, y con ventanas corridas, Google dio valores semanales idénticos (0 diferencias en 261 semanas). No se midió entre días distintos. Google dice que Trends trabaja con una muestra de las búsquedas y agrega "pequeñas fluctuaciones al azar" para proteger la privacidad, más visibles en términos de poco interés ([Ayuda de Google Trends](https://support.google.com/trends/answer/4365533)), así que una corrida de otro día puede diferir un poco.
- **Números enteros:** Google da 0-100 en enteros. En un término cuyo pico queda por debajo de 10, ese redondeo es de varios %; esas filas llevan `lowPrecision`.
- **Todavía sin medir:** la tasa de éxito en la tienda con semanas de uso real (publicado el 2026-10-09). Como referencia, el Actor de Google Trends más usado falla o se agota en más o menos 1 de cada 4 corridas (sus estadísticas públicas, leídas el 2026-10-09).

#### No afiliado

Sin relación con Google. "Google Trends" nombra la fuente pública de los datos.

# Actor input Schema

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

Words or phrases, one per line (up to 5,000 term × location pairs per run). Google's own syntax works: "a + b" (either), a Topic id like /m/0vpj4_b.

## `geos` (type: `array`):

Google Trends codes: a country (US, GB, AR, KR), a region (US-CA, GB-ENG, BR-SP), a US metro (US-NY-501). Leave empty for worldwide. Each term is read for each location.

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

One of Google's ranges (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) or your own dates: 2024-01-01 2025-06-30.

## `compareTogether` (type: `boolean`):

Off: each term on its own 0-100 scale (what most people want for many unrelated terms). On: all terms on one scale, like Google's comparison chart, also with more than 5 terms (an anchor term ties the batches of 5 together; up to 200 terms).

## `anchorTerm` (type: `string`):

Used only with 'Compare all terms on one scale' and more than 5 terms. Best: a term of middle popularity among yours. Default: the first term.

## `dailyForLongRanges` (type: `boolean`):

Google gives daily points only up to 270 days; longer ranges come weekly. On: daily points for the whole range, stitched from daily windows onto Google's own weekly scale, with a check against Google's weekly series per term. Charged as 'keyword-daily'.

## `includeTimeline` (type: `boolean`):

The 0-100 interest curve for the time range (with the last, still incomplete point marked isPartial).

## `includeByRegion` (type: `boolean`):

Interest by country, region, metro or city (see Region detail), each on the term's own 0-100 scale.

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

The searches people also made: top (most frequent) and rising (fastest growth; Breakout = over 5,000 %).

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

Google often does not offer related topics to sessions that are not signed in; when it does not, the row says 'notOffered' for this section and nothing extra is charged.

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

auto = Google's default for the location (countries for worldwide, states/regions for a country). DMA = US metro areas (US locations only). CITY = cities. COUNTRY = worldwide only.

## `includeLowVolumeRegions` (type: `boolean`):

Also list regions where Google has too little data (value empty).

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

Google Trends category number (0 = all categories; e.g. 7 Finance, 71 Food & Drink, 18 Shopping).

## `searchType` (type: `string`):

Which Google search the interest comes from.

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

Leave empty: the Actor uses its own IP and switches to residential IPs by itself when Google refuses it (included in the price). Set a proxy only to force your own.

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "geos": [
    "US"
  ],
  "timeRange": "today 12-m",
  "compareTogether": false,
  "dailyForLongRanges": false,
  "includeTimeline": true,
  "includeByRegion": true,
  "includeRelatedQueries": true,
  "includeRelatedTopics": false,
  "regionResolution": "auto",
  "includeLowVolumeRegions": false,
  "category": 0,
  "searchType": "web"
}
```

# Actor output Schema

## `terms` (type: `string`):

Dataset items: one row per term and location (term, geo, timeRange, status, sections, interestOverTime, averageInterest, peakDate, interestByRegion, relatedQueries; comparison and stitching fields when used). Rows with data are charged (event `keyword`, or `keyword-daily`); noData and failed rows are delivered free with the reason.

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

Key-value record SUMMARY: counts per status, every term not delivered or incomplete with the reason, settings, request counters, stoppedBy. Not charged.

# 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",
        "ethereum",
        "solana"
    ],
    "geos": [
        "US"
    ],
    "timeRange": "today 12-m"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pampadata/google-trends-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 = {
    "searchTerms": [
        "bitcoin",
        "ethereum",
        "solana",
    ],
    "geos": ["US"],
    "timeRange": "today 12-m",
}

# Run the Actor and wait for it to finish
run = client.actor("pampadata/google-trends-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 '{
  "searchTerms": [
    "bitcoin",
    "ethereum",
    "solana"
  ],
  "geos": [
    "US"
  ],
  "timeRange": "today 12-m"
}' |
apify call pampadata/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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