# Google Trends Scraper: Fast, No Browser (`webthreenity/google-trends-scraper`) Actor

Google Trends data without a browser: interest over time, by region, city and US metro, related queries, trending searches by country. Compare any number of terms on one scale. Accepts the input of Apify's Google Trends Scraper.

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

## Pricing

from $2.50 / 1,000 search terms

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: Fast, No Browser

Get Google Trends data as clean rows: **interest over time, by region, city and US metro area, related queries (top and rising), and trending searches by country**. It talks to Google Trends directly, without a browser, so runs are quick and cheap, and it **compares any number of terms on one scale**, not just 5.

- **Works with your existing input.** Apify's Google Trends Scraper input (`searchTerms`, `isMultiple`, `timeRange`, `geo`, `category`, `startUrls`, `spreadsheetId`, `customTimeRange`, `maxItems`) runs unchanged, and results use the same field names.
- **Doesn't give up when Google pushes back.** Google limits how often one IP address can ask, so every attempt uses a new residential IP address and cookie, included in the price. A refused request is retried on another IP straight away. Failed searches are never charged.
- **More than 5 terms on one chart.** Turn on *Put all search terms on one scale* and 8, 50 or 500 terms come back comparable, with 100 as the highest point among all of them.
- **A summary for every term:** average, peak and when it happened, latest value, change over the period, and whether it is rising, falling or stable. No spreadsheet formulas needed.
- **Every Google Trends filter:** 9 time ranges or your own dates, 250 countries (and states or provinces through a URL), 1,132 categories, and web, image, news, YouTube or Google Shopping searches.
- **Trending now:** the searches trending in any country, with their approximate search volume and news articles.

### What you can do with it

- Find out whether a product, a brand or a topic is growing or fading before you invest in it.
- Pick blog topics and keywords with rising queries, then track them every week (schedule the Actor).
- Compare 50 competitors or product names on one scale for a market report.
- Find the states, cities or metro areas where interest is highest for local ads.
- Feed a dashboard, a newsletter or an AI agent with what people are searching for today.

### Quick start

1. Type your search terms, one per line.
2. Pick the country and time range.
3. Click **Start**. One row per term appears in the **Output** tab, with its summary; open a row for the full timeline, regions and related queries.

### Input examples

**A few terms, United States, past 5 years**

```json
{ "searchTerms": ["air fryer", "standing desk"], "geo": "US", "timeRange": "today 5-y" }
```

**Compare terms on one chart, as on Google Trends (up to 5 per line)**

```json
{ "searchTerms": ["coffee, tea, matcha"], "isMultiple": true }
```

**Any number of terms on one scale**

```json
{ "searchTerms": ["coffee", "tea", "matcha", "espresso", "latte", "chai", "cold brew", "hot chocolate"], "compareAllTerms": true, "geo": "US" }
```

**A Google Trends URL, for example a state and YouTube searches**

```json
{ "startUrls": [{ "url": "https://trends.google.com/trends/explore?geo=US-CA&q=pizza&date=today%203-m&gprop=youtube" }] }
```

**Your own dates and a category**

```json
{ "searchTerms": ["mortgage rates"], "geo": "GB", "customTimeRange": "2024-01-01 2026-06-30", "category": "7" }
```

**Trending searches in three countries**

```json
{ "trendingSearchesCountries": ["US", "GB", "FR"] }
```

### Output

One row per search term (or per comparison):

```json
{
  "type": "searchTerm",
  "searchTerm": "bitcoin",
  "geo": "US",
  "timeRange": "today 12-m",
  "average": 34.9,
  "peak": 100,
  "peakTime": "Feb 1 – 7, 2026",
  "latest": 15,
  "latestTime": "Oct 11 – 17, 2026",
  "changePercent": -48.2,
  "trend": "falling",
  "interestOverTime_timelineData": [
    { "time": "1760832000", "formattedTime": "Oct 19 – 25, 2025", "formattedAxisTime": "Oct 19, 2025", "value": [32], "hasData": [true], "formattedValue": ["32"] }
  ],
  "interestOverTime_averages": [],
  "interestBySubregion": [
    { "geoCode": "US-WY", "geoName": "Wyoming", "value": [100], "formattedValue": ["100"], "maxValueIndex": 0, "hasData": [true] }
  ],
  "interestByCity": [ "… up to 200 cities" ],
  "interestByMetro": [],
  "interestBy": [],
  "relatedQueries_top": [
    { "query": "bitcoin price", "value": 100, "formattedValue": "100", "hasData": true, "link": "/trends/explore?q=bitcoin+price&date=today+12-m&geo=US" }
  ],
  "relatedQueries_rising": [
    { "query": "spcx stock", "value": 14500, "formattedValue": "Breakout", "link": "/trends/explore?q=spcx+stock&date=today+12-m&geo=US" }
  ],
  "relatedTopics_top": [],
  "relatedTopics_rising": [],
  "trendsUrl": "https://trends.google.com/trends/explore?q=bitcoin&geo=US&date=today+12-m&hl=en-US",
  "scrapedAt": "2026-10-23T16:04:58.112Z"
}
```

- **Values are relative**, as on Google Trends: 100 is the highest point of the chart, 50 is half as many searches. They are not search counts.
- `interestBy` is filled for worldwide searches (by country), `interestBySubregion` inside a country (states, regions), `interestByCity` everywhere Google has city data, `interestByMetro` for the United States when you ask for it.
- In a comparison, each term has its own summary in `termSummaries`, Google's `interestOverTime_averages` has one average per term, and every related query says which term it belongs to.
- With *Put all search terms on one scale*, each term gets its own row and `"scale": "shared"`.
- A search that fails gets a row with an `error` and is not charged.

Trending searches come as rows with `"type": "trendingSearch"`: `country`, `rank`, `title`, `approxTraffic` (such as `"2,000+"`), `approxTrafficNumber`, `startedAt`, `picture` and `news` (title, URL, source).

### Coming from Apify's Google Trends Scraper?

Paste your input as it is. The field names of the results are the same, with a summary, the place, the time range, the search type and a link to the chart added to each row. Browser settings such as `skipDebugScreen` and `pageLoadTimeoutSecs` are accepted and have no effect, since there is no browser.

### How "one scale" works

Google compares at most 5 terms at a time, and scales each comparison so its own highest point is 100. To compare more, the Actor puts terms in groups of 5, compares the most popular term of each group with the other groups' leaders, and rescales each group from there. Values are rounded to one decimal; a term hundreds of times smaller than the most popular one shows values close to 0, as it would on Google Trends itself.

### Pricing

Pay per event: you pay for results delivered, nothing for failed searches.

| Event | Price |
|---|---|
| Search term (each term, including each term of a comparison) | $2.50 per 1,000 |
| Trending search (one row of trending searches) | $1.00 per 1,000 |

Residential proxies are included. Example: 200 terms with timeline, regions, cities and related queries = **$0.50**.

### Good to know

- **Related topics:** in October 2026 Google returns them empty for most searches, on its own website too, so they are off by default. Related queries are not affected.
- **Speed:** 10 terms are fetched at a time, each through its own IP address. Google sometimes refuses a request; it is retried on another IP, so a few terms take longer than others.
- **Small terms:** when too few people search for a term, Google reports no data (`hasData: false`) and the summary is empty.
- **States and provinces:** use a Google Trends URL with the place in it, such as `geo=US-CA` or `geo=FR-J`.
- **Fresh data:** the past hour, 4 hours and day are close to real time; weekly points in the past 12 months include the current, partial week, which the summary leaves out.

### FAQ

**Is this the same data as on trends.google.com?** Yes. The Actor asks Google Trends for the same data its website shows, in the same format.

**Can it compare more than 5 terms?** Yes, turn on *Put all search terms on one scale*.

**Can I run it every week?** Yes: save your input as a task and add a schedule in Apify Console.

**Is it legal to scrape Google Trends?** The Actor collects public, aggregated search interest data. Respect Google's terms of service for how you use and publish it.

### Support

Something not working as expected? Open an issue on the **Issues** tab with your input. Made by WebThreenity.

# Changelog

This Actor's version history is a separate document: https://apify.com/webthreenity/google-trends-scraper/changelog.md

# Actor input Schema

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

One search term per line. Each term gives one result row. With **Compare terms separated by commas**, a line such as `coffee, tea` compares those terms on one chart (Google allows 5 per comparison).

## `isMultiple` (type: `boolean`):

Treat a comma in a line as a separator: `coffee, tea` becomes one comparison of two terms, as on the Google Trends website.

## `compareAllTerms` (type: `boolean`):

Compare every search term against every other, not just 5: values are rescaled through the most popular term so 100 is the highest point among all of them. Each term still gets its own row.

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

Period of the data. The time between points depends on it, as on Google Trends.

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

Overrides **Time range**. Two dates, `YYYY-MM-DD YYYY-MM-DD`, for example `2024-01-01 2024-12-31`. Hourly data: `2026-10-01T00 2026-10-07T23`.

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

Where the searches were made. For a state or province, paste a Google Trends URL in **Google Trends URLs** (for example one with `geo=US-CA`).

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

Limit the data to searches in one category, for example Finance or Travel > Air Travel.

## `property` (type: `string`):

Which Google search the interest comes from.

## `includeInterestOverTime` (type: `boolean`):

The timeline, plus a summary per term: average, peak, latest value and change.

## `includeInterestByRegion` (type: `boolean`):

By country for worldwide searches, by state or region inside a country.

## `includeCities` (type: `boolean`):

Up to 200 cities.

## `includeMetros` (type: `boolean`):

Nielsen DMA metro areas, for searches in the United States or a US state.

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

Top and rising searches made together with each term.

## `includeRelatedTopics` (type: `boolean`):

Top and rising topics. Off by default: in October 2026 Google returns them empty for most searches (related queries are not affected).

## `trendingSearchesCountries` (type: `array`):

Country codes such as `US`, `GB`, `FR`. Adds the searches trending right now in each country, with their approximate search volume and news articles. Works with or without search terms.

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

Paste URLs from trends.google.com/trends/explore. Terms, place (including states such as `US-CA`), time, category and search type are read from each URL.

## `spreadsheetId` (type: `string`):

ID of a public Google Sheet with one search term per row in the first column. Row 1 is the column title and is skipped.

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

Stop after this many search term rows. 0 means no limit.

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

Apify residential proxies by default, included in the price: Google limits each IP address, and every attempt gets a fresh residential IP. If you pick datacenter proxies, searches that keep failing move to residential ones.

## `viewedFrom` (type: `string`):

Country of the residential IP addresses. Leave empty for the United States (European IPs can get Google's consent page). This does not change the data: the Country field does.

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

Search terms processed at the same time. The Actor slows down by itself when Google asks it to.

## `maxRequestRetries` (type: `integer`):

Attempts with a new IP address before a term is reported as failed. Failed terms are not charged.

## `skipDebugScreen` (type: `boolean`):

Accepted for compatibility with Apify's Google Trends Scraper. This Actor uses no browser, so there are no screenshots.

## `pageLoadTimeoutSecs` (type: `integer`):

Accepted for compatibility with Apify's Google Trends Scraper and ignored: requests time out after 30 seconds and are retried.

## Actor input object example

```json
{
  "searchTerms": [
    "web scraping"
  ],
  "isMultiple": false,
  "compareAllTerms": false,
  "timeRange": "",
  "geo": "",
  "category": "",
  "property": "",
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "includeCities": true,
  "includeMetros": false,
  "includeRelatedQueries": true,
  "includeRelatedTopics": false,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "viewedFrom": "",
  "maxConcurrency": 10,
  "maxRequestRetries": 8,
  "skipDebugScreen": true
}
```

# Actor output Schema

## `searchTerms` (type: `string`):

Rows with type searchTerm: interestOverTime_timelineData, interestOverTime_averages, interestBy, interestBySubregion, interestByCity, interestByMetro, relatedQueries_top, relatedQueries_rising, relatedTopics_top, relatedTopics_rising, plus average, peak, peakTime, latest, changePercent and trend (or termSummaries for a comparison).

## `trendingSearches` (type: `string`):

Rows with type trendingSearch: country, rank, title, approxTraffic, approxTrafficNumber, startedAt, picture and news articles.

## `runSummary` (type: `string`):

How many searches succeeded or failed, and how many requests Google slowed down.

# 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": [
        "web scraping"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("webthreenity/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": ["web scraping"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("webthreenity/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": [
    "web scraping"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call webthreenity/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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