# Google Trends Scraper: No Login Needed (`bibian/google-trends-scraper`) Actor

Extract Google Trends data without logging in: interest over time, interest by region, related queries and topics for up to 25 search terms, plus the daily trending searches feed for any country.

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

## Pricing

from $1.60 / 1,000 trend data points

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 – 10/10 Reliable

Scrape Google Trends data without logging in or solving a captcha: interest over time, interest by region, related queries and related topics for up to 25 search terms, plus the daily trending searches feed for any country.

### At a glance

| | |
|---|---|
| **What you get** | Interest over time, interest by region, related queries, related topics, and the daily trending-searches feed, straight from Google Trends' own API. |
| **Price** | $2.00 per 1,000 rows: a 50-row test run costs about $0.11, start fee included. |
| **Speed** | A single search term with interest over time returns about 50 rows in 5-10 seconds (measured: 53 rows in 7s). No login, no proxy, no browser to configure. |
| **Try it** | Click **Try for free**: the form is already filled with 3 compared terms, region US, and interest over time, by region, related queries, related topics and trending-now all switched on. |
| **Keep it fresh** | Schedule it daily and keep only the new rows: see "Monitor new rows daily" below. |

### What you can do with it

- **Track a term's interest over time**: weekly or daily search-interest values for any term, country and time range, ready for a dashboard or a report.
- **Compare up to 5 terms at once**: Google's own comparison mode, normalized on the same 0-100 scale, in one call.
- **Compare one term across up to 5 regions**: the same comparison mode, varied by region instead of term — see "Compare one term across regions" in the input.
- **Find related queries and topics**: the "top" and "rising" searches and topics people associate with a term, with the exact value and link Google shows on its own site.
- **Watch what is trending right now**: today's trending searches for any country, with approximate traffic and the news stories driving each trend.
- **Replace pytrends in Python without rewriting anything**: [pytrends-cloud](https://github.com/morvanvivien/pytrends-cloud) keeps the `TrendReq` API and its pandas DataFrames and runs on this actor, so the 429 errors stop. See "Drop-in replacement for pytrends" below.

### Ready-to-run input examples

Copy one of these into the input editor as is.

Track one term over time:

```json
{
  "searchTerms": ["ChatGPT"],
  "geo": "US",
  "timeRange": "today 12-m",
  "interestOverTime": true
}
```

Compare several terms in one region:

```json
{
  "searchTerms": ["ChatGPT", "Claude AI", "Gemini AI"],
  "geo": "US",
  "timeRange": "today 12-m",
  "interestOverTime": true,
  "interestByRegion": true,
  "relatedQueries": true
}
```

Today's trending searches:

```json
{
  "searchTerms": [],
  "trendingNow": true,
  "trendingGeo": "US"
}
```

### Input

| Field | What it does |
|---|---|
| Search terms | 1 to 25 terms. Up to 5 are compared together on the same scale in one call; more are split into separate batches of 5 that do not share a scale with each other. |
| Region (geo) | Empty for worldwide, a country code (`US`, `FR`), or a sub-region (`US-CA`, `GB-LON`). |
| Time range | A Google Trends range (`now 7-d`, `today 12-m`, `today 5-y`, `all`, ...). |
| Custom time range | Optional, replaces "Time range": two dates such as `2024-01-01 2024-06-30`, or to the hour for ranges under a week, such as `2024-01-01T00 2024-01-07T23`. |
| Category | Google Trends category ID. `0` means every category. |
| Property | `web`, `images`, `news`, `youtube` or `froogle` (Google Shopping). |
| Interface language | Language tag for region and topic names, such as `en-US` or `fr`. |
| Interest over time / by region, Related queries / topics | Which outputs to fetch. At least one is required when search terms are given. |
| Interest by region: resolution | Optional level of detail: `COUNTRY` (worldwide only), `REGION` or `CITY` (worldwide or inside a country), `DMA` for US metro areas. Empty keeps Google's default. |
| Interest by region: include low-volume regions | Also return the regions Google hides by default for their low search volume. |
| Compact output | One result per search term and data type, with the whole series inside (`points`, `regions`, `top` and `rising` lists), instead of one row per date, region or related entry. Same data, far fewer results, so it costs much less. Not compatible with "Only new results". |
| Compare one term across regions | 2 to 5 region codes to compare a single search term across, on the same 0-100 scale in one call (Google's own "compare across regions" mode). Needs exactly one search term and is not compatible with "Interest by region"; "Region (geo)" is ignored when this is set. |
| Trending now | A separate mode: today's trending searches for one country. Works with or without search terms. |
| Trending now: country | Two-letter country code for "Trending now" (`US`, `FR`, `GB`, `IN`, `JP`, ...). |

### Output

One record per data point. Five real results from live runs, one of each kind:

Interest over time:

```json
{
  "id": "ts::ChatGPT::US::today 12-m::1762646400",
  "searchTerm": "ChatGPT",
  "geo": "US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "date": "2025-11-09T00:00:00.000Z",
  "value": 100,
  "isPartial": false
}
```

Interest by region:

```json
{
  "id": "geo::ChatGPT::US::today 12-m::US-CA",
  "searchTerm": "ChatGPT",
  "geo": "US-CA",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "regionName": "California",
  "value": 94
}
```

Related queries:

```json
{
  "id": "relq::ChatGPT::US::today 12-m::top::what is chatgpt",
  "searchTerm": "ChatGPT",
  "geo": "US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "type": "top",
  "relatedQuery": "what is chatgpt",
  "value": 100,
  "link": "https://trends.google.com/trends/explore?q=what+is+chatgpt&date=today+12-m&geo=US"
}
```

Interest over time, comparing one term across regions ("Compare one term across regions" set to `["US-NY", "US-CA"]`):

```json
{
  "id": "ts::pizza::US-NY::today 12-m::1762646400",
  "searchTerm": "pizza",
  "geo": "US-NY",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "date": "2025-11-09T00:00:00.000Z",
  "value": 83,
  "isPartial": false
}
```

Trending now:

```json
{
  "id": "trendingnow::US::d'andre swift::Sun, 8 Nov 2026 17:20:00 -0800",
  "geo": "US",
  "title": "d'andre swift",
  "approxTraffic": "2000+",
  "description": null,
  "link": "https://trends.google.com/trending/rss?geo=US",
  "pubDate": "2026-11-09T01:20:00.000Z",
  "newsItems": [
    { "title": "Week 10 Fantasy Football Early Waiver Wire Pickups", "url": "https://sports.yahoo.com/...", "source": "Yahoo Sports" }
  ]
}
```

Related topics follow the same shape as related queries, with `relatedTopic` and `relatedTopicType` instead of `relatedQuery`.

`category` and `property` echo the "Category" and "Property" input fields on every row of the four comparison-based outputs (interest over time, interest by region, related queries, related topics), so rows from runs with different categories or properties can be told apart once exported or merged together. The trending-now feed has no category or property of its own and does not carry them.

| Field | On which rows | Meaning |
|---|---|---|
| `category` | All but trending now | The "Category" input echoed back (`0` = every category). |
| `property` | All but trending now | The "Property" input echoed back (`web`, `images`, `news`, `youtube` or `froogle`). |

Export the dataset as JSON, CSV or Excel, or read it through the Apify API.

### Why this one

- **Measured reliability, not a promise.** All 18 cloud runs so far succeeded with non-empty results, across varied terms, regions, time ranges, properties and the "trending now" mode (checked 13/11/2026). The Apify Store's current leader for this search fails 12% of its runs (checked the same day).
- **Built for the real failure mode.** Google rate-limits this API with HTTP 429, not a JavaScript challenge. The actor spaces out its own requests, retries with backoff and respects `Retry-After`, and only reaches for a proxy after a 429 survives several spaced retries — datacenter first, residential only as a last resort.
- **Four outputs in one actor.** Interest over time, interest by region, related queries, related topics and the trending-now feed, instead of a different tool per output.
- **No login, no browser.** Reads Google Trends' own internal API and public RSS feed directly, so runs are fast and cheap.

### Good to know

- Values are relative (0-100) to the highest point in the selected set, exactly like the Google Trends website; they are not absolute search volumes.
- When 2 to 5 items are compared in the same call, Google drops the related topics of all of them. The actor then asks for each item's related topics on its own, automatically, since related topics never share a scale anyway.
- Related queries and related topics are sometimes empty for a given term: Google itself does not always have that data, regardless of how the request is made.
- `isPartial` is `true` only for the most recent point of a still-accumulating time range, exactly as shown on the Google Trends website.
- Only aggregated, publicly published Google Trends data is collected: no personal data of any kind.

### Who uses it

- **SEO and content planning**: find what people search for around a topic before writing or launching.
- **Market and brand monitoring**: compare how your brand's interest moves against competitors, over time and by region.
- **Trend-driven alerts**: schedule "Trending now" daily per country and feed the output into a newsletter, a Slack channel or a dashboard.

### Pricing

Pay per result: **$2.00 per 1,000 rows**, plus $0.01 per run start with the default 4 GB of memory. For example, 500 rows cost about $1.01. You only pay for the rows you receive, and platform usage is included in that price. Store discounts apply automatically on paid Apify plans: up to 20% off every event on the higher tiers.

With **Compact output**, one result holds a whole series: 3 terms over 5 years of weekly interest is 3 results ($0.006) instead of 783 rows. Run with 512 MB of memory (plenty for this actor) and the start fee drops to $0.0025.

### Run it from your code

JavaScript:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('bibian/google-trends-scraper').call({
  searchTerms: ['ChatGPT', 'Claude AI'],
  geo: 'US',
  timeRange: 'today 12-m',
  interestOverTime: true,
  relatedQueries: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient(token="<APIFY_TOKEN>")
run = client.actor("bibian/google-trends-scraper").call(run_input={
    "searchTerms": ["ChatGPT", "Claude AI"],
    "geo": "US",
    "timeRange": "today 12-m",
    "interestOverTime": True,
    "relatedQueries": True,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### Drop-in replacement for pytrends

pytrends is archived and Google rate-limits it with HTTP 429. [pytrends-cloud](https://github.com/morvanvivien/pytrends-cloud) keeps its `TrendReq` API and its pandas DataFrames, and runs each call on this actor in compact mode:

```python
## from pytrends.request import TrendReq
from pytrends_cloud import TrendReq   # pip install pytrends-cloud

pytrends = TrendReq(hl="en-US", tz=360)   # reads APIFY_TOKEN
pytrends.build_payload(["python", "javascript", "rust"], timeframe="today 12-m")
df = pytrends.interest_over_time()
```

`interest_over_time`, `interest_by_region` (with `COUNTRY`, `REGION`, `CITY` and `DMA`), `related_queries`, `related_topics` and the trending searches work as in pytrends, for about $0.01 per call.

### Monitor new rows daily and connect your tools

1. **Schedule it.** Save a task for a search and schedule it as often as you need with Apify Schedules. Tick **Only new results** in the input and each run returns, and charges, only the rows that earlier runs of the same search did not deliver.
2. **Push the results where you work.** Add an Apify integration or a webhook to the task: Google Sheets, Slack, Make, Zapier, n8n or your own endpoint, triggered at the end of every run.
3. **Call it from your stack.** The API and the JavaScript and Python clients return the dataset as JSON, CSV or Excel.
4. **Let an AI agent use it.** Through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp), assistants such as Claude or ChatGPT can search the Store, read this page and run the actor as a tool.

### Frequently asked questions

**Do I need a Google account or a proxy?** No. The actor reads Google Trends' own public API and RSS feed directly; no login, no cookies you need to provide.

**Why does Google sometimes rate-limit this kind of tool?** Google Trends' internal API enforces a per-IP rate limit (HTTP 429), independent of any login. This actor spaces out its requests and backs off automatically, and only escalates to a proxy when a block survives several spaced retries.

**Can I compare more than 5 terms?** Yes. Terms beyond the first 5 are processed in separate batches of 5; each batch is on its own 0-100 scale (that is how Google's own comparison works too).

**Can I compare one term across several countries or regions instead?** Yes, set "Compare one term across regions" to 2-5 region codes (for example `["US-NY", "US-CA"]`) with exactly one entry in "Search terms". All regions then share the same 0-100 scale in one call, the same way Google's own "Compare across regions" works.

**Which formats can I export?** JSON, CSV, Excel, XML, HTML table or RSS, from the dataset page or through the API.

**Is it legal to scrape?** The actor collects publicly visible, aggregated Google Trends data and respects the robots.txt rules of the site. How you use the data is your responsibility: check Google's terms and the laws that apply to you, for example the GDPR.

**Need another output or a missing field?** Open an issue in the Issues tab and say what you need, with an example if you have one. Requests are read, and the most asked ones are built next.

**Something does not work?** Open an issue in the Issues tab. Every public actor is test-run daily and the broken ones are repaired.

**Did this save you time?** A short review on the Store page helps other people find the actor, and tells me what to improve next.

# Actor input Schema

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

1 to 25 terms to compare on Google Trends. Terms are compared 5 at a time (Google's own limit); more than 5 are split into separate batches that do not share a scale with each other.

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

Where to measure interest: empty for worldwide, a country code ("US", "FR"), or a sub-region ("US-CA", "GB-LON").

## `compareGeos` (type: `array`):

2 to 5 region codes to compare a single search term across, on the same 0-100 scale in one call (Google's own "compare across regions" mode). Requires exactly one entry in "Search terms" and is not compatible with "Interest by region". "Region (geo)" above is ignored when this is set.

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

A Google Trends time range. For a precise range, use "Custom time range" below.

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

A precise range instead of the menu above: two dates such as "2024-01-01 2024-06-30", or to the hour for ranges under a week, such as "2024-01-01T00 2024-01-07T23". Leave empty to use "Time range".

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

Google Trends category ID. 0 means every category.

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

Which Google property to measure search interest on.

## `hl` (type: `string`):

Language tag used for region and topic names in the response, such as "en-US" or "fr".

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

One row per date per search term, with the relative search-interest value (0-100) and whether the latest point is still partial.

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

One row per region per search term, with the relative search-interest value (0-100) in that region.

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

Level of detail for "Interest by region". Leave empty for Google's default (countries worldwide, sub-regions inside a country). COUNTRY needs a worldwide search, REGION and CITY work worldwide or inside a country, DMA (US metro areas) needs "US" or worldwide.

## `includeLowVolumeRegions` (type: `boolean`):

Also return regions with a low search volume, which Google hides by default.

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

The top and rising search queries related to each search term.

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

The top and rising topics related to each search term.

## `trendingNow` (type: `boolean`):

Also fetch today's trending searches for one country from Google's public trending-searches feed. Works on its own: it does not need "searchTerms".

## `trendingGeo` (type: `string`):

Two-letter country code for "Trending now" (for example "US", "FR", "GB", "IN", "JP").

## `compact` (type: `boolean`):

Return one dataset item per search term and data type, with the whole series nested inside (points, regions, top and rising lists), instead of one row per date, region or related entry. Same data, far fewer items, so it costs much less. Not compatible with "Only new results".

## `onlyNew` (type: `boolean`):

For scheduled runs. Skip the results that an earlier run of this same search already delivered, so each run returns, and charges, only what is new. The memory is kept in a key-value store of your account named "only-new-memory-bibian-" followed by the ID of this Actor.

## Actor input object example

```json
{
  "searchTerms": [
    "ChatGPT",
    "Claude AI",
    "Gemini AI"
  ],
  "geo": "US",
  "compareGeos": [],
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "hl": "en-US",
  "interestOverTime": true,
  "interestByRegion": true,
  "includeLowVolumeRegions": false,
  "relatedQueries": true,
  "relatedTopics": true,
  "trendingNow": true,
  "trendingGeo": "US",
  "compact": false,
  "onlyNew": false
}
```

# Actor output Schema

## `rows` (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 = {
    "searchTerms": [
        "ChatGPT",
        "Claude AI",
        "Gemini AI"
    ],
    "geo": "US",
    "timeRange": "today 12-m",
    "category": 0,
    "property": "web",
    "hl": "en-US",
    "interestByRegion": true,
    "relatedQueries": true,
    "relatedTopics": true,
    "trendingNow": true,
    "trendingGeo": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("bibian/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": [
        "ChatGPT",
        "Claude AI",
        "Gemini AI",
    ],
    "geo": "US",
    "timeRange": "today 12-m",
    "category": 0,
    "property": "web",
    "hl": "en-US",
    "interestByRegion": True,
    "relatedQueries": True,
    "relatedTopics": True,
    "trendingNow": True,
    "trendingGeo": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("bibian/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": [
    "ChatGPT",
    "Claude AI",
    "Gemini AI"
  ],
  "geo": "US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "hl": "en-US",
  "interestByRegion": true,
  "relatedQueries": true,
  "relatedTopics": true,
  "trendingNow": true,
  "trendingGeo": "US"
}' |
apify call bibian/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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