# Google Trends Scraper & API: Bulk Trend Summaries (`meridianlabs/google-trends-scraper`) Actor

Bulk Google Trends API and pytrends alternative. Each keyword lookup returns interest over time, interest by region, rising related searches and a plain-English summary: rising or falling, year on year, peak, seasonality. $5 per 1,000 keyword lookups; failed lookups are free.

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

## Pricing

$5.00 / 1,000 keyword lookups

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** looks up **Google Trends for hundreds of keywords in one run** and gives you the full data plus a **plain-English trend summary for every keyword**: is interest **rising or falling**, how it compares **year on year**, when it **peaks**, whether it's **seasonal**, and which **related searches are taking off**. The input form is pre-filled, so the easiest way to try it is to click **Start**. A 3-keyword run costs $0.015. You can also call it from your own code as a **Google Trends API**, a maintained **pytrends alternative** (examples below).

It's built for **SEO and content marketers**, **online sellers doing product research**, **YouTube creators**, **analysts** and **AI agents** who need Google Trends data for more than a handful of keywords.

![Google Trends Scraper result: one row per keyword with momentum, year-on-year change, seasonality and the top rising search](https://raw.githubusercontent.com/leewilliam200/meridianlabs-apify-assets/main/google-trends-scraper/output-summary-table.jpg)

### What does Google Trends Scraper do?

For each keyword (or each [Google Trends](https://trends.google.com) URL you paste) it returns:

- 📈 **Interest over time** (`interestOverTime`): the full 0–100 series, hourly, daily, weekly or monthly depending on the range.
- 🗺️ **Interest by region** (`interestByRegion`): countries (worldwide), states/regions (in a country) or US metro areas, highest first.
- 🔎 **Rising related searches** (`relatedQueries`): Google's top and **rising** related searches ("related queries"), with growth such as `+350%` or `Breakout`.
- 📝 **A plain-English summary** (`summary`) with the key numbers as separate, filterable fields:
  - momentum: rising, falling or stable over the last 13 weeks (or 7 days / 24 hours)
  - change year on year
  - peak date and value, and "now" compared with the range average
  - seasonality, e.g. *peaks every October*, including seasons across the new year such as November–January
  - the fastest-rising **relevant** related search

### Why use this Google Trends scraper?

- 🚀 **Bulk by design.** Paste a list of keywords, or Google Trends URLs, and get one row per keyword.
- 🧠 **Answers, not just numbers.** A readable summary plus ready-to-sort fields (`momentum`, `yearOnYearChangePct`, `seasonal`...), so you can find "rising and seasonal in Q4" across 500 keywords in a spreadsheet.
- 🧹 **Noise flagged.** Google's own "rising" lists sometimes include unrelated searches (we've seen *"laptop stand"* listed as rising for *"air fryer"*). Every related search carries `sharesWordWithKeyword`, and the summary only headlines relevant ones.
- ⚖️ **Compare on one scale.** Turn on *Compare keywords* to put up to 5 keywords on the same 0–100 scale (Google's limit), in as many groups as you need.
- ⚡ **Fast and dependable.** No browser, and no `429 Too Many Requests` errors for you to handle: proxies and retries are built in. In our 1,000-keyword test (September 2026) every lookup succeeded, typically in about 4 seconds per keyword.
- 🧾 **No silent empty runs.** Every keyword gets a row with a `status` (`ok`, `no_data`, `error` or `skipped`), and the run's status message says how many of each.
- 💸 **Fair billing.** You pay per keyword lookup. Failed lookups are free, and the run stops exactly at your maximum spending limit.
- 🤖 **AI-agent ready.** A documented output schema, a summary table view and stable field names. It works from the Apify API, integrations (Make, Zapier, n8n, Google Sheets) and MCP clients.

### How do I get Google Trends data for many keywords at once?

1. Enter your **keywords**, one per line, and/or paste **Google Trends URLs**.
2. Choose **location**, **time range** and **search type**. Pick **Past 5 years** to get seasonality and year-on-year change.
3. Optionally turn on **Compare keywords on one scale**.
4. Click **Start**. Open the **Summary** view for one line per keyword, or export everything as JSON, CSV or Excel.

![Google Trends Scraper input: keywords, location and time range](https://raw.githubusercontent.com/leewilliam200/meridianlabs-apify-assets/main/google-trends-scraper/google-trends-scraper-input-form.png)

Watch the 30-second demo:

[![Google Trends Scraper demo video](https://img.youtube.com/vi/SLY6A1bs6UA/maxresdefault.jpg)](https://www.youtube.com/watch?v=SLY6A1bs6UA)

#### Can I paste Google Trends URLs?

Yes. Paste URLs straight from trends.google.com, e.g. `https://trends.google.com/trends/explore?q=tea,coffee&geo=GB&gprop=youtube`. Each URL keeps its own terms (up to 5 compared), location, time range, category and search type. The form's settings apply only to the keyword list.

### Use it as a Google Trends API (pytrends alternative)

[pytrends](https://github.com/GeneralMills/pytrends), the unofficial Python library most people used for Google Trends, was archived by its owner in April 2025 and no longer gets fixes. It also sends every request from your own IP, so bulk jobs run into Google's `429 Too Many Requests` errors. This Actor does the same job as a hosted API: rotating proxies and retries are built in, so there are no 429s for you to handle. In our 1,000-keyword test (September 2026) every lookup succeeded, and failed lookups are free.

Python (`pip install apify-client`; get your token in Console → Settings → API & Integrations):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("meridianlabs/google-trends-scraper").call(run_input={
    "keywords": ["air fryer", "standing desk"],
    "geo": "US",
    "timeRange": "past_5_years",
})

for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["keyword"], row["status"], row["summary"]["text"])
```

This is for apify-client 3.x; on 2.x, use `run["defaultDatasetId"]`.

JavaScript (`npm install apify-client`, with `const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })`):

```js
const { items } = await client.dataset((await client.actor('meridianlabs/google-trends-scraper').call({ keywords: ['air fryer', 'standing desk'], geo: 'US', timeRange: 'past_5_years' })).defaultDatasetId).listItems();
```

**Coming from pytrends?** `interest_over_time()` is `interestOverTime`, `interest_by_region()` is `interestByRegion` and `related_queries()` is `relatedQueries` (top and rising). `timeframe='today 5-y'` becomes `"timeRange": "past_5_years"`, and `geo` works the same way. One keyword lookup returns all of them in a single row, plus the plain-English `summary`. Related topics aren't available (see Limitations).

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

**$5 per 1,000 keyword lookups ($0.005 per keyword lookup). Failed lookups are free.**

- ✅ **Charged:** keywords with data; keywords where Google has **no data** (the lookup ran and answered); and **partial** rows (timeline complete, but Google refused regions or related searches).
- 🆓 **Free:** errors, blocked lookups, invalid input, and keywords skipped because the run reached your **maximum spending limit** or its **time limit**.
- Examples: 3 keywords = $0.015, 100 keywords = $0.50, 1,000 keywords = $5. In compare mode each keyword counts once.
- **Free to try:** Apify's free plan includes $5 of platform usage every month, which covers about **1,000 keyword lookups** here. Platform usage is included in the price.
- Set a **maximum cost per run** in the run options and the Actor stops exactly there. Keywords it didn't reach are listed as `skipped` and not charged.

### Input

| Field | What it does |
|---|---|
| `keywords` | Search terms; each keyword is one keyword lookup ($0.005). Duplicates are removed. |
| `trendsUrls` | Google Trends explore URLs; each keeps its own settings. |
| `compareKeywords` | Put keywords on one shared 0–100 scale, in groups of up to 5. |
| `geo` | Country or region code, e.g. `US`, `GB`, `AU`, `US-CA`, `AU-NSW`. Empty = worldwide. |
| `timeRange` | Past hour → 2004 to present, or a custom `YYYY-MM-DD YYYY-MM-DD` range. |
| `searchType` | Web, YouTube, News, Images or Google Shopping search. |
| `category` | Optional Google Trends category ID to disambiguate (0 = all). |
| `includeRegions`, `regionResolution` | Interest by region, and at which level: countries, states/regions or US metro areas. |
| `includeRelatedQueries` | Related searches, top and rising (Google's "related queries"). |
| `maxConcurrency` | Keywords looked up in parallel (1–10). |
| `failOnErrors` | Mark the run failed if any keyword errors (for schedules and monitoring). Failed keywords are still free. |

Example:

```json
{
  "keywords": ["halloween costume", "air fryer", "pickleball"],
  "geo": "US",
  "timeRange": "past_5_years"
}
```

### Output example

Data source: Google Trends (https://www.google.com/trends). Every row carries this in its `dataSource` field.

The **Summary** view on the Output tab gives one line per keyword:

![Google Trends Scraper Summary view in Apify Console: summary text, momentum, recent change, year on year, peak, seasonality and top rising related search per keyword](https://raw.githubusercontent.com/leewilliam200/meridianlabs-apify-assets/main/google-trends-scraper/google-trends-scraper-summary-view.png)

Every row also carries the full data behind the summary, e.g. five years of weekly interest for *halloween costume*:

![Google Trends data for halloween costume over 5 years, peaking every October](https://raw.githubusercontent.com/leewilliam200/meridianlabs-apify-assets/main/google-trends-scraper/halloween-costume-5-year-trend.jpg)

One row per keyword (trimmed):

```json
{
  "keyword": "halloween costume",
  "status": "ok",
  "geo": "US",
  "timeRange": "past_5_years",
  "searchType": "web",
  "comparedWith": [],
  "summary": {
    "text": "Interest is rising (+352% vs the previous 13 weeks); up 23% year on year. Peak: October 2021. Seasonal: peaks every October. Fastest-rising related search: '2024 halloween costume ideas' (Breakout).",
    "momentum": "rising",
    "recentChangePct": 352,
    "yearOnYearChangePct": 23,
    "peakDate": "2021-10-24",
    "seasonal": true,
    "seasonalPeakMonth": "October",
    "seasonalWindow": "September–November",
    "topRisingQuery": "2024 halloween costume ideas",
    "topRisingQueryGrowth": "Breakout"
  },
  "interestOverTime": [{ "date": "2021-09-19", "value": 30, "isPartial": false }, "..."],
  "averageInterest": 10,
  "interestByRegion": [{ "geoCode": "US-WV", "geoName": "West Virginia", "value": 100 }, "..."],
  "relatedQueries": {
    "top": [{ "query": "halloween costumes", "value": 100, "sharesWordWithKeyword": true }, "..."],
    "rising": [{ "query": "2024 halloween costume ideas", "growth": "Breakout", "growthPct": null, "sharesWordWithKeyword": true }, "..."]
  },
  "dataSource": "Google Trends (https://www.google.com/trends)",
  "scrapedAt": "2026-09-24T08:58:11Z"
}
```

`status` is one of:

- `ok`: data returned.
- `no_data`: Google has too little search data for this keyword, location and range.
- `error`: the lookup failed; not charged.
- `skipped`: not looked up because the run hit its spending or time limit; not charged.

Rows marked `"partial": true` have a complete timeline, but Google refused regions or related searches for that keyword and location. The missing parts are listed in `unavailableParts`.

### How to read Google Trends data

- **Values are relative, not search counts.** 100 is the keyword's highest point in the chosen range and location; 50 means half as popular as that peak. They are not monthly search volumes.
- **Separate lookups aren't comparable.** "air fryer = 80" and "standing desk = 80" from separate lookups don't mean equal popularity. Turn on **Compare keywords** to put them on one scale.
- **The last point may be partial.** The current week or day is still in progress; it's marked `isPartial: true` and left out of the summary.
- **Google samples its data.** Repeating a lookup can shift individual values by a few points. The trend is reliable; single values are approximate.
- **Longer ranges unlock more of the summary.** Year-on-year change needs more than 12 months of weekly data, and seasonality needs at least 2 full years. Use **Past 5 years** for both.

### What can you use Google Trends data for?

- 🗓️ **SEO and content planning:** find rising topics and when seasonal topics peak, so content ships before the peak.
- 🛒 **E-commerce and product research:** check whether a product is growing or fading, compare alternatives, and spot rising variants (e.g. *"ninja crispi air fryer"*).
- ▶️ **YouTube topic research:** set *Search type* to **YouTube search** to measure what people search on YouTube.
- 📊 **Market research and reporting:** track brands or categories over time and by region.
- 🤖 **AI agents:** give an agent reliable "is X trending?" answers with numbers attached.

### How do I track Google Trends automatically every week?

1. Fill in the input (for example, your 200 product keywords, **Past 5 years**) and click **Save as a new task**.
2. Open **Schedules** → **Create new**, pick the task and choose how often, e.g. every Monday at 08:00.
3. Every run adds a fresh dataset; connect it to a spreadsheet or a workflow (next section) or read it with the API.

200 keywords every week is about 860 lookups a month, **≈ $4.30/month**. Set **Fail the run if any lookup fails** on scheduled tasks so a failed run shows up in your run list and monitoring alerts. Failed keywords stay free.

### How do I send Google Trends data to Google Sheets, Make, Zapier, n8n or an AI agent?

- **Google Sheets and Drive:** on the Actor's or task's **Integrations** tab, add the Google Drive integration, or use Make, Zapier or n8n (below) with a Google Sheets "add rows" step.
- **Make, Zapier and n8n:** each has an official Apify app or node. Trigger on "Actor run finished", then get the dataset items. Ask for the `overview` view to get the Summary columns, one row per keyword.
- **Webhooks:** Integrations → **HTTP webhook** on "Run succeeded" sends the run details to your URL.
- **AI agents (MCP):** add `https://mcp.apify.com?actors=meridianlabs/google-trends-scraper` to your MCP client (Claude, Cursor, VS Code and others). The agent can then run lookups and read the summaries.
- **Code:** see *Use it as a Google Trends API* above.

### Limitations

- **No related topics and no city-level regions.** Google withholds these from automated lookups (and at the time of writing returns none even in a normal browser session). Related *searches* and country/state/metro regions are fully available.
- **Very new or very niche terms** may return `no_data`. That's Google's answer, not an error.
- **Rising lists can contain noise from Google's side.** Use `sharesWordWithKeyword` to filter.

### FAQ

#### Is there an official Google Trends API?

Google announced an official Trends API in 2025, but at the time of writing access is limited to an invite-only alpha, and the popular unofficial Python library *pytrends* was archived in April 2025. This Actor gives you the same Google Trends data through the Apify API, ready to use today: see *Use it as a Google Trends API* above for Python and JavaScript examples.

#### Is it legal to scrape Google Trends?

This Actor collects publicly available, aggregated, non-personal data from Google Trends. You're responsible for how you use it; check Google's terms for your use case. This Actor is not affiliated with or endorsed by Google. Data source: Google Trends (https://www.google.com/trends).

#### Can I use Google Trends data with AI agents, the API or MCP?

Yes. Run it through the Apify API or client libraries, schedule it, connect it to Make, Zapier, n8n or Google Sheets, or call it from MCP clients (see *How do I send Google Trends data…* above). All output fields are documented in the dataset schema.

#### How many keywords can I scrape at once?

Hundreds to thousands per run. 1,000 keywords take roughly 10–20 minutes, depending on *Parallel lookups*.

#### What happens if a run times out or restarts?

If a run approaches its timeout, the Actor stops starting new lookups and lists the rest as `skipped` (not charged), so you can run them again. If the platform restarts a run, it picks up where it left off without charging twice.

### More from Meridian Labs

- **[Keyword Search Volume + Google Trends](https://apify.com/meridianlabs/keyword-search-volume)**: monthly search volume, CPC, competition and keyword difficulty (Google Ads figures) plus this Actor's Google Trends summary for every keyword, in one row. From $3 per 1,000 keywords.
- **[Greenhouse, Lever & Ashby Jobs](https://apify.com/meridianlabs/greenhouse-lever-ashby-jobs-scraper)**: open jobs from companies on six hiring systems, with salary normalised to min, max, currency and period. $2 per 1,000 jobs.

### Support

Something looks wrong, or you need a field we don't return? Open an issue on the **Issues** tab with the input you used. We read every one.

If this saved you time, a rating helps others find it; if something's off, open an issue and we'll fix it fast.

# Actor input Schema

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

Search terms to look up. Each keyword is one keyword lookup ($0.005; failed lookups are free). Duplicates are removed. Optional if you give Google Trends URLs below.

## `trendsUrls` (type: `array`):

Paste Google Trends explore URLs, e.g. https://trends.google.com/trends/explore?q=air%20fryer\&geo=US\&date=today%205-y. Each URL keeps its own terms (up to 5 compared), location, time range, category and search type; the settings below don't apply to URLs.

## `compareKeywords` (type: `boolean`):

Off: each keyword gets its own 0–100 scale (100 = its own peak). On: keywords are compared in groups of up to 5 (Google's limit) so their numbers are directly comparable. Still charged per keyword.

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

Country code, or country-region code, as used by Google Trends: e.g. US, GB, AU, US-CA, AU-NSW. Leave empty for worldwide.

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

How far back to look. Google picks the data resolution from the range (e.g. daily for 90 days, weekly for 5 years, monthly for 2004 to present). Seasonality and year-on-year change need weekly data spanning more than a year: use Past 5 years.

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

Only used when Time range is Custom. Format: YYYY-MM-DD YYYY-MM-DD, e.g. 2024-01-01 2025-06-30.

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

Which Google search to measure: web search, YouTube, News, Image search or Google Shopping (the same choice as the search-type menu on trends.google.com).

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

Optional Google Trends category ID to narrow ambiguous keywords (0 = all categories). Example: 71 = Food & Drink. You'll find it after cat= in a Google Trends URL.

## `includeRegions` (type: `boolean`):

Adds interest by region: which countries (worldwide lookups), states/regions (country lookups) or US metro areas search the keyword most, 0–100, highest first. Included in the keyword lookup price.

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

Level for interest by region. Google's default: countries for worldwide lookups, states/regions for a country. City-level data is not available (Google withholds it from automated lookups), so for a state such as AU-NSW, where Google defaults to cities, the row comes back partial without regions.

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

Adds Google's top and rising related searches ("related queries"), with growth such as +350% or Breakout. Each is flagged with whether it shares a word with your keyword, because Google's rising list sometimes contains unrelated noise. Included in the keyword lookup price.

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

How many keywords to look up at once. Higher is faster; the price is the same.

## `failOnErrors` (type: `boolean`):

Useful for schedules and monitoring: the run is marked failed (so Apify can alert you) if any keyword errors. Failed keywords are still not charged.

## Actor input object example

```json
{
  "keywords": [
    "halloween costume",
    "air fryer",
    "pickleball"
  ],
  "trendsUrls": [
    "https://trends.google.com/trends/explore?q=air%20fryer,standing%20desk&geo=US"
  ],
  "compareKeywords": false,
  "geo": "US",
  "timeRange": "past_5_years",
  "searchType": "web",
  "category": 0,
  "includeRegions": true,
  "regionResolution": "auto",
  "includeRelatedQueries": true,
  "maxConcurrency": 5,
  "failOnErrors": false
}
```

# Actor output Schema

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

One row per keyword with the plain-English summary and its key numbers (dataset view 'overview').

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

Every field: interest over time, interest by region, related searches (top and rising) and the plain-English summary.

# 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": [
        "halloween costume",
        "air fryer",
        "pickleball"
    ],
    "geo": "US",
    "timeRange": "past_5_years"
};

// Run the Actor and wait for it to finish
const run = await client.actor("meridianlabs/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 = {
    "keywords": [
        "halloween costume",
        "air fryer",
        "pickleball",
    ],
    "geo": "US",
    "timeRange": "past_5_years",
}

# Run the Actor and wait for it to finish
run = client.actor("meridianlabs/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 '{
  "keywords": [
    "halloween costume",
    "air fryer",
    "pickleball"
  ],
  "geo": "US",
  "timeRange": "past_5_years"
}' |
apify call meridianlabs/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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