# Google Trends Scraper: Interest, Rising Queries & Trending Now (`roomy_tweet/google-trends-scraper`) Actor

Google Trends without a browser or API key: interest over time with average, peak and change, interest by state, metro or city, top and rising related queries, more than 5 terms compared on one scale, and the full Trending now list with search volumes.

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

## Pricing

from $0.40 / 1,000 search term 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?

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: Interest, Rising Queries & Trending Now

Get **Google Trends** data for any search term, as structured rows you can export or call through the API: **interest over time**, **interest by region** (state, metro or city), **top and rising related queries**, **comparisons of more than 5 terms on one scale**, and the full **Trending now** list with search volumes. It works like a Google Trends API: no browser, no API key and no proxies to set up, results in JSON, CSV or Excel.

### Why this Google Trends scraper

- **Built around Google's 429 errors.** Google Trends refuses requests that come without its session cookie, and refuses an IP that asks too much. This Actor gets a fresh cookie when Google refuses, and moves to another IP (datacenter, then residential) when Google keeps refusing. In our October 2026 test runs, 199 of 200 term results came back complete (the incomplete one is why requests now get more retries), 150 terms took 100 seconds.
- **Summary figures per term**: average, peak and peak date, latest value, and the change from the start to the end of the period. No spreadsheet work needed to see whether a term is growing.
- **More than 5 terms on one scale.** Google compares at most 5 terms at a time. Here you can compare more (up to 500 per run; we tested 12): an anchor term links the requests, and each term gets its **share of interest** in percent ([how it works](#comparing-more-than-5-terms)).
- **The full Trending now list**: every search trending in a country (644 in the US and 395 in Brazil over 24 hours in our test), not only the 10 of the RSS feed, with search volume, growth, start and end time, categories and related searches.
- **Regions at the level you need**: countries, states/provinces, US metros (DMA) or cities with coordinates.
- **Paste Trends URLs** from your browser: an Explore page keeps its own terms, location, time range, category and property.
- **No charge for unavailable term data.** Terms Google has no data for are saved without a search-term charge. The Actor Start fee still applies per run.
- **Run report and quality check**, so a change on Google's side shows up as a warning (or a failed run, for schedules), not as silently empty results.

### What you can use it for

- **SEO and content planning**: find rising queries before they peak, pick the wording people search for, time content for seasonal peaks.
- **Market and product research**: compare brands, products or categories on one scale and see which is gaining share.
- **E-commerce**: watch Google Shopping and YouTube interest for products; plan stock around seasonality.
- **Regional targeting**: see in which states, metros or cities a term is most searched, for ads and expansion.
- **Newsrooms and social media**: the Trending now list every few hours, filtered by category.
- **Finance and data science**: Google Trends as a time series signal, back to 2004.
- **AI agents and dashboards**: one clean row per term, ready for an LLM or a BI tool.

### Quick start

1. Type your **Search terms**, one per line: `pickleball`, `padel`.
2. Add **Locations** as country codes (`US`, `BR`, `GB`), regions (`US-CA`) or leave empty for worldwide. Every term runs in every location.
3. Pick a **Time range** (past hour to 2004 – present, or custom dates).
4. Run it and export the dataset, or read it through the API.

```json
{
  "searchTerms": ["pickleball", "padel"],
  "geos": ["US", "BR"],
  "timeRange": "past-12-months"
}
```

### What you get

One row per term and location:

| Field | Example |
|---|---|
| `searchTerm`, `geo`, `timeRange`, `timeRangeResolved`, `resolution` | padel · BR · today 12-m · 2025-10-25 2026-10-25 · WEEK |
| `averageInterest`, `peakInterest`, `peakDate` | 51.1 · 100 · 2025-11-09 |
| `latestInterest`, `latestDate` | 45 · 2026-10-18 (the last complete week) |
| `changePercent` | 1.1 (average of the last quarter of the period against the first quarter) |
| `interestOverTime` | `[{ "date": "2026-10-18", "value": 45, "hasData": true, "isPartial": false }, …]` |
| `interestByRegion`, `regionResolution` | `[{ "geoCode": "BR-RS", "geoName": "State of Rio Grande do Sul", "value": 100 }, …]` · REGION |
| `relatedQueriesTop` | `[{ "query": "padel raquete", "value": 100 }, …]` |
| `relatedQueriesRising` | `[{ "query": "padel news", "increasePercent": 3600, "breakout": false, "formattedValue": "+3,600%" }, …]` |
| `comparedWith`, `scale`, `shareOfInterestPercent` | In compare mode: the other terms, the scale used, the term's share |
| `hasData`, `errors` | false when Google has no data; sections that failed, if any |
| `trendsUrl`, `scrapedAt` | The same chart on trends.google.com |

And one row per trending search:

| Field | Example |
|---|---|
| `trend`, `geo`, `rank` | vasco da gama x corinthians · BR · 1 |
| `searchVolume`, `searchVolumeText` | 2000000 · 2M+ (Google's volume bucket) |
| `increasePercent`, `active`, `startedAt`, `endedAt` | 1000 · true · 2026-10-24T17:20:00Z · null |
| `categories`, `relatedSearches` | \[Sports] · \["corinthians x vasco", …] |

**Values are Google's relative interest, not search counts.** 100 is the highest point of the chart for that term, place and time; 50 is half as popular; 0 means too little data. That is how Google Trends works for everyone. The values matched Google's own website on 51 of 54 weekly points we checked; the other 3 differed by 1, because Google samples its data (the same request a few minutes apart can differ slightly) and the last week was still in progress.

### Pricing

Pay per result, with platform usage included. The Actor Start event costs $0.00005 per GB of memory, with a minimum of one event per run ($0.00005 at the default 512 MB). The examples below exclude this start event.

| Plan | Per term result | Per trending search |
|---|---:|---:|
| Free | $0.002 | $0.0005 |
| Bronze | $0.001 | $0.0003 |
| Silver | $0.0006 | $0.0003 |
| Gold and above | $0.0004 | $0.0003 |

A **term result** is one term in one location with every section you turned on (interest over time, regions, related queries): the sections do not change the price.

| You get | Free plan |
|---|---:|
| 100 terms | $0.20 |
| 1,000 terms | $2.00 |
| The top 100 trending searches in 5 countries, every day for a month | about $7.50 |

No search-term charge: terms Google has no data for (saved with `hasData: false`), and terms that failed. The Actor Start fee still applies. Apify's free plan includes $5 of monthly credit, enough for about 2,500 term results before start fees. Set a maximum cost per run and the run stops by itself when it gets there.

### Options

```json
{
  "searchTerms": ["coca cola", "pepsi", "red bull", "celsius"],
  "compareTerms": true,
  "geos": ["US"],
  "timeRange": "custom",
  "startDate": "2024-01-01",
  "endDate": "2026-06-30",
  "category": "Food & Drink",
  "searchProperty": "web",
  "regionResolution": "DMA"
}
```

- **Locations**: `US`, `BR`, `GB` (countries), `US-CA`, `BR-SP` (regions), `US-CA-807` (a US metro), or empty for worldwide.
- **Time range**: past hour, 4 hours, day, 7 days, 30 days, 90 days, 12 months, 5 years, 2004 – present, or custom dates. Google picks the point size: hourly up to 7 days, daily up to about 9 months, weekly up to 5 years, monthly beyond.
- **Category**: a name as trends.google.com shows it ("Food & Drink", "Finance") or a category ID (71). Empty = all categories.
- **Google property**: web search, image search, news search, YouTube search or Google Shopping.
- **Sections**: turn interest over time, interest by region, related queries and related topics on or off. Fewer sections make runs faster; the price per term stays the same.
- **Region level**: Google's default (countries for worldwide, states for a country), cities, or US metros (DMA). A level a location doesn't have falls back to Google's default, and `regionResolution` says which one was used.
- **Google Trends URLs**: paste `trends.google.com/trends/explore?q=…` (up to 5 terms, compared as on the website) or `trends.google.com/trending?geo=…&hours=…&category=…&status=active`.
- **Language** changes region and topic names (`pt-BR`, `de`...), not the data.

**Related topics** are off by default: in October 2026 Google returned no related topics for any search we tried, on its own website too ("not enough data"). Turn them on if Google brings them back. Google gives them for single terms only, not inside comparisons.

### Comparing more than 5 terms

Turn on **Compare terms on one scale** and all terms share one 0–100 scale, like Google's Compare button, plus a `shareOfInterestPercent` per term (its part of the total interest of all compared terms).

Google takes at most 5 terms per comparison, each comparison on its own scale. With more terms, the first request takes 5; its most searched term becomes the **anchor** and is repeated next to 4 new terms in every further request. Each further request is scaled so the anchor matches its first-request values, then everything is rescaled so the top point of any term is 100.

What to know:

- Values in compare mode can have decimals.
- A term far smaller than the anchor gets few distinct values, as on Google's own chart.
- `scale` says how each term was placed: `shared`; `shared-low-precision` when the anchor peaked under 10 in that request (a much bigger term was in it), so the factor rests on few values; `own` when the anchor had no data in that request and the term kept its own scale.
- Our test: 12 soft-drink and energy-drink brands across 3 requests, shares adding up to 100%.

### Trending now

```json
{
  "trendingGeos": ["US", "BR", "JP"],
  "trendingHours": "24",
  "trendingCategories": ["17", "18"],
  "trendingActiveOnly": true,
  "maxTrendsPerGeo": 100
}
```

- **Past 4 hours, 24 hours, 48 hours or 7 days**, per country.
- **Categories**: Sports, Technology, Entertainment, Politics, Business and Finance and 14 more, as on trends.google.com/trending. A trend can have several.
- **Only active** leaves out trends Google marks as ended.
- Google lists them by relevance; **Max trending searches per location** keeps the first ones. In our tests Google listed 644 for the US and 395 for Brazil over 24 hours, 117 for Germany over 4 hours and 2,568 for Japan over 7 days.
- `searchVolume` is Google's bucket (200K+ = 200000), not an exact count.

Trending now and search terms can run in the same run.

### Run report and quality check

Each run writes a **REPORT** to its key-value store: status per term and location (`OK`, `PARTIAL` when a section failed, `NO_DATA`, `FAILED`, `SKIPPED` when a run limit was reached), requests made, how many Google refused and which IP route was used.

A quality check flags runs where every term failed, where Google's response no longer has the expected parts, where no term had data, or where Trending now came back empty. With **Fail the run on a quality drop**, such a run is marked as failed, so a scheduled run e-mails you instead of saving empty rows.

### Integrations and API

Run it from the Apify API, the JavaScript or Python client, or schedule it in Apify. Results go to Google Sheets, Make, Zapier, n8n, Slack, webhooks, or anywhere through the API.

```bash
curl -X POST "https://api.apify.com/v2/acts/roomy_tweet~google-trends-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["pickleball"], "geos": ["US"]}'
```

### FAQ

**Is this the official Google Trends API?** No. Google's own Trends API is an alpha for a limited group of testers; this Actor reads the same data the Google Trends website shows, for any term.

**Why are the values 0–100 and not search volumes?** Google Trends never publishes search counts, only interest relative to the highest point. Trending now has volume buckets (200K+, 2M+).

**Why do two runs give slightly different numbers?** Google computes Trends from a sample of searches and refreshes it, so values can move by a point or two between requests. Long time ranges and popular terms move least.

**A term has `hasData: false`.** Google has too few searches for it in that place and time. Try a broader term, a bigger location or a longer time range. These rows are not charged.

**Can I get daily data for a whole year?** Google gives daily points for ranges up to about 9 months; longer ranges come weekly. Use a custom range of up to 9 months for daily points.

**How many terms per run?** Up to 500 search terms and 1,000 term results (terms × locations) per run, plus up to 50 Trending now locations.

**Is scraping Google Trends legal?** The Actor reads public, aggregated data that Google shows to anyone without login. It contains no personal data. You are responsible for how you use the results.

**Something broke or a field is missing.** Open an issue on the Actor's Issues tab with the run link; the REPORT usually shows what happened.

# Actor input Schema

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

What to look up on Google Trends, one term per line. Each term gets its own result (its own 0–100 scale) unless you turn on "Compare terms on one scale". A Google topic ID such as /m/05p0rrx also works.

## `startUrls` (type: `array`):

Optional. Paste pages from trends.google.com: an Explore page (/trends/explore?q=…, up to 5 terms compared, with its own location, time range, category and property) or Trending now (/trending?geo=…).

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

Country codes (US, BR, GB), regions (US-CA, BR-SP) or US metros (US-CA-807). Every term runs in every location. Leave empty for worldwide.

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

The period of the interest over time chart. Google picks the point size: hourly up to 7 days, daily up to 9 months, weekly up to 5 years, monthly beyond.

## `startDate` (type: `string`):

Only with the custom time range. 2004-01-01 or later.

## `endDate` (type: `string`):

Only with the custom time range.

## `compareTerms` (type: `boolean`):

Put all search terms on one 0–100 scale, as Google's Compare button does, and add each term's share of the total. Google compares at most 5 terms at once; for more, an anchor term links the requests (see the README).

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

Optional. Narrow the searches to a Google Trends category, by name ("Food & Drink", "Finance") or ID (71). Empty = all categories.

## `searchProperty` (type: `string`):

Which searches to count: web search, image search, news search, YouTube search or Google Shopping.

## `interestOverTime` (type: `boolean`):

The chart as points (date, value 0–100), plus average, peak, latest value and change.

## `interestByRegion` (type: `boolean`):

Where the term is searched most, relative to all searches in each place (0–100).

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

Google's default is countries for worldwide and states/provinces for a country. Metros (DMA) exist for the US only.

## `relatedQueries` (type: `boolean`):

Top and rising searches made together with the term, with growth in percent and Breakout flags.

## `relatedTopics` (type: `boolean`):

Off by default: in October 2026 Google returned no related topics for any search we tried, on its own website too. Turn on to get them if Google brings them back (single terms only, not comparisons).

## `trendingGeos` (type: `array`):

Country codes (US, BR, GB...) to save every search trending there right now, with search volume, growth, start time, categories and related searches. Leave empty to skip.

## `trendingHours` (type: `string`):

The window Trending now covers.

## `trendingCategories` (type: `array`):

Optional. Keep only trends in these categories.

## `trendingActiveOnly` (type: `boolean`):

Leave out trends Google marks as ended.

## `maxTrendsPerGeo` (type: `integer`):

Google lists them by relevance; the first ones are kept.

## `language` (type: `string`):

Language of region and topic names (en-US, pt-BR, es, de...). Search data does not change.

## `maxItems` (type: `integer`):

Stop after saving this many results (term results and trending searches together).

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

How many terms are fetched at the same time.

## `maxDurationSecs` (type: `integer`):

Terms not started by then are skipped (status SKIPPED in the report).

## `failOnQualityDrop` (type: `boolean`):

Mark the run as failed when the quality check finds a problem (every term failing, Google's response changing, Trending now empty), so scheduled runs alert you.

## Actor input object example

```json
{
  "searchTerms": [
    "pickleball",
    "padel"
  ],
  "geos": [
    "US"
  ],
  "timeRange": "past-12-months",
  "compareTerms": false,
  "searchProperty": "web",
  "interestOverTime": true,
  "interestByRegion": true,
  "regionResolution": "default",
  "relatedQueries": true,
  "relatedTopics": false,
  "trendingHours": "24",
  "trendingActiveOnly": false,
  "maxTrendsPerGeo": 100,
  "language": "en-US",
  "maxItems": 10000,
  "maxConcurrency": 3,
  "maxDurationSecs": 1800,
  "failOnQualityDrop": false
}
```

# Actor output Schema

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

One row per term and location: interest over time, regions, related queries and summary figures.

## `trending` (type: `string`):

Trending searches with volume, growth, start time and categories.

## `report` (type: `string`):

Status per term and location, request counts and quality checks.

# 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": [
        "pickleball",
        "padel"
    ],
    "geos": [
        "US"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("roomy_tweet/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": [
        "pickleball",
        "padel",
    ],
    "geos": ["US"],
}

# Run the Actor and wait for it to finish
run = client.actor("roomy_tweet/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": [
    "pickleball",
    "padel"
  ],
  "geos": [
    "US"
  ]
}' |
apify call roomy_tweet/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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