# Google Trends Scraper: 200 Keywords on One Scale (`honestdata/google-trends-one-scale`) Actor

Google Trends API alternative. Compare 5 to 200 keywords on one consistent scale: interest over time, growth, peak date and an error bar for every keyword. Small keywords Google rounds to 0 come back as real numbers, and glitches in Google's data are flagged.

- **URL**: https://apify.com/honestdata/google-trends-one-scale.md
- **Developed by:** [Honest Data](https://apify.com/honestdata) (community)
- **Categories:** SEO 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 keyword on one scales

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?

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

### What does this Google Trends scraper do?

It compares **any number of keywords, from 5 to 200**, from [Google Trends](https://trends.google.com) on **one consistent scale**, with an **error bar for every keyword**. It's a **Google Trends API alternative** without the 5-keyword limit, and small keywords come back as real numbers instead of 0.

**In short:** up to 200 keywords on one scale in one run, an error bar on every keyword, glitches in Google's data flagged, and keywords with no data are free.

Google Trends compares **at most 5 keywords at a time**, and it rescales every comparison so its own top keyword is 100. That causes two problems:

1. **You can't rank more than 5 keywords.** Two separate comparisons use two different scales, so their numbers can't be put side by side.
2. **Small keywords disappear.** Next to a big keyword, a small one gets rounded down to **0** for the whole year. Its data isn't just imprecise, it's gone.

This Actor fixes both. Send it 5, 50 or 200 keywords and every one comes back on **one consistent scale**, including the small ones, each with an error bar that tells you how precise it is.

### Example: 12 drinks, US, past 12 months

Put "coffee" and "dandelion coffee" into Google Trends directly and dandelion coffee reads **0** every week. Here is the same set, in one run, on one scale:

| Rank | Keyword | Avg interest | Share of set | 12-mo growth | ± |
|---:|---|---:|---:|---:|---:|
| 1 | coffee | 77.846 | 56.39% | +10.8% | 0.10% |
| 2 | tea | 37.135 | 26.90% | −2.0% | 0.14% |
| 3 | espresso | 9.615 | 6.97% | −8.6% | 0.42% |
| 4 | matcha | 6.247 | 4.53% | +32.8% | 0.44% |
| 6 | cold brew | 2.059 | 1.49% | +83.3% | 0.52% |
| 8 | yerba mate | 0.500 | 0.36% | +9.5% | 0.75% |
| 11 | chicory coffee | 0.069 | 0.05% | −10.2% | 1.19% |
| 12 | dandelion coffee | 0.017 | 0.01% | 0.0% | 1.02% |

Dandelion coffee is about **1/4,600th** of coffee, measured to within about 1%. The run used 7 requests and took 3 seconds.

### Why use it?

#### Error bars you can trust

Every keyword gets an error bar (`uncertaintyPct`), and it's **measured on your run**, not guessed:

- Keywords are compared in overlapping groups, and each group shares one keyword with the next. The shared keyword's two copies should match. Any difference beyond what rounding explains is Google's sampling noise, measured directly.
- It was tested against a simulated Google with known true values across thousands of keywords. About 68% of true values land within ±1σ and 95% within ±2σ, which is what honest error bars should do.
- A keyword Google has no usable data for is reported as `below_threshold`. It is never filled in with a guess.

#### Built-in check for glitches in Google's data

Sometimes Google Trends shifts across the board. From about late March to late June 2026, unrelated US keywords like *shower curtain*, *doormat* and *dish rack* all roughly doubled together and then fell back. In a 12-month US run of 7 keywords, **5 of them "peaked" inside that stretch**, coffee and tea included. Taken at face value, those peak dates are wrong.

Every run checks for this automatically, for free:

- One extra request compares a fixed basket of everyday, unrelated keywords. When they all move together, it's Google's data moving, not your keywords.
- `warning` tells you when a keyword's peak or growth falls in such a stretch, and `growthVsBaselinePct` gives the growth with the drift taken out.

#### Tested every day

An automated check runs this Actor every morning on a real query and checks the data itself (rows, filled fields, error bars), not just that the run finished.

#### Use cases

- **SEO and content**: rank a long keyword list by real interest, including the long tail
- **Product and market research**: compare brands, products or competitors beyond Google's 5-keyword limit
- **Trend spotting**: find fast-growing keywords early
- **Data science**: a clean, consistently scaled time series for modelling

### What data can you get from Google Trends?

| Field | What it is |
|---|---|
| `rank` | Position in your set by average interest |
| `averageInterest` | Average on the common scale (the single highest point across all your keywords = 100) |
| `shareOfSetPct` | Share of all the interest in your set |
| `growthPct` | Last quarter of the period vs the first quarter |
| `growthVsBaselinePct` | The same growth with Google's market-wide drift taken out |
| `peakInterest`, `peakDate` | The highest point and its date |
| `latestInterest` | The most recent complete point |
| `uncertaintyPct` | The ± on the keyword's overall level |
| `warning` | Set when the peak or growth falls in a market-wide jump in Google's data |
| `status` | `ok`, or `below_threshold` if Google has too little data |
| `series` | Every data point on the common scale, each with `marketWideJump` |

### How to scrape Google Trends for many keywords at once

1. Open the Actor and click **Try for free**.
2. Paste your keywords, one per line (5 to 200).
3. Pick a **location** and **time range** (the default is worldwide, past 12 months).
4. Click **Start**. Most runs take a few seconds.
5. Download the results as JSON, CSV or Excel, or read them through the API.

### How much does it cost to scrape Google Trends?

**$0.005 per keyword** that comes back on the common scale, so **100 keywords cost $0.50**. Keywords with no usable data are free, and the glitch check is free. There's also a tiny start fee of $0.00005 per run.

Apify's free plan includes $5 of monthly credit, which covers about **1,000 keywords a month**. The run checks your spending limit before it starts, so it never stops halfway through.

### Input

See the **Input** tab for every option. The main ones:

- **Keywords**: 5 to 200, one per line
- **Location**: a country or region code (e.g. `US`, `GB`, `US-CA`), or empty for worldwide
- **Time range**: past 7 days, 30 days, 90 days, 12 months or 5 years, 2004 to now, or a custom date range
- **Search type**: web, images, news, shopping or YouTube search
- **Category**: a Google Trends category ID, to narrow ambiguous keywords
- **Output format**: one row per keyword (with the full series inside), or one row per keyword per date

### Output

You can download the dataset as JSON, CSV, Excel, XML or HTML. One row per keyword looks like this (series shortened):

```json
[
  {
    "rank": 1,
    "keyword": "coffee",
    "status": "ok",
    "averageInterest": 54.87,
    "shareOfSetPct": 66.03,
    "peakInterest": 100,
    "peakDate": "2026-07-19",
    "latestInterest": 48,
    "growthPct": -10,
    "growthVsBaselinePct": -2.8,
    "warning": null,
    "uncertaintyPct": 0.06,
    "series": [
      { "date": "2026-07-17", "value": 56, "partial": false, "marketWideJump": false },
      { "date": "2026-07-18", "value": 69, "partial": false, "marketWideJump": false }
    ]
  },
  {
    "rank": 2,
    "keyword": "tea",
    "status": "ok",
    "averageInterest": 23.957,
    "shareOfSetPct": 28.83,
    "growthPct": -11,
    "growthVsBaselinePct": -3.9,
    "uncertaintyPct": 0.13
  }
]
```

Choose **One row per keyword per date** to get a flat table (`keyword`, `date`, `value`, ...) that drops straight into Sheets, Excel, Looker Studio or pandas. The `OUTPUT` record lists the dates of every market-wide jump found (`marketWideCheck`).

### Tips

- **How it works:** keywords are compared in overlapping groups of similar popularity, so a small keyword is never rounded away by a much bigger one. Each group shares one keyword with the next, and that shared keyword carries the scale across, like a relay race handing over a baton.
- `uncertaintyPct` is the precision of a keyword's **overall level**. Individual points of very small keywords are coarser, because Google reports whole numbers.
- When every keyword fits in one group (5 or fewer, of similar size), there are no links to measure sampling noise from, so only rounding error is reported.
- The glitch check uses English control keywords. Outside English-speaking regions they can have too little data, and the check is skipped (`checked: false`).

### FAQ

**Why not just compare in groups of 5 myself?** Each group is scaled to its own top keyword, so the numbers from different groups can't be compared, and small keywords round to 0 next to big ones.

**Is this Google's search volume?** No. Google Trends measures relative search interest, and this Actor keeps that meaning while putting everything on one scale.

**How many keywords can I send?** Up to 200 per run. It uses about one request to Google for every two keywords, plus one for the glitch check.

**Can I use it from code or an AI assistant?** Yes. Use the Apify API or the Python and JavaScript clients (see the **API** tab), connect it to Make, Zapier or Google Sheets, or schedule it. AI assistants such as Claude and Cursor can call it through Apify's MCP server: `https://mcp.apify.com?tools=honestdata/google-trends-one-scale`.

**Is it legal to scrape Google Trends?** Google Trends data is aggregated and anonymous, and this Actor collects no personal data. As with any data, check that your use fits the rules that apply to you.

**Found a problem?** Open an issue in the **Issues** tab. We read every report.

**Found it useful?** A short review on this page helps other people find it.

### More from Honest Data

- [AliExpress Product Search Scraper (US)](https://apify.com/honestdata/aliexpress-product-search): search results with the real regular price, ads and promos flagged.
- [YouTube Transcript Scraper](https://apify.com/honestdata/youtube-transcript-scraper): transcripts in bulk at $2 per 1,000, and misses are free.
- [Product Demand Radar](https://apify.com/honestdata/product-demand-radar): rank product ideas by Google demand and AliExpress supply.

# Actor input Schema

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

Up to 200 keywords. They all come back on one consistent scale, so you can rank them against each other, big and small.

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

Country or region code, e.g. US, GB, DE, US-CA. Leave empty for worldwide.

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

Period to compare. Google picks the point spacing: hourly for 7 days, daily up to 90 days, weekly up to 5 years, monthly beyond.

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

Optional. Overrides the time range above. Format: YYYY-MM-DD YYYY-MM-DD, e.g. 2024-01-01 2024-12-31.

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

Which Google search to measure: web (the usual Google Trends view), images, news, Google Shopping or YouTube.

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

Google Trends category. 0 means all categories.

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

One row per keyword with its ranking, summary and full series, or one flat row per keyword per date.

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

Google rate-limits heavy traffic. Apify Proxy is used by default; residential proxies are the most reliable for large runs.

## Actor input object example

```json
{
  "keywords": [
    "coffee",
    "tea",
    "matcha",
    "yerba mate",
    "chicory coffee"
  ],
  "geo": "",
  "timeRange": "today 12-m",
  "searchType": "",
  "category": 0,
  "outputMode": "keyword",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "keywords": [
        "coffee",
        "tea",
        "matcha",
        "yerba mate",
        "chicory coffee"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("honestdata/google-trends-one-scale").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": [
        "coffee",
        "tea",
        "matcha",
        "yerba mate",
        "chicory coffee",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("honestdata/google-trends-one-scale").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": [
    "coffee",
    "tea",
    "matcha",
    "yerba mate",
    "chicory coffee"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call honestdata/google-trends-one-scale --silent --output-dataset

```

## MCP server setup

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

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/jYhffqdduQF13s7jl/builds/5lC3aW3DFQjSRcIgC/openapi.json