# Google Trends API Alternative: Data Scraper | $0.20 / 1K (`hridayrungta/google-trends-scraper`) Actor

Google Trends data and API alternative: interest over time, top and rising related queries, interest by region and Trending now by country. JSON, CSV or Excel, no login or API key. $0.20 per 1,000 rows plus a $0.0015 start fee.

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

## Pricing

from $0.20 / 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.

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: Google Trends data and API alternative

**Get Google Trends data as JSON, CSV or Excel without a browser, a login or an API key.** Interest over time, related queries (top and rising), interest by region and the Trending now list for any country. One row per keyword, **$0.20 per 1,000 rows** plus a $0.0015 start fee per run.

It calls the same public endpoints the Google Trends website calls, so you get what the site shows. It runs on 256 MB and uses no paid proxies, which is why the price can be this low.

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

- **Keyword research and SEO**: download interest over time for hundreds of keywords and find rising queries before they peak.
- **Google Trends download and monitoring**: schedule weekly pulls into Google Sheets or a database, instead of exporting CSVs by hand.
- **Product and market research**: see where a product is searched most (state, city, metro area) and compare brands head to head.
- **Content and trend spotting**: the Trending now list per country, with approximate volume and percent increase.
- **YouTube, news, image and Shopping search demand**: switch the search type.

### Google Trends API alternative

Google Trends has long had no public API; people scrape it or use unofficial libraries like pytrends. Google has described an official Trends API, but only as a limited alpha by application, as far as we know, so it is not something most teams can use today. This Actor needs no approval: you call it through the Apify API, a schedule or an integration and get structured rows back.

### What you get

#### Search terms mode

For every keyword, geo and time range, **one row** with the sections you switch on:

- **Interest over time**: Google's 0-100 score for every point on the chart (daily, weekly or monthly depending on the range), plus the average and the peak.
- **Related queries**: top 25 and rising 25. Rising entries show percent growth; entries Google labels "Breakout" have `isBreakout: true`.
- **Interest by region**: 0-100 score per country, state, city or metro area.
- **Compare mode**: up to 5 terms sent together, so scores are relative to each other like the compare view on trends.google.com. You still get one row per term.
- Filters: country or sub-region (US, GB, US-CA...), time range (past hour to 2004-present, or your own dates), category, search type (web, news, YouTube, images, Google Shopping).

#### Trending now mode

Today's trending searches for a country over the last 4 hours, 24 hours, 48 hours or 7 days: the search, approximate volume ("200K+"), percent increase, start time, whether it is still active, related searches and Google's category.

### Output example

A search row (lists shortened):

```json
{
  "type": "search",
  "searchTerm": "coffee",
  "comparedWith": null,
  "geo": "US",
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "averageInterest": 79.21,
  "peak": { "date": "2026-04-12T00:00:00.000Z", "value": 100 },
  "interestOverTime": [
    { "date": "2025-10-12T00:00:00.000Z", "formattedDate": "Oct 12 – 18, 2025", "value": 65, "isPartial": false }
  ],
  "relatedQueries": {
    "top": [{ "query": "coffee near me", "value": 100 }, { "query": "coffee shop", "value": 87 }],
    "rising": [{ "query": "top songs this week", "value": 5550, "isBreakout": true, "formattedValue": "Breakout" }]
  },
  "interestByRegion": [{ "geoCode": "US-WY", "geoName": "Wyoming", "value": 100 }],
  "exploreUrl": "https://trends.google.com/trends/explore?q=coffee&geo=US",
  "scrapedAt": "2026-10-14T05:06:00.283Z"
}
```

A trending row:

```json
{
  "type": "trending",
  "query": "galatasaray vs barcelona",
  "geo": "US",
  "windowHours": 24,
  "searchVolume": 200000,
  "searchVolumeLabel": "200K+",
  "increasePercent": 1000,
  "startedAt": "2026-10-13T16:50:00.000Z",
  "endedAt": null,
  "isActive": true,
  "relatedSearches": ["galatasaray vs fc barcelona standings", "lamine yamal"],
  "categories": ["Sports"],
  "exploreUrl": "https://trends.google.com/trends/explore?q=galatasaray%20vs%20barcelona&geo=US"
}
```

### Input

| Field | What it does |
|---|---|
| `mode` | `search` (default) or `trending`. |
| `searchTerms` | One keyword or topic per line. |
| `compareTerms` | Off: each term scored on its own. On: terms compared together in groups of up to 5. |
| `geos` | Country codes or sub-regions (US, GB, IN, US-CA). Empty means worldwide. Each geo is scraped separately. |
| `timeRange` / `customTimeRange` | Past hour to 2004-present, or `YYYY-MM-DD YYYY-MM-DD`. |
| `category` | Google Trends category ID (0 = all). |
| `property` | `web`, `news`, `youtube`, `images` or `shopping`. |
| `includeInterestOverTime`, `includeRelatedQueries`, `includeInterestByRegion` | Choose the sections in each row. |
| `regionResolution`, `includeLowSearchVolumeRegions` | Region detail: automatic, countries, states, cities or metro areas. |
| `trendingGeos`, `trendingWindowHours`, `trendingLimit` | Trending mode: countries, look-back window, rows per country. |
| `maxItems` | Hard cap on billed rows for the run (default 1,000). |

Example: related queries for one keyword in the US, last 3 months:

```json
{
  "searchTerms": ["ai agents"],
  "geos": ["US"],
  "timeRange": "today 3-m",
  "includeInterestOverTime": false,
  "includeRelatedQueries": true
}
```

### Pricing (pay per event)

Flat prices, no tiers.

| Event | Price |
|---|---|
| Actor started (once per run) | $0.0015 |
| Search term row | $0.0002 ($0.20 / 1,000) |
| Trending search row | $0.0001 ($0.10 / 1,000) |

Worked examples:

- 100 keywords in one country: $0.0015 + 100 x $0.0002 = **$0.0215**.
- The same 100 keywords in 5 countries: 500 rows = **$0.1015**.
- Top 25 US trending searches: $0.0015 + 25 x $0.0001 = **$0.004**.
- All trending searches for a country (a few hundred): roughly **$0.03 to $0.05**.

You are charged only for rows that are saved. A keyword Google has no data for returns no row and costs nothing. If Google throttles a request, the Actor retries on a fresh connection and re-queues the keyword once; a row still missing a section you asked for is dropped and not charged.

### How to get Google Trends data, step by step

1. Open the Actor and leave **What to scrape** on "Search terms".
2. Type your keywords, one per line, and pick a country and time range.
3. Choose the sections you want (defaults: interest over time and related queries).
4. Click **Start**. A few keywords take seconds.
5. Open the **Overview** table or export to JSON, CSV or Excel. For trending searches, switch the mode to "Trending now" and pick countries.

### Schedule it and connect it

Recurring pulls are the point of trend data. Use an [Apify Schedule](https://docs.apify.com/platform/schedules) to run daily, weekly or monthly, then send results to **Google Sheets**, **Make**, **n8n**, **Zapier** or your own endpoint with a **webhook**. The Apify API and MCP server let scripts and AI agents run it too.

### Known limits (please read)

- **No related topics.** Google only returns related topics to requests that carry a browser verification token, and this Actor does not try to fake one. Related *queries* work fully.
- **Google samples its data.** Two requests for the same term can differ by a point or two, and rising lists change by the hour. Numbers match what trends.google.com shows when you run.
- **Dates are in UTC.** Daily and weekly points are stamped at midnight UTC, so a chart in your local time zone can be offset by a day.
- **Scores are relative.** Google scales every chart to 0-100 for the term, geo and time range. Compare across terms only with `compareTerms` on.
- **Trending now** returns Google's list for a country in Google's order. `trendingLimit` keeps the top N. Volume is an approximate bucket ("200K+"), not an exact count.
- **Related queries** are capped at the top 25 and rising 25 that Google returns.
- Google throttles bursts with HTTP 429. The Actor pauses, retries on a fresh connection (up to `maxRetries`) and re-queues a keyword once. During heavy throttling a few keywords can still come back empty; they are logged and not charged, so check the run log if you see fewer rows than keywords.

### FAQ

**Do I need a Google account or API key?** No.

**Is there an official Google Trends API?** Not one you can simply sign up for, as far as we know (see above). This Actor reads the public site's own endpoints.

**What is the difference between this and pytrends?** pytrends is a Python library you run and maintain yourself and that gets throttled from your own IP. This Actor runs on Apify, retries on fresh connections and gives you a dataset, schedules and integrations.

**How do I download Google Trends data to CSV?** Run the Actor and export the dataset as CSV or Excel. Each row holds a keyword; the `interestOverTime` list holds the chart points.

**How many keywords can I run?** As many as you like. Use `maxItems` to cap spending.

**Can I compare more than 5 terms?** Compare mode sends groups of 5, and each group is scored separately, so scores are comparable only inside a group.

**Why did a keyword return nothing?** Google had too little search volume for it in that geo and time range.

**Can I use it with ChatGPT or Claude?** Yes, through the Apify API or the Apify MCP server.

### Legal

This Actor only collects data that Google Trends shows to any visitor without logging in. You are responsible for using the data in line with Google's terms and the laws that apply to you. No personal data is collected.

### Related Actors

- [Reddit Scraper](https://apify.com/hridayrungta/reddit-scraper) (own): posts and comments, to see what sits behind a rising query.
- [YouTube Scraper](https://apify.com/hridayrungta/youtube-scraper) (own): videos, channels and search results.
- [Google Maps Places Scraper](https://apify.com/hridayrungta/google-maps-places-scraper) (own): local business data.
- [Google Trends Scraper by apify](https://apify.com/apify/google-trends-scraper) (third party): the official Apify-maintained Trends Actor.
- [Google Trends Scraper by data_xplorer](https://apify.com/data_xplorer/google-trends-fast-scraper) (third party): another Trends Actor.

# Actor input Schema

## `mode` (type: `string`):

"Search terms": interest over time, related queries and interest by region for your keywords. "Trending now": what people in a country are searching for right now.

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

Search mode. One keyword or topic per line, e.g. "pizza" or "electric car".

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

Off: every term is scored 0-100 on its own. On: terms are sent to Google together (up to 5 per group) so the numbers are relative to each other, exactly like the compare view on trends.google.com. You still get one row per term.

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

Search mode. Country codes (US, GB, IN) or sub-regions (US-CA, GB-ENG). Leave empty for worldwide. Each geo is scraped separately.

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

Search mode. How far back to look.

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

Overrides the time range. Format: "YYYY-MM-DD YYYY-MM-DD", e.g. "2025-01-01 2025-06-30".

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

Google Trends category number. 0 = all categories. Examples: 71 Food & Drink, 5 Computers & Electronics, 7 Finance, 45 Health, 18 Shopping, 3 Arts & Entertainment.

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

Which Google search to measure.

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

A 0-100 score for every point on the chart, plus the average and the peak.

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

Top and rising related searches (rising ones flagged as breakout when Google marks them so).

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

Score per country / state / city inside the selected geo.

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

How fine the region breakdown is. "Automatic" lets Google pick (countries for worldwide, states for a country).

## `includeLowSearchVolumeRegions` (type: `boolean`):

Also return regions where Google has little data.

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

Interface language for related queries and labels, e.g. en-US, de-DE, es-ES.

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

Trending mode. Country codes such as US, GB, IN, DE, BR.

## `trendingWindowHours` (type: `string`):

Trending mode. Look back 4, 24, 48 or 168 hours (7 days).

## `trendingLimit` (type: `integer`):

Trending mode. Google returns up to several hundred trending searches per country; this keeps the top N (in Google's own order).

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

Hard cap on billed rows for the whole run.

## `maxRetries` (type: `integer`):

How many times a blocked or failed request is retried on a fresh connection.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "pizza",
    "coffee"
  ],
  "compareTerms": false,
  "geos": [
    "US"
  ],
  "timeRange": "today 12-m",
  "category": 0,
  "property": "web",
  "includeInterestOverTime": true,
  "includeRelatedQueries": true,
  "includeInterestByRegion": false,
  "regionResolution": "auto",
  "includeLowSearchVolumeRegions": false,
  "language": "en-US",
  "trendingGeos": [
    "US"
  ],
  "trendingWindowHours": "24",
  "trendingLimit": 25,
  "maxItems": 1000,
  "maxRetries": 4
}
```

# Actor output Schema

## `results` (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": [
        "pizza",
        "coffee"
    ],
    "geos": [
        "US"
    ],
    "trendingGeos": [
        "US"
    ],
    "trendingLimit": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("hridayrungta/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": [
        "pizza",
        "coffee",
    ],
    "geos": ["US"],
    "trendingGeos": ["US"],
    "trendingLimit": 25,
}

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

```

## MCP server setup

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