---
title: "Google Trends scraper"
description: "Scrape Google Trends trending searches as JSON: volume, growth, status, start time and related queries by country. One API request from Python, Node.js, CLI or MCP."
canonical: https://www.zenrows.com/scrape/google-trends
updated: 2026-10-20
---

# Google Trends scraper

The Zenrows Google Trends scraper turns a Trending now URL into structured JSON: each trending search with its search volume, growth, status, start time and related queries, plus the list's country and timeframe. Fetch in Adaptive Stealth Mode opens the page and Extract returns the fields. Run it from an API call, the CLI or an AI agent.

- Site: trends.google.com
- Returns: Trending searches, volumes, growth and related queries by country

## Run it: one Google Trends list in, JSON out

```json Input
{
  "url": "https://trends.google.com/trending?geo=US",
  "mode": "auto",
  "extract": "auto",
  "proxy_country": "us"
}
```

```json Output
{
  "trend_context": {
    "location": "United States",
    "timeframe": "Past 24 hours",
    "category": "All categories",
    "total_trends": 422
  },
  "trends": [
    {
      "title": "commanders vs 49ers",
      "search_volume": "500K+",
      "growth_percent": 1000,
      "status": "Active",
      "started": "22 hours ago",
      "related_queries": ["terry mclaurin", "49ers vs commanders"],
      "more_related_count": 16
    },
    {
      "title": "gluten free ritz cracker launch",
      "search_volume": "50K+",
      "growth_percent": 1000,
      "status": "Active",
      "started": "11 hours ago",
      "related_queries": ["ritz crackers gluten free", "gluten free ritz crackers"]
    }
  ]
}
```

Sample output for the Google Trends Trending now page (United States), built from a live request on Oct 20, 2026, trimmed to two of the trends listed. A field is returned when the page shows it.

## What data can you scrape from Google Trends?

The Trending now page ranks searches that are rising right now in one country, with a volume bracket, a growth figure and the queries Google groups into each trend. The scraper returns the list settings once and every trend as its own record.

| Field | What it holds | Example |
|---|---|---|
| `trend_context.location` | The country the list covers | `United States` |
| `trend_context.timeframe` | The window the trends started in | `Past 24 hours` |
| `trend_context.category` | The category filter applied to the list | `All categories` |
| `trend_context.total_trends` | How many trends the list holds in total | `422` |
| `trends[]` | One record per trending search, in the page's order | `{ "title": "49ers", … }` |
| `trends[].title` | The search that is trending | `kayem foods meat recall usda` |
| `trends[].search_volume` | Google's volume bracket for the trend | `500K+` |
| `trends[].growth_percent` | The increase over the usual search level, in percent | `1000` |
| `trends[].status` | Whether the trend is still active or has lasted and faded | `Active` |
| `trends[].started` | When the trend began, relative to the request | `2 hours ago` |
| `trends[].related_queries[]` | The query variants Google groups into the trend | `["49ers game", "commanders", "san francisco 49ers"]` |
| `trends[].more_related_count` | How many more related queries the trend groups beyond those shown | `59` |

## How to scrape Google Trends with Zenrows

1. **Create a free Zenrows account** and copy your API key from the dashboard.
2. **Build the Trending now URL for a country.** `https://trends.google.com/trending?geo=US` is the United States; swap the code for `GB`, `DE`, `IN` or any other country Google Trends covers.
3. **Pick the window.** Add `hours=4`, `hours=48` or `hours=168` for the past 4 hours, 48 hours or 7 days. The default is the past 24 hours. The category menu on the page adds its own value to the URL, so copy the URL after you filter.
4. **Send it with the default configuration**: Adaptive Stealth Mode to open the page, Extract to return the fields, and the country that matches `geo`. Read `parsed` from the response.
5. **Repeat on a schedule.** Trending searches turn over within hours, so a Batch job per country every hour or so gives you a time series of what rose and when.

```python Python
# pip install requests
import json
import requests

params = {
    "apikey": "YOUR_ZENROWS_API_KEY",
    "url": "https://trends.google.com/trending?geo=US",
    "mode": "auto",          # Adaptive Stealth Mode
    "extract": "auto",       # structured JSON
    "proxy_country": "us",   # match the geo in the URL
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()

data = response.json()["parsed"]
for trend in data["trends"]:
    print(trend["search_volume"], trend["growth_percent"], trend["title"])
print(json.dumps(data["trend_context"], indent=2))
```

```javascript Node.js
// Node 18+ (built-in fetch)
const params = new URLSearchParams({
  apikey: "YOUR_ZENROWS_API_KEY",
  url: "https://trends.google.com/trending?geo=US",
  mode: "auto",
  extract: "auto",
  proxy_country: "us",
});

const response = await fetch(`https://api.zenrows.com/v1/?${params}`, {
  signal: AbortSignal.timeout(180_000),
});
if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);

const { parsed } = await response.json();
for (const t of parsed.trends) console.log(t.title, t.search_volume, t.related_queries.join(", "));
```

```bash cURL
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Ftrends.google.com%2Ftrending%3Fgeo%3DUS&mode=auto&extract=auto&proxy_country=us"

# Only the trend, its volume and its related queries
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Ftrends.google.com%2Ftrending%3Fgeo%3DUS&mode=auto&extract=auto&proxy_country=us&extract_fields=trends.title%2Ctrends.search_volume%2Ctrends.related_queries"
```

```python Python SDK
# pip install zenrows
from zenrows import ZenRowsClient

client = ZenRowsClient("YOUR_ZENROWS_API_KEY")
response = client.get(
    "https://trends.google.com/trending?geo=US&hours=4",
    params={"mode": "auto", "extract": "auto", "proxy_country": "us"},
)
for trend in response.json()["parsed"]["trends"]:
    print(trend["started"], trend["status"], trend["title"])
```

## Input

The scraper takes one Google Trends URL per request. Country and timeframe are part of the URL; the options below control how Zenrows opens it. In a Batch job they apply to every task.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `url` | string | required | A Trending now URL: `https://trends.google.com/trending?geo=<country>`, with `hours` for the window and the category value from the page's filter |
| `mode` | string | `auto` | Adaptive Stealth Mode: starts with the lightest setup and adds rendering and protected-site handling only when the page needs them |
| `extract` | string | `auto` | Returns the trend list as JSON in `parsed`, next to the raw `html` |
| `extract_fields` | string | all fields | Comma-separated paths to keep, such as `trends.title,trends.search_volume,trends.growth_percent` |
| `proxy_country` | string | any | Two-letter country code. Match it to `geo` so times and labels follow that country |
| `wait_for` | string | none | A CSS selector to wait for before the page is read |
| `session_id` | integer | none | Keep the same session across several requests, up to 10 minutes |

```json Batch input
{
  "type": "regular",
  "status": "closed",
  "zenrows_params": {
    "mode": "auto",
    "extract": "auto"
  },
  "tasks": [
    { "url": "https://trends.google.com/trending?geo=US", "external_id": "us-24h", "zenrows_params": { "proxy_country": "us" } },
    { "url": "https://trends.google.com/trending?geo=GB", "external_id": "gb-24h", "zenrows_params": { "proxy_country": "gb" } },
    { "url": "https://trends.google.com/trending?geo=US&hours=168", "external_id": "us-7d", "zenrows_params": { "proxy_country": "us" } }
  ]
}
```

## Output

Every response is JSON with two keys: `html`, the page as Google Trends served it, and `parsed`, the structured list. The sample is trimmed to three trends of a real United States list.

```json Trending now
{
  "trend_context": {
    "location": "United States",
    "timeframe": "Past 24 hours",
    "category": "All categories",
    "total_trends": 422
  },
  "trends": [
    {
      "title": "49ers",
      "search_volume": "500K+",
      "growth_percent": 1000,
      "status": "Active",
      "started": "2 hours ago",
      "related_queries": ["49ers game", "commanders", "san francisco 49ers"],
      "more_related_count": 59
    },
    {
      "title": "valkyries",
      "search_volume": "20K+",
      "growth_percent": 900,
      "status": "Active",
      "started": "1 hour ago",
      "related_queries": ["valkyries vs dream", "valkyries game"],
      "more_related_count": 12
    },
    {
      "title": "horario de invierno",
      "search_volume": "20K+",
      "growth_percent": 500,
      "status": "Active",
      "started": "15 hours ago",
      "related_queries": []
    }
  ]
}
```

Volumes are Google's brackets (`20K+`, `500K+`), and growth is a percentage over the usual level for that search, so both are relative signals. Store them with the time of your request, and the start time becomes a timestamp. Need a spreadsheet? Load `trends` into pandas with `pd.json_normalize(...)` and write CSV. Need the page for an LLM? Ask for Markdown instead of JSON.

## Scrape Google Trends from your coding agent

Claude Code, Cursor, Codex and any MCP client can check what is trending in a country from a prompt.

The agent sends the same Fetch and Extract request a developer would, so it works from the live list instead of what it remembers. Connect the Zenrows MCP server once, or install the CLI and let the agent call it in the terminal.

```bash Connect the MCP server (Claude Code)
claude mcp add zenrows -e ZENROWS_API_KEY=YOUR_ZENROWS_API_KEY -- npx -y @zenrows/mcp
```

```json MCP config (Cursor, Claude Desktop, Windsurf)
{
  "mcpServers": {
    "zenrows": {
      "command": "npx",
      "args": ["-y", "@zenrows/mcp"],
      "env": { "ZENROWS_API_KEY": "YOUR_ZENROWS_API_KEY" }
    }
  }
}
```

```bash Or run the CLI
npx -y @zenrows/cli init
zenrows extract "https://trends.google.com/trending?geo=US" --proxy-country us
```

```text Then ask your agent
Use Zenrows to get the Google Trends trending searches for the US and
the UK over the past 4 hours. List the ones at 100K+ searches with their
related queries, and tell me which topics trend in both countries.
```

## Scrape Google Trends at scale with Batch and Crawl

**Batch** runs one Trending now URL per country and timeframe as a single job, each with its own country and an ID like `us-24h`. Schedule it every hour and you get a history of when each search started trending, how big it got and when it faded, across every market you track.

**Crawl** follows links from a start page and returns every page it reaches on trends.google.com, keeping the links that match your patterns. On Google Trends you usually know your URLs already (one per country and window), so Batch carries most jobs. Crawl helps when you want the pages as Markdown for an LLM: start on the Trends home page and keep links that contain `/trending`.

```bash Batch (cURL)
curl -X POST "https://async.api.zenrows.com/v1/jobs" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "regular",
    "status": "closed",
    "zenrows_params": { "mode": "auto", "extract": "auto" },
    "tasks": [
      { "url": "https://trends.google.com/trending?geo=US", "external_id": "us-24h", "zenrows_params": { "proxy_country": "us" } },
      { "url": "https://trends.google.com/trending?geo=GB", "external_id": "gb-24h", "zenrows_params": { "proxy_country": "gb" } }
    ]
  }'

# Read the results when the job finishes
curl "https://async.api.zenrows.com/v1/jobs/JOB_ID/results?status=successful" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY"
```

```bash Batch (CLI)
# countries.jsonl: one {"url": "https://trends.google.com/trending?geo=..", "external_id": "...", "proxy_country": "..", "extract": "auto"} per line
zenrows batch create countries.jsonl --wait
zenrows batch results <job-id> --out google-trends.jsonl
```

```bash Crawl (cURL)
curl -X POST "https://api.zenrows.com/v1/crawls" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://trends.google.com/home",
    "depth": 1,
    "max_pages": 50,
    "output_format": "markdown",
    "include_patterns": ["/trending"]
  }'
```

**Scheduled jobs** run the same Batch job on a timetable, on Zenrows' side: every few hours, once a day, at set times on chosen days, or once at a future date. Each run keeps its own results, a webhook can tell your app when a run finishes, and you can pause or resume the schedule at any time, with no cron server to keep alive.

```bash Scheduled job (cURL)
# Runs every day on Zenrows' side; each run keeps its own results
curl -X POST "https://async.api.zenrows.com/v1/jobs" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "type": "scheduled",
      "status": "closed",
      "schedule": {
        "rate": {
          "every": 1,
          "unit": "day"
        }
      },
      "zenrows_params": {
        "mode": "auto",
        "extract": "auto",
        "proxy_country": "us"
      },
      "tasks": [
        {
          "url": "https://trends.google.com/trending?geo=US",
          "external_id": "google-trends"
        }
      ]
    }'

# Or at set times: "schedule": { "calendar": { "times_of_day": ["09:00"],
#   "cadence": { "weekly": { "days": ["mon", "thu"] } } }, "timezone": "Europe/Madrid" }
```

## What teams do with Google Trends data

| Use case | Data they pull | Who runs it |
|---|---|---|
| Newsjacking and content planning | Searches rising in the last 4 hours, with volume and related queries | Editorial, social and content teams |
| Keyword discovery | Related queries grouped under each trend, fed into keyword research | SEO teams and agencies |
| Demand signals for retail | Product and brand searches that start trending, by country | Ecommerce, merchandising and category teams |
| Market and consumer research | Trend history per country: what rose, how big and for how long | Analysts and research agencies |
| Trading and risk signals | Company names, tickers and events trending in search, timestamped | Quant and alternative data teams |
| Grounding AI agents | The live trending list, so an agent can say what people search for today | AI and data teams |

## Tips for scraping Google Trends

- **Use country codes in `geo`.** `geo=US`, `geo=GB`, `geo=IN`. Request from the same country so times and labels follow that market.
- **Pick the window with `hours`.** `hours=4` catches searches as they break; `hours=168` gives the week's bigger stories. Leave it out for the past 24 hours.
- **Turn relative times into timestamps at once.** "22 hours ago" is relative to your request. Subtract it from the request time and store the result.
- **Keep `related_queries` with each trend.** Google groups variants and misspellings under one trend, and the related queries are often the better keywords to target.
- **Read volumes as brackets.** `500K+` is a lower bound. Rank trends by bracket and growth together instead of treating either as an exact count.
- **Snapshot often.** A trend can start and fade within a day. Hourly runs per country show the full arc; one daily run misses most of it.

## Frequently asked questions

### Is it legal to scrape Google Trends?

Google Trends publishes aggregated search data that every visitor can see, and collecting it is common practice for content planning and research. Trending searches can name public figures and private people, and personal data falls under laws such as the GDPR and the CCPA, so keep only what you have a legitimate reason to use. Check Google's terms for your use case and ask your lawyer if you are unsure.

### Is there an official Google Trends API?

Google announced a Google Trends API in 2025 as an alpha with access limited to approved testers. Most teams cannot get access, so they read the public Google Trends pages, which is what this scraper does for the Trending now list.

### What Google Trends pages can I scrape?

The Trending now page ( trends.google.com/trending ) for any country Google Trends covers, with the past 4 hours, 24 hours, 48 hours or 7 days, and with or without a category filter. Each request returns the trends on that list with their volume, growth, status, start time and related queries.

### How do I scrape Google Trends for a specific country?

Put the country code in geo and request from the same country. To cover many markets, send one URL per country in a single Batch job, each task with its own country.

### How do I scrape Google Trends with Python?

Send a GET request to https://api.zenrows.com/v1/ with your API key, the Trending now URL, Adaptive Stealth Mode and Extract, as in the Python example above. parsed["trends"] is a list of dictionaries, one per trending search. The zenrows package on PyPI wraps the same request.

### How often should I scrape trending searches?

As often as the window you care about. For breaking searches, run the past 4 hours list every hour or so per country. For weekly reporting, one run of the 7 day list per country is enough.

### Can AI agents scrape Google Trends with Zenrows?

Yes. Connect the Zenrows MCP server to Claude, Cursor, Codex or any MCP client, or give your agent the Zenrows CLI. Ask what is trending in a country and the agent calls Fetch and Extract, then answers from the live list.

### Can I scrape Google Trends on a schedule?

Yes. Create a scheduled Batch job with your Google Trends URLs and the same settings as a single request, and Zenrows runs it on its side: every few hours, once a day, at set times on chosen days, or once at a future date. Each run keeps its own results, a webhook can notify your app when a run finishes, and the schedule can be paused or resumed at any time.

### Which integrations work with the Google Trends scraper?

Zenrows works with n8n, Make, Zapier, Clay, Dify, LangChain, LlamaIndex, CrewAI and Mastra, plus the Python, Node.js and Go SDKs and any HTTP client. An hourly workflow can post new trends in your categories to Slack or log them to a sheet. See the integrations page for the full list.

### What format does the data come in?

JSON by default, with the trend list in parsed and the original page in html . You can also ask for the page as Markdown or plain text for an LLM to read.

All scrapers: https://www.zenrows.com/scrape. Start free: https://app.zenrows.com/register. Docs: https://docs.zenrows.com