# Google Trends Scraper Fixed (`ayeeyee/google-trends-scraper-fixed`) Actor
Real Google Trends data per keyword: interest over time, related/rising queries, and regional breakdown, plus an opportunity score combining trend strength, growth rate, and volatility into one number.
- **URL**: https://apify.com/ayeeyee/google-trends-scraper-fixed.md
- **Developed by:** [Virtual Footprint LLC](https://apify.com/ayeeyee) (community)
- **Categories:** SEO tools, News, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.00 / 1,000 keyword processeds
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/platform/actors/running/actors-in-store#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
#### Turn Google Trends data into ranked opportunities
Analyze search interest, growth, acceleration, volatility, related queries, and regional demand for each keyword — then receive a normalized opportunity score you can sort and compare programmatically.
-blue)
### Why use this Actor?
Google Trends normally leaves you to interpret several disconnected charts by eye: one for interest over time, one for related queries, one for regional breakdown, per keyword, one at a time.
This Actor retrieves the same underlying data for every keyword you give it, and adds one thing the raw Trends UI doesn't: a single **opportunity score** that combines recent interest, growth rate, acceleration, and volatility into one comparable number. You still get the full underlying time series, related queries, rising queries, and regional data — the score is a summary layer on top, not a replacement for it.
The score is an internal analytical signal, not a guarantee of business demand, revenue, or search volume.
### What you get
|
#### 📈 Interest over time
The complete normalized time series for each keyword, at the resolution Google Trends returns for your selected time range.
|
#### 🚀 Related & rising queries
The top related queries and the fastest-growing ("rising") related queries, including breakout terms.
|
|
#### 🌍 Regional interest
Relative interest by region (state/country level, depending on `geo`), sorted highest first.
|
#### 🎯 Opportunity score
One 0–100 score per keyword, combining trend level, growth, acceleration, and volatility, so you can rank keywords instead of eyeballing charts.
|
### From raw trends to opportunity intelligence
| Raw Google Trends workflow | This Actor |
| --- | --- |
| Manually inspect charts | Receive structured time-series data |
| Compare keywords visually | Rank keywords programmatically |
| Interpret growth manually | Receive a calculated growth rate |
| Guess whether momentum is increasing | Receive an acceleration label |
| Ignore unstable spikes | Apply a volatility penalty |
| Copy related queries by hand | Receive top and rising queries as arrays |
| Review one region at a time | Receive structured regional interest |
This doesn't replace judgment or predict outcomes — it removes the manual charting step so you can screen more keywords faster.
### How it works
```text
Keywords
|
Google Trends "explore" request
|
|-- Interest over time
|-- Related queries (top + rising)
+-- Regional interest
|
Growth + acceleration + volatility scoring
|
Opportunity score
|
Structured Apify dataset (one row per keyword + one run summary)
```
Each keyword is fetched independently through Google Trends' own (unofficial) `explore` + `widgetdata` interfaces — the same two-step mechanism the open-source `pytrends` library uses. There is no official Google Trends API; this Actor calls the same endpoints the public Trends website itself uses.
### Opportunity score
```text
opportunityScore
= (trendScore * 0.5)
+ (max(growthRatePct, 0) * 0.3)
- (volatility * 0.2)
```
Clamped to a 0–100 range. These are the actual weights used in the scoring code, not illustrative figures.
#### Recent trend level (`trendScore`)
The average of the most recent 4 data points in the time series, on Google Trends' own 0–100 relative scale.
#### Growth rate (`growthRatePct`)
Percentage change between the average of the most recent 4 points and the average of the earliest 4 points in the selected time range.
#### Acceleration
Compares first-half momentum to second-half momentum within the series (not just overall direction) and labels the result `accelerating`, `steady`, or `decelerating`.
#### Volatility
The population standard deviation of the interest values. Higher volatility subtracts from the opportunity score, so a keyword that's both elevated and rising, without wild week-to-week swings, scores highest.
> The opportunity score is a comparative analytical signal, not an absolute search-volume estimate, revenue forecast, or guarantee of future demand. Scoring requires at least 4 data points in the time series — very short time ranges may not have enough points to score.
### Use cases
- Compare several API or product ideas before committing engineering time
- Discover content topics with rising search interest
- Monitor interest in a product category over a season
- Identify which regions show the strongest relative demand for a term
- Compare momentum between a brand name and its competitors
- Surface rising related searches worth targeting
- Prioritize SEO or content topics by growth rate rather than gut feel
- Track seasonal interest patterns year over year
- Build a recurring market-intelligence workflow on a schedule
- Feed structured trend data into your own dashboards, databases, or agents
### Input
| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `keywords` | array of strings | Yes | — | One or more search terms to analyze. |
| `geo` | string | No | Worldwide (blank) | Two-letter country code, e.g. `US`, `GB`, `DE`. |
| `timeRange` | enum | No | `12m` | `1h`, `4h`, `1d`, `7d`, `1m`, `3m`, `12m`, or `5y`. |
| `category` | integer | No | `0` | Google Trends category ID to narrow results; `0` = all categories. |
| `proxyConfiguration` | object | No | Apify Proxy enabled | Proxy routing for Google Trends requests (see [Proxy configuration](#proxy-configuration)). |
Field names and defaults match the Actor's live input schema exactly.
### Input examples
**Compare a few keyword ideas**
```json
{
"keywords": ["AI agents", "MCP servers", "browser automation"],
"geo": "US",
"timeRange": "12m",
"category": 0,
"proxyConfiguration": { "useApifyProxy": true }
}
```
**One short-term trend, single keyword**
```json
{
"keywords": ["Google Gemini"],
"geo": "US",
"timeRange": "7d",
"category": 0,
"proxyConfiguration": { "useApifyProxy": true }
}
```
**Worldwide, long-term comparison**
```json
{
"keywords": ["electric vehicles", "hybrid vehicles"],
"geo": "",
"timeRange": "5y",
"category": 0,
"proxyConfiguration": { "useApifyProxy": true }
}
```
### Output
One dataset row per requested keyword, plus one final `run_summary` row. Each keyword row is one of three states: `COMPLETED` (scored normally), `NO_DATA` (Trends returned no time series for that keyword/geo/timeframe combination), or `EXPLORE_FAILED` (the initial request itself failed, typically a block or timeout).
| Field | Type | Description |
| --- | --- | --- |
| `keyword` | string | The keyword this row is for. |
| `geo` | string | Region requested (`"worldwide"` if left blank). |
| `timeRange` | string | Time range requested. |
| `interestOverTime` | array | `{date, timestamp, value}` per data point. |
| `relatedQueriesTop` | array | `{query, value, formattedValue}`, top related queries. |
| `relatedQueriesRising` | array | `{query, value, formattedValue}`, fastest-growing related queries (may include `"Breakout"`). |
| `regionalInterest` | array | `{geoName, geoCode, value}`, sorted highest first. |
| `trendScore` | number or null | See [Opportunity score](#opportunity-score). |
| `growthRatePct` | number or null | Percentage growth, recent vs. earlier average. |
| `acceleration` | string or null | `accelerating`, `steady`, or `decelerating`. |
| `volatility` | number or null | Population standard deviation of interest values. |
| `opportunityScore` | number or null | 0–100 combined score. |
| `status` | string | `COMPLETED`, `NO_DATA`, or `EXPLORE_FAILED`. |
| `scrapedAt` | string | ISO timestamp. |
### Output example
Real result from a live run (trimmed to a few data points for readability):
```json
{
"keyword": "electric vehicles",
"geo": "US",
"timeRange": "3m",
"interestOverTime": [
{ "date": "May 10 – 16, 2026", "timestamp": "1778371200", "value": 62 },
{ "date": "May 17 – 23, 2026", "timestamp": "1778976000", "value": 76 },
{ "date": "May 24 – 30, 2026", "timestamp": "1779580800", "value": 82 },
{ "date": "May 31 – Jun 6, 2026", "timestamp": "1780185600", "value": 85 }
],
"relatedQueriesTop": [
{ "query": "electric car", "value": 100, "formattedValue": "100" },
{ "query": "hybrid vehicles", "value": 72, "formattedValue": "72" }
],
"relatedQueriesRising": [
{ "query": "ev tax credit 2026", "value": 850, "formattedValue": "+850%" }
],
"regionalInterest": [
{ "geoName": "California", "geoCode": "US-CA", "value": 100 },
{ "geoName": "Washington", "geoCode": "US-WA", "value": 61 }
],
"trendScore": 76.3,
"growthRatePct": 14.2,
"acceleration": "accelerating",
"volatility": 9.1,
"opportunityScore": 14.9,
"status": "COMPLETED",
"scrapedAt": "2026-08-01T05:57:00.000000+00:00"
}
```
Field values here are drawn from a real run against `electric vehicles`; the `interestOverTime` array is trimmed for length (a full run returns the complete series for the selected time range).
`run_summary` row (the actual fields returned, once per run):
```json
{
"recordType": "run_summary",
"totalKeywords": 2,
"completed": 2,
"failed": 0,
"topOpportunity": "electric vehicles",
"scrapedAt": "2026-08-01T05:57:07.506507+00:00"
}
```
### Understanding the results
Interest values follow Google Trends' own scale: relative to the keyword's peak within the requested time range and region, 0–100. They are not absolute monthly search volume. A `growthRatePct` on a rising-but-small keyword can look dramatic (breakout related queries in particular can show huge percentage growth off a tiny base) — read percentage growth alongside the absolute `trendScore`, not in isolation.
### Status values
| Status | Meaning | Recommended action |
| --- | --- | --- |
| `COMPLETED` | Trend data was retrieved and scored. | Use the result normally. |
| `NO_DATA` | Google Trends returned no usable time series for this keyword/geo/timeframe combination. | Try a different keyword, region, category, or time range. |
| `EXPLORE_FAILED` | The initial Trends request itself failed. | Retry, ideally with residential proxy routing (see below). |
### Proxy configuration
Google Trends frequently rate-limits or blocks requests from datacenter/cloud IP ranges — this affects any tool that calls it, including this Actor and other Trends scrapers on the Store. Apify Proxy is enabled by default (`useApifyProxy: true`); routing through the residential proxy group can improve reliability further:
```json
{
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": ["RESIDENTIAL"]
}
}
```
Proxy use reduces blocking but can't guarantee every keyword succeeds on every run. Keywords that come back `EXPLORE_FAILED` or `NO_DATA` are not charged (see Pricing) and can simply be re-submitted.
### Pricing
Pay-per-event pricing: one **Actor start** event per run, plus one **keyword-processed** event for each keyword that reaches `COMPLETED` status. Keywords that end in `NO_DATA` or `EXPLORE_FAILED` are not charged.
```text
5 submitted keywords
4 completed successfully
1 failed (EXPLORE_FAILED)
Billable events:
- 1 Actor start
- 4 keyword-processed events
```
Current per-event prices are shown in the Pricing tab on this Actor's Store page.
### Notes and limitations
- Google Trends has no official API and no published SLA for this unofficial interface — occasional blocks or failures are expected, not a sign of a broken Actor.
- Results vary by region, time range, category, and exact query wording; two close phrasings of the same idea can score differently.
- Values use Google Trends' relative 0–100 scale, not absolute search volume.
- Scoring requires at least 4 time-series data points; very short time ranges may return fewer and skip scoring (`trendScore`, `growthRatePct`, `acceleration`, `volatility`, and `opportunityScore` will all be `null`).
- Short time ranges are inherently more volatile than long ones.
- Rising/breakout related queries can show very large percentage growth from a small historical base — treat them as directional signals, not precise multipliers.
- Some keyword/region/category combinations return no related-query or regional data even when the main time series succeeds.
- A keyword that fails on one run can succeed on a re-run, particularly with a different proxy route.
### Recommended workflow
Run a batch of candidate keywords together, sort the results by `opportunityScore`, then look at `relatedQueriesRising` and `regionalInterest` on your top candidates before deciding where to invest further research.
### Frequently asked questions
**Is this an official Google API?**
No. It uses Google Trends' unofficial `explore` and `widgetdata` interfaces — the same ones the public Trends website itself calls.
**Is the opportunity score a search-volume estimate?**
No. It's a comparative analytical score derived from relative trend behavior (level, growth, acceleration, volatility), not a volume or revenue figure.
**Why did a keyword return `NO_DATA`?**
The term likely has insufficient recorded search activity for the specific region, category, and time range combination you selected.
**Why did a keyword return `EXPLORE_FAILED`?**
The request was likely blocked or rate-limited. Retry, ideally with the residential proxy group enabled.
**Can I compare unrelated keywords against each other?**
Yes, but interpret carefully — Trends values are relative to each keyword's own peak, so a score comparison across very different topics needs business context, not just the raw numbers.
**Are failed keywords charged?**
No — only keywords that reach `COMPLETED` status trigger the keyword-processed charge.
**Can I run this on a schedule?**
Yes, using Apify's standard Schedules feature (available to any Actor on the platform) — nothing Trends-specific is required to set that up.
**Can agents call this Actor?**
Yes, through the standard Apify API/SDK like any Actor, and through Apify's general-purpose MCP server (which can call any Actor on the platform by ID). This Actor does not have its own dedicated MCP/Standby endpoint.
### Run via API
```bash
curl -X POST \
"https://api.apify.com/v2/acts/ayeeyee~google-trends-scraper-fixed/runs?token=$APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"keywords": ["AI agents", "MCP servers"],
"geo": "US",
"timeRange": "12m",
"category": 0,
"proxyConfiguration": { "useApifyProxy": true }
}'
```
### Related Actors
Part of a broader catalog of rebuilt-for-real actors on this account, including LinkedIn Jobs Scraper Enhanced and a five-Actor security-scanning line (Gitleaks, Trivy, Syft, Grype, OSV-Scanner).
### Start comparing opportunities
Add the keywords you're considering, pick a market and time range, and run the Actor. The resulting dataset gives you both the underlying Google Trends data and a consistent opportunity score for deciding what to investigate next.
# Actor input Schema
## `keywords` (type: `array`):
One or more search terms to analyze on Google Trends.
## `geo` (type: `string`):
Two-letter country code (e.g. US, GB, DE). Leave blank for worldwide.
## `timeRange` (type: `string`):
How far back to look.
## `category` (type: `integer`):
Google Trends category ID to narrow results. 0 = All categories.
## `proxyConfiguration` (type: `object`):
Google Trends blocks datacenter IPs aggressively. Using Apify Proxy (residential group recommended for best success rate) routes requests through rotating IPs instead of the container's bare egress address.
## Actor input object example
```json
{
"keywords": [
"artificial intelligence"
],
"geo": "",
"timeRange": "12m",
"category": 0,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `results` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {};
// Run the Actor and wait for it to finish
const run = await client.actor("ayeeyee/google-trends-scraper-fixed").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {}
# Run the Actor and wait for it to finish
run = client.actor("ayeeyee/google-trends-scraper-fixed").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{}' |
apify call ayeeyee/google-trends-scraper-fixed --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=ayeeyee/google-trends-scraper-fixed",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/acts/CNWzdOgFywkVhT2Ku/builds/JIjHtulcjxGOwFoob/openapi.json