# Google Trends Scraper & API: Trending Now & Rising Queries (`manageable_gully/google-trends-scraper`) Actor

Google Trends scraper and API (pytrends alternative): interest over time, top and rising/breakout related queries and topics, Trending Now searches, interest by country/region/city, compare up to 5 keywords, many countries per run. $2 per 1,000 keyword reports.

- **URL**: https://apify.com/manageable_gully/google-trends-scraper.md
- **Developed by:** [WebIntel Tools](https://apify.com/manageable_gully) (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

from $2.00 / 1,000 keyword reports

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 & API: Interest Over Time, Rising Queries, Trending Now and Regions

A **Google Trends scraper and API** (a hosted **pytrends alternative**): get **Google Trends data in bulk** without a Google account or the closed Trends API: **interest over time**, **interest by country, region, metro or city**, **top and rising related queries** (including "Breakout" terms) and related topics. Compare **up to 5 keywords on one 0-100 scale**, run **many countries in one go**, and optionally pull today's **Trending Now** searches per country. Every report comes back as one clean JSON row, ready for spreadsheets, dashboards or AI agents.

### What you can use it for

- **SEO and content planning:** find **rising and breakout queries** around your keywords before they peak.
- **E-commerce and product research:** check seasonality and 5-year trends for product ideas (use `searchProperty: shopping` for Google Shopping interest).
- **Market comparison:** compare up to 5 brands or products on one 0-100 scale, in 50 countries in one run.
- **Local marketing:** see which states, regions, metro areas or cities search for a term most.
- **News and social teams:** Trending Now searches per country, with approximate traffic and news links.
- **AI agents and dashboards:** stable JSON for every report, ready for an LLM or a BI tool.

### How to use it

1. Add keywords under **Search terms** (each analysed alone) and/or **Comparison groups** like `chatgpt, gemini, claude`.
2. Add the **countries / regions** (`US`, `GB`, `US-CA` ...) or leave empty for Worldwide.
3. Pick a **time range** (`past-12-months`, `past-5-years`, `2024-01-01 2024-12-31` ...).
4. Click **Start**. Each term or group in each geo becomes one report row.

### What you get in each report

| Section | Details |
|---|---|
| **Interest over time** | Timeline of 0-100 values per term (hourly, daily, weekly or monthly depending on the range), `isPartial` flag for the current period, and the average per term |
| **Interest by region** | Countries (Worldwide), states/regions (a country), or metros/cities, sorted by interest, with geo codes |
| **Related queries** | Top and rising searches per term with values like `+250%` and `Breakout` flags, plus links to open them in Google Trends |
| **Related topics** | Top and rising topics with topic type and Knowledge Graph id (single-term searches) |
| **Trending Now** | Trending searches per country with approximate traffic (`2,000+`), publish time, picture and news links |

Filters work like trends.google.com: time range (past hour to since 2004, or custom dates), category, and search type (web, images, news, Google Shopping, YouTube).

### Input examples

Rising queries and 12-month trend for a few keywords in the US:

```json
{ "searchTerms": ["air fryer", "standing desk", "protein powder"], "geos": ["US"], "timeRange": "past-12-months" }
```

Compare five AI assistants in five markets on one scale:

```json
{ "comparisonGroups": ["chatgpt, gemini, claude, copilot, perplexity"], "geos": ["", "US", "GB", "DE", "IN"], "timeRange": "past-90-days" }
```

YouTube search interest by US metro area for a custom date range:

```json
{ "searchTerms": ["minecraft"], "geos": ["US"], "timeRange": "2025-01-01 2025-12-31", "searchProperty": "youtube", "regionResolution": "DMA" }
```

Today's trending searches in three countries:

```json
{ "trendingNowGeos": ["US", "GB", "IL"], "maxTrendingPerGeo": 20 }
```

### Output

One row per term (or comparison group) and geo (shortened example):

```json
{
  "type": "keywordReport",
  "searchTerms": ["chatgpt", "gemini", "claude"],
  "isComparison": true,
  "geo": "US",
  "timeRange": "today 3-m",
  "averages": {"chatgpt": 66, "gemini": 27, "claude": 18},
  "interestOverTime": [
    {"date": "2026-07-17T00:00:00Z", "formattedTime": "Jul 17, 2026", "values": {"chatgpt": 62, "gemini": 23, "claude": 21}, "isPartial": false}
  ],
  "interestByRegion": [
    {"geoCode": "US-MS", "geoName": "Mississippi", "values": {"chatgpt": 73, "gemini": 19, "claude": 8}}
  ],
  "relatedQueries": {
    "claude": {
      "top": [{"query": "claude ai", "value": 100, "formattedValue": "100", "isBreakout": false, "link": "https://trends.google.com/trends/explore?q=claude+ai&date=today+3-m&geo=US"}],
      "rising": [{"query": "claude code", "value": 5000, "formattedValue": "Breakout", "isBreakout": true, "link": "https://trends.google.com/trends/explore?q=claude+code&date=today+3-m&geo=US"}]
    }
  },
  "hasData": true,
  "trendsUrl": "https://trends.google.com/trends/explore?q=chatgpt%2Cgemini%2Cclaude&date=today%203-m&geo=US",
  "charged": true,
  "scrapedAt": "2026-10-17T09:05:11Z"
}
```

Trending Now rows:

```json
{ "type": "trendingNow", "geo": "US", "rank": 1, "title": "hurricane trudy", "approxTraffic": "1000+", "approxTrafficNumber": 1000,
  "publishedAt": "2026-10-17T08:30:00Z", "news": [{"title": "...", "url": "https://...", "source": "..."}] }
```

Values are illustrative. Export as JSON, CSV or Excel, or read them from the API.

### Why this one

- **Reliable:** fresh sessions, backoff on HTTP 429 and an automatic residential-proxy fallback. Incomplete reports are returned with an `errors` field and **not charged**.
- **Cheap and fast:** plain HTTP (no browser), 256 MB memory, about 1 second per report. A comparison of 5 terms is still **one** report.
- **Bulk by design:** every term and comparison group runs in every geo you list, in parallel.
- **Stable schema** with ISO dates and per-term value maps, easy for spreadsheets, SQL and LLM agents.

### Limits

- Google Trends values are relative (0-100), not absolute search volumes.
- Google allows at most 5 terms per comparison. Very rare terms may have no data (`hasData: false`, free).
- Related topics are shown by Google only for single terms and are sometimes empty.
- Logged-out public data only. Google's Terms of Service restrict automated access; use the data responsibly. This Actor is not affiliated with Google.

### Pricing

Pay per event, no monthly rent: **$0.002 per keyword report** (**$2.00 per 1,000**).

- **$0.0005 per Trending Now search**

| Example | Cost |
|---|---|
| 100 keywords in one country | $0.20 |
| 1,000 reports | $2.00 |
| A 5-brand comparison in 50 countries (50 reports) | $0.10 |
| Trending Now for 10 countries x 50 searches | $0.25 |

You can set a **maximum cost per run** in the run options; the Actor stops cleanly when it is reached. New to Apify? The free plan includes $5 of platform credit every month, so you can try this Actor at no cost.

### API, integrations and AI agents (MCP)

Run it from your own code with the [Apify API](https://docs.apify.com/api/v2) and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/manageable_gully~google-trends-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d @input.json
```

```python
from apify_client import ApifyClient
run = ApifyClient("<YOUR_APIFY_TOKEN>").actor("manageable_gully/google-trends-scraper").call(run_input={...})
```

- **No-code:** use the Apify app in **n8n, Make or Zapier** ("Run Actor", then "Get dataset items"), or send results to Google Sheets, Slack or a webhook.
- **AI agents (MCP):** add `https://mcp.apify.com?tools=manageable_gully/google-trends-scraper` to Claude, Cursor, VS Code or any MCP client and the agent can call this Actor as a tool.
- **Schedules:** run it hourly, daily or weekly from Apify Console.

### FAQ

**Is there an official Google Trends API?** Google offers a Trends API only to a small alpha group. This Actor reads the same public data that trends.google.com shows, without a Google account.

**Are the numbers search volumes?** No. Google Trends values are relative interest from 0 to 100 (100 = peak popularity for the selected terms, place and time). Terms in a comparison group share one scale.

**Why are related topics sometimes empty?** Google shows related topics only for single-term searches and omits them for low-volume terms. Related queries are usually available.

**What happens when Google rate-limits?** The Actor retries with fresh sessions and switches to residential proxies automatically. Reports that still fail come back with an `errors` field and are not charged.

**Do I pay for terms with no data?** No. Reports where Google has no data (`hasData: false`) are returned for transparency and not charged.

**Can AI agents use it?** Yes. It is available as a tool through the Apify MCP server (`https://mcp.apify.com?tools=manageable_gully/google-trends-scraper`) and the Apify API, and it returns structured JSON that agents can read directly.

### More tools from WebIntel Tools

- [SEO Audit & Domain Checker](https://apify.com/manageable_gully/website-health-audit): SEO, DNS, SSL and security-header audit for lists of domains
- [Lighthouse & PageSpeed Bulk Audit](https://apify.com/manageable_gully/lighthouse-bulk-audit): Lighthouse scores and Core Web Vitals for hundreds of URLs
- [RSS Feed Reader & Monitor](https://apify.com/manageable_gully/rss-feed-reader): read and monitor RSS, Atom and JSON feeds, only new items
- [Product Hunt Scraper](https://apify.com/manageable_gully/product-hunt-scraper): daily, weekly and monthly Product Hunt launches with websites

See [all WebIntel Tools Actors](https://apify.com/manageable_gully).

*Made by WebIntel Tools. This Actor was built and is maintained with AI assistance. Report issues on the Issues tab; they are monitored daily.*

# Actor input Schema

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

Keywords to analyse one by one, e.g. 'air fryer'. Each term x each geo = one keyword report.

## `comparisonGroups` (type: `array`):

Comma-separated terms compared on the same 0-100 scale, like the Compare box on trends.google.com, e.g. 'chatgpt, gemini, claude'. Each group x each geo = one keyword report.

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

Google Trends geo codes. Leave empty or use '' for Worldwide. Examples: 'US', 'GB', 'DE', 'US-CA' (state), 'US-NY-501' (metro). Every term/group runs for every geo.

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

Preset or custom range. Presets: past-hour, past-4-hours, past-day, past-7-days, past-30-days, past-90-days, past-12-months, past-5-years, since-2004 (also raw values like 'today 12-m'). Custom: '2024-01-01 2024-12-31'.

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

Google Trends category number, 0 = all categories (e.g. 18 = Shopping, 71 = Food & Drink, 958 = Jobs, 5 = Computers & Electronics).

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

Which Google search to measure.

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

Timeline of 0-100 values for each term.

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

Countries (worldwide), states/regions (country) or cities/metros (region) ranked by interest.

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

Top and rising related searches for each term, including 'Breakout' queries.

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

Top and rising related topics. Google only shows these for single-term searches and sometimes returns none.

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

Granularity of 'Interest by region'. auto = countries for Worldwide, regions for a country, cities for a region.

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

Also return regions with low search volume.

## `trendingNowGeos` (type: `array`):

Also return today's trending searches (with approximate traffic and news links) for these countries, e.g. 'US', 'GB'. Charged per trending search returned.

## `maxTrendingPerGeo` (type: `integer`):

1-100.

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

Language for region and topic names, e.g. 'en-US', 'de', 'he'.

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

Higher is faster but Google rate-limits sooner. 1-10.

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

Apify Proxy is used by default. If Google rate-limits the datacenter IPs, the Actor switches to residential automatically (you are not charged extra).

## `allowResidentialFallback` (type: `boolean`):

Keeps runs reliable when Google returns HTTP 429. No extra charge to you.

## Actor input object example

```json
{
  "searchTerms": [
    "air fryer"
  ],
  "comparisonGroups": [
    "chatgpt, gemini, claude"
  ],
  "geos": [
    "US"
  ],
  "timeRange": "past-12-months",
  "category": 0,
  "searchProperty": "web",
  "includeInterestOverTime": true,
  "includeInterestByRegion": true,
  "includeRelatedQueries": true,
  "includeRelatedTopics": true,
  "regionResolution": "auto",
  "includeLowVolumeRegions": false,
  "maxTrendingPerGeo": 50,
  "language": "en-US",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "allowResidentialFallback": true
}
```

# Actor output Schema

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

One item per keyword (or comparison group) x geo with interest over time, by region and related queries/topics; plus one item per Trending Now search.

## `summary` (type: `string`):

Run statistics and the effective input.

# 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": [
        "air fryer"
    ],
    "comparisonGroups": [
        "chatgpt, gemini, claude"
    ],
    "geos": [
        "US"
    ],
    "timeRange": "past-12-months",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("manageable_gully/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": ["air fryer"],
    "comparisonGroups": ["chatgpt, gemini, claude"],
    "geos": ["US"],
    "timeRange": "past-12-months",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("manageable_gully/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": [
    "air fryer"
  ],
  "comparisonGroups": [
    "chatgpt, gemini, claude"
  ],
  "geos": [
    "US"
  ],
  "timeRange": "past-12-months",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call manageable_gully/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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