# Google Trends Explore (`truefetch/google-trends-explore`) Actor

Google Trends Explore API: one call returns up to five compared terms as 15 typed fields each — interest timeline with its resolved window and resolution, average interest, interest by geography, and top and rising related queries with links.

- **URL**: https://apify.com/truefetch/google-trends-explore.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** SEO tools, Developer tools, Integrations
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 4.00 out of 5 stars

## Pricing

from $10.13 / 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.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**Google Trends Explore is a Google Trends Explore API that turns a classic Explore comparison into up to five typed, 18-field Dataset rows with timelines, geographic interest, and top and rising related queries.**

- **One Actor call, five terms, one normalized scale** — all terms share the same comparison, so their 0-100 values are directly comparable with each other.
- **The response states its own shape**: the absolute window Google resolved the request to, and the bucket size it chose, in every record.
- **Geography switches the breakdown**: Worldwide returns country-level rows, a single country returns that country's subregions.
- **Every related query carries its own Explore link**, so a term worth investigating is one request away from its own comparison.

[**Run a one-result test**](https://console.apify.com/actors/truefetch~google-trends-explore) · [**View API**](https://apify.com/truefetch/google-trends-explore/api)

The smallest useful run uses one term and bills one Result event plus one Actor Start event — **$0.02350** on the FREE tier. A one-term row leaves `interest_average` null; add a second term when the average comparison matters.

### What does Google Trends Explore do?

Google Trends Explore accepts terms, geography, window, category, and search surface, then returns the source comparison as typed records. Each distinct source keyword can become one stable 18-field Dataset row; source-empty terms are skipped, while a row with one measured panel can keep another unavailable panel as null.

It does not return search volumes: Google's [Trends data documentation](https://support.google.com/trends/answer/4365533) defines the 0-100 values as relative interest, not counts. Separate requests are normalized independently. This Actor is not Google's access-gated Trends API and has no affiliation with Google; it reads the public classic Explore experience.

### How do I run Google Trends Explore?

Fill the five inputs, start the run, and read one row per term from the default Dataset:

1. Enter one to five terms in `keywords`.
2. Choose `location`, `time_range`, `category` and `search_type`.
3. Start the run and read the default Dataset.

This two-term scenario exercises the shared comparison scale; delete either term for the smallest one-result test:

```json
{
  "keywords": ["bitcoin", "ethereum"],
  "location": "Worldwide",
  "time_range": "Past 90 days",
  "category": "Finance",
  "search_type": "News search"
}
```

Billing follows published rows: five distinct source terms can produce five rows and five Result events. A source-empty term is skipped, and two requested values that Google normalizes to the same source keyword are emitted once rather than billed twice.

### What data does Google Trends Explore return?

Each published record has 18 fields.

| Group | Fields | Notes |
| --- | --- | --- |
| Term and scope | `keyword`, `location`, `category`, `search_type`, `platform` | Read back from what Google resolved the request to, not echoed from the input. |
| Resolved scope | `date_start`, `date_end`, `resolution`, `geo_resolution`, `rising_start`, `rising_end` | Timeline grain, geographic grain, and the previous window used for rising-query growth. |
| Measurements | `interest_average`, `timeline`, `regions`, `queries_top`, `queries_rising` | `interest_average` is Google's own mean and is supplied only for a comparison of two or more terms. |
| Provenance | `processor`, `processed_at` | Which Actor produced the record, and when. |

Illustrative abbreviated record from the scenario above:

```json
{
  "keyword": "bitcoin",
  "location": "Worldwide",
  "category": "Finance",
  "search_type": "News search",
  "date_start": "2026-05-09",
  "date_end": "2026-08-07",
  "resolution": "DAY",
  "geo_resolution": "COUNTRY",
  "rising_start": "2026-02-08",
  "rising_end": "2026-05-08",
  "interest_average": 70,
  "timeline": [{ "time": "2026-07-01T00:00:00+00:00", "value": 64 }],
  "regions": [{ "name": "Singapore", "code": "SG", "value": 56 }],
  "queries_top": [{ "query": "bitcoin price", "value": 100, "url": "https://trends.google.com/trends/explore?q=bitcoin+price&date=today+3-m" }],
  "queries_rising": [{ "query": "bitcoin etf news", "value": 13500, "url": "https://trends.google.com/trends/explore?q=bitcoin+etf+news&date=today+3-m", "is_breakout": true }]
}
```

Values Google does not supply stay empty rather than being filled in: `interest_average` is null on a single-term run, and an unavailable panel remains null with the incomplete row counted in the run summary. A source no-data timeline bucket keeps its timestamp with `value: null`; a measured value below one keeps `value: 0` and `value_text: "<1"`.

In `queries_rising`, `value` is percentage growth — 13500 means +13,500% — and `is_breakout` marks the terms Google labels "Breakout" instead of printing a number. On multi-year windows a `timeline` entry may carry a `note` recording a change Google made to how it measured from that point on; the series is not directly comparable across such a point.

### What inputs can I configure?

All five inputs are required.

| Input | Type | Required | Effect |
| --- | --- | --- | --- |
| `keywords` | array, 1-5 | Yes | The terms to compare. A sixth is refused at the source. |
| `location` | select, 236 options | Yes | `Worldwide` or one listed country or territory. Also decides what `regions` contains. |
| `time_range` | select, 9 options | Yes | Past hour through 2004-present. Determines `resolution`. |
| `category` | select, 26 options | Yes | Applies to the whole request, including regions and related queries. |
| `search_type` | select, 5 options | Yes | Web, Image, News, Shopping or YouTube search. |

### What platforms and markets does Google Trends Explore cover?

One source: Google Trends, read through its public Explore experience.

- **Markets** — 236 schema options including Worldwide. Worldwide returns country-level rows in `regions`; a selected country returns its own subregions, so geography selects the breakdown as well as the measurement.
- **Surfaces** — Web, Image, News, Shopping and YouTube search. Each is an independent index; the same term can rank very differently between them and the figures do not translate.
- **Windows** — nine, from the past hour to the full 2004-present archive. The window fixes the granularity: a 12-month request returns weekly buckets, a 7-day request hourly ones, the full archive monthly ones.
- **Categories** — 26, applied to the entire request.

Coverage is source-dependent: low-volume terms can return no data, especially in smaller markets. Broaden the term, geography, or window when a narrow combination is empty.

### Why use Google Trends Explore?

Because the comparison arrives normalized and self-describing: up to five terms on one 0-100 scale, in fixed 18-field records that state their window, timeline grain, geographic grain, and rising-query baseline.

| Capability | What it gives a data team |
| --- | --- |
| Five terms normalized in one comparison | A relative ranking, instead of stitching together separately scaled runs that cannot be compared. |
| Resolved window and `resolution` in the record | The series is self-describing, so downstream code does not have to infer bucket size from point count. |
| Geography-aware `regions` | Country-level or subregion-level breakdown from the same field, chosen by the input rather than by parsing a different panel. |
| Related queries with Explore links | Discovery and the next request in one step. |
| Fixed 18-field record | Parsing remains stable when a source panel is unavailable; the affected field stays null. |

The trade-off is inherent to the source: because each request is normalized on its own, this Actor cannot give you a series that merges across requests. If your work depends on that, Google's own Trends API is the right tool and this one is not.

### Who is Google Trends Explore for?

Developers and data teams use it when Explore must feed a pipeline rather than remain a browser tab. Examples include scheduled term-set tracking, market comparisons across countries or surfaces, and typed answers to "which term is moving?"

Store `interest_average` for a fixed comparison set, compare one term across Web and Shopping, or use `queries_rising` as emerging phrasing to review.

It is the wrong tool if you need absolute search volumes, cross-request comparable scaling, more than five terms in one comparison, or keyword difficulty and cost-per-click data. Those are different products, and this Actor does not approximate them.

### How can I use Google Trends Explore through the API or MCP?

The Actor ID is `ubXiK9s9p31KTeQrg` — also addressable by name as `truefetch/google-trends-explore`; both forms work in the API, the SDKs, and MCP.

```bash
curl -X POST "https://api.apify.com/v2/acts/truefetch~google-trends-explore/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["bitcoin","ethereum"],"location":"Worldwide","time_range":"Past 90 days","category":"Finance","search_type":"News search"}'
```

Through MCP, expose it with the Apify MCP server and call it by Actor ID:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "truefetch/google-trends-explore"],
      "env": { "APIFY_TOKEN": "YOUR_TOKEN" }
    }
  }
}
```

Generated SDK snippets and the OpenAPI definition are on the [API page](https://apify.com/truefetch/google-trends-explore/api). For long or scheduled workloads, start the run asynchronously, keep the run ID, and page the resulting Dataset.

### How much does Google Trends Explore cost?

One published term row costs $0.01350 on the FREE tier, plus a $0.01000 Actor Start per run — the smallest useful one-row test is $0.02350.

| Event | Billing unit | FREE | BRONZE | SILVER | GOLD / PLATINUM / DIAMOND |
| --- | --- | ---: | ---: | ---: | ---: |
| Result | One compared term | $0.01350 | $0.01215 | $0.01080 | $0.01013 |
| Actor Start | One per GB of memory, minimum one | $0.01000 | $0.01000 | $0.01000 | $0.01000 |

A one-row run bills one Actor Start and one Result event: `$0.01000 + $0.01350 = $0.02350` on the FREE tier. Prices can change; the [pricing page](https://apify.com/truefetch/google-trends-explore/pricing) is authoritative.

### How does Google Trends Explore compare with alternatives?

**Against the Explore interface.** Free, and entirely adequate for one question asked once. It stops being adequate when the same comparison has to run on a schedule, across markets, or feed something downstream.

**Against Google's own Trends API.** The [Trends API alpha](https://developers.google.com/search/apis/trends) returns consistently scaled data that can be joined across requests and compared across dozens of terms — both things this Actor cannot do. Access is application-gated. If merging series across requests is required and you have alpha access, choose it.

**Against narrower Trends Actors.** Several read Google Trends. This one is built around the comparison rather than the single term: the values arrive scaled against each other, and the record states the window and bucket size it was measured at, so a stored series stays interpretable months later.

**Against a keyword research suite.** Those give volumes, difficulty and CPC, which this Actor does not. They are complementary, not substitutes.

### What are the limits and troubleshooting steps?

Each limit below includes its next step:

- **A sixth term is refused.** This Actor accepts one to five values. Split larger sets, but do not compare values across separately normalized runs.
- **A low-volume term returns nothing.** Try a broader term, larger market, or longer window.
- **One section is empty.** The affected field stays null and the run counts an incomplete row. Retry once; include the run ID if it persists.
- **Identical runs differ slightly.** Treat small changes on low-interest terms as sampling noise.
- **The run returns nothing.** Google refused the request window; retry later rather than treating it as an empty trend.

Smallest reproducible input for a bug report is the two-term bitcoin/ethereum JSON from the How-do-I-run section. Attach it, the run ID, and which section was missing to [Issues](https://apify.com/truefetch/google-trends-explore/issues).

### Frequently asked questions

#### Is there a Google Trends interest by region API?

Yes. `regions` follows `location`: Worldwide returns countries such as `SG`, while a country returns subregions such as `US-WY`. Each entry carries the name, source code, and 0-100 value.

#### Is there a Google Trends related queries API?

Yes. `queries_top` and `queries_rising` return query text, value, and the source Explore link. Top values use a 0-100 scale; rising values are percentage growth.

#### Why is `interest_average` null?

Google supplies it only for comparisons of two or more terms. A single-term row leaves it null instead of inserting a locally calculated substitute.

#### Can I compare numbers from two different runs?

No. Each run is normalized independently, so put every term you want to compare into one run.

#### What does `resolution` mean and why does it change?

It is Google's timeline bucket size for the selected window: an hour uses minutes, while the full archive uses months.

#### What is a `note` on a timeline entry?

It records a source methodology change from that point onward, so the Actor preserves it with the affected bucket.

#### Does the category filter affect related queries too?

Yes. It applies to the timeline, regions, and both related-query lists.

#### Is there a free Google Trends Explore API?

No open official API currently matches this workflow. Google's alpha is application-gated; this Actor reads classic Explore and charges $0.02350 for one Actor Start plus one published row on the FREE tier.

#### Can I schedule runs to track a term set?

Yes. Schedule the same term set, geography, window, and surface. Store `interest_average` per term, and watch `queries_rising` for `is_breakout` entries.

### Related TrueFetch Actors

Three siblings, each for a different stage of the same investigation:

- [Price Tracker API](https://apify.com/truefetch/price-tracker-api) — for scheduled product-price snapshots when the subject is retail monitoring rather than search-interest research.
- [Google Maps Business Listing](https://apify.com/truefetch/google-maps-business-listing) — turns a market that indexes strongly for a term into the businesses operating there.
- [Reddit Search API](https://apify.com/truefetch/reddit-search-api) — checks whether a search-interest signal is also appearing in public Reddit search results.

### Support

- [Store page](https://apify.com/truefetch/google-trends-explore)
- [API reference](https://apify.com/truefetch/google-trends-explore/api)
- [Input configuration](https://apify.com/truefetch/google-trends-explore/input)
- [Pricing](https://apify.com/truefetch/google-trends-explore/pricing)
- [Report an issue](https://apify.com/truefetch/google-trends-explore/issues)
- [TrueFetch community](https://t.me/TrueFetch)

[**Run a one-result test**](https://console.apify.com/actors/truefetch~google-trends-explore) · [**View API**](https://apify.com/truefetch/google-trends-explore/api)

**Last Updated:** August 12, 2026

# Actor input Schema

## `keywords` (type: `array`):

Compare one to five search terms in a single Explore request. Values are normalized together, so 100 marks the peak within this request and does not represent absolute search volume.

## `location` (type: `string`):

Choose Worldwide or one country. Each row reports interest relative to searches in that geography, so compare values within the selected location rather than across separate runs.

## `time_range` (type: `string`):

Choose a window from Past hour through 2004 - present. Google resolves the returned dates and sampling interval; short windows can legitimately contain no data for some term and location combinations.

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

Filter interest to one of 26 Google Trends categories, or retain All Categories. This helps disambiguate terms used in different industries.

## `search_type` (type: `string`):

Select Web, Image, News, Google Shopping, or YouTube search. Each surface uses a separate interest index and can return different timelines, regions, and related queries.

## Actor input object example

```json
{
  "keywords": [
    "javascript"
  ],
  "location": "Canada",
  "time_range": "2004 - present",
  "category": "Jobs & Education",
  "search_type": "YouTube search"
}
```

# Actor output Schema

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

Open the default Dataset. Each row carries 18 documented keys; interest is Google's 0-100 index, no-data buckets stay null, and values are comparable only within one geography, surface and request.

# 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 = {
    "keywords": [
        "javascript"
    ],
    "location": "Canada",
    "time_range": "2004 - present",
    "category": "Jobs & Education",
    "search_type": "YouTube search"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/google-trends-explore").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 = {
    "keywords": ["javascript"],
    "location": "Canada",
    "time_range": "2004 - present",
    "category": "Jobs & Education",
    "search_type": "YouTube search",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/google-trends-explore").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 '{
  "keywords": [
    "javascript"
  ],
  "location": "Canada",
  "time_range": "2004 - present",
  "category": "Jobs & Education",
  "search_type": "YouTube search"
}' |
apify call truefetch/google-trends-explore --silent --output-dataset

```

## MCP server setup

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

```

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/ubXiK9s9p31KTeQrg/builds/hr8XoOLSylXNUepkw/openapi.json