# Google Trends Scraper - Trending Now by Country (`automia-admin/google-trends-scraper`) Actor

Get Google's trending searches for any country: search volume, percentage increase, categories, related queries and the time each trend started. Filter by category or minimum volume. No browser and no proxy, so runs finish in seconds. Export to JSON, CSV or Excel.

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

## Pricing

from $3.00 / 1,000 trends

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Get **every trending search on Google right now**, for any country, as clean structured data — with search volume, category, related queries and the exact time each trend started.

### What does Google Trends Trending Now Scraper do?

This Actor extracts the full **Trending Now** feed from [Google Trends](https://trends.google.com/trending): the searches that are spiking in a given country over the last 4 hours, 24 hours, 48 hours or 7 days. For each trend you get the query, its approximate **search volume**, the **percentage increase**, the **categories** it belongs to, the **related queries** people are searching alongside it, and the **timestamp** when it started trending.

It talks directly to the same endpoint the Google Trends web app uses, so there is **no headless browser and no proxy involved**. Runs finish in seconds, cost very little, and avoid the fragility of browser-based scrapers.

Run it on demand, schedule it every hour, call it from the API, or plug it into your own pipeline through any of the Apify integrations.

### Why use it?

- **Content and SEO** — publish while a topic is still rising instead of a day late.
- **Newsrooms** — see what an audience is searching for the moment a story breaks.
- **Marketing and social media** — find the trend behind a spike before your competitors do.
- **Market research** — track category-level attention across countries over time.
- **AI agents and automations** — a clean JSON feed of what the world is searching, ready to drop into a prompt or a database.

### How to use it

1. Click **Try for free**.
2. Set **Country** to the two-letter code you care about — `US`, `GB`, `BR`, `DE`, `ES`, `IN`, `AR`, and many more.
3. Pick a **Time window**: last 4 hours for breaking trends, last 7 days for the broader picture.
4. Optionally narrow things down with **Categories**, **Minimum search volume** or **Maximum results**.
5. Press **Start** and download the results as JSON, CSV, Excel or HTML.

To keep a live feed, open the **Schedules** tab and run it every hour — each run returns the trends as they stand at that moment.

### Input

Every field is optional except the country.

| Field | Type | Description |
| --- | --- | --- |
| `geo` | string | Two-letter country code. Default `US`. |
| `hours` | string | Time window: `4`, `24`, `48` or `168` (7 days). Default `24`. |
| `language` | string | Language code for the request, e.g. `en`, `es`, `pt`, `de`. Default `en`. |
| `categoryIds` | array | Keep only these categories. Empty means all. |
| `minSearchVolume` | integer | Drop trends below this approximate volume. |
| `maxItems` | integer | Cap the number of results. `0` means no limit. |
| `sortBy` | string | `volume`, `recency` or `relevance`. |
| `includeRelatedQueries` | boolean | Include related searches per trend. Default `true`. |

Example input:

```json
{
  "geo": "US",
  "hours": "24",
  "categoryIds": ["17"],
  "minSearchVolume": 20000,
  "maxItems": 50,
  "sortBy": "volume"
}
```

### Output

Each trend becomes one dataset item. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "query": "mariners vs dodgers",
  "normalizedQuery": "mariners vs dodgers",
  "geo": "US",
  "startedAt": "2026-07-29T01:10:00+00:00",
  "searchVolume": 100000,
  "increasePercentage": 1000,
  "categoryIds": [17],
  "categories": ["Sports"],
  "relatedQueries": ["mariners", "dodgers vs mariners", "la dodgers", "dodgers game"],
  "newsArticleCount": 29,
  "trendsUrl": "https://trends.google.com/trends/explore?q=mariners+vs+dodgers&geo=US",
  "searchUrl": "https://www.google.com/search?q=mariners%20vs%20dodgers",
  "scrapedAt": "2026-07-29T14:01:01+00:00"
}
```

#### Data fields

| Field | Description |
| --- | --- |
| `query` | The trending search term. |
| `normalizedQuery` | Google's canonical form of the term. |
| `geo` | Country the trend belongs to. |
| `startedAt` | UTC timestamp when the term started trending. |
| `searchVolume` | Approximate number of searches, as reported by Google. |
| `increasePercentage` | Reported percentage increase in searches. |
| `categoryIds` | Numeric category identifiers. |
| `categories` | Human-readable category names. |
| `relatedQueries` | Other searches rising alongside this one. |
| `newsArticleCount` | How many news articles Google associates with the trend. |
| `trendsUrl` | Link to the term on Google Trends. |
| `searchUrl` | Link to the Google results page for the term. |
| `scrapedAt` | UTC timestamp of the run. |

#### Available categories

Autos and Vehicles · Beauty and Fashion · Business and Finance · Entertainment · Food and Drink · Games · Health · Hobbies and Leisure · Jobs and Education · Law and Government · Other · Pets and Animals · Politics · Science · Shopping · Sports · Technology · Travel and Transportation · Climate

### How much does it cost to scrape Google Trends?

**$3.00 per 1,000 trends**, plus **$0.01** per run to start. Platform usage is included in that price — you are not billed separately for compute.

A run pulling 100 trends costs about **$0.31**. A daily schedule at that size lands near **$9 a month**.

Because the Actor makes one lightweight HTTP request instead of driving a browser, it finishes in about five seconds and runs on 256 MB of memory, so there is no hidden compute cost inflating your bill.

To spend less, use `maxItems` to cap results, `minSearchVolume` to keep only the significant movers, or `categoryIds` to narrow the feed to what you actually track — you are only charged for the trends you receive.

### Tips

- **Shorter windows are sharper.** `4` hours surfaces what is breaking right now; `168` gives you the week's landscape.
- **Volume is bucketed.** Google reports approximate figures such as 20,000, 100,000 or 200,000 — treat them as tiers, not exact counts.
- **Compare countries.** Run one schedule per market and see which trends cross borders.
- **Sort by recency** when you care about catching a trend early rather than a big one late.

### FAQ

**Does it need a proxy?** No. The Actor uses a single lightweight request that works without proxies, which is why it is fast and cheap to run.

**Which countries are supported?** Any country that appears on `trends.google.com/trending`. If a country code returns nothing, the run says so explicitly instead of failing silently.

**Does it return interest over time for a specific keyword?** Not yet — this Actor covers the Trending Now feed. Keyword time series is tracked as a separate feature.

**Is scraping Google Trends legal?** The Actor only reads publicly available data that Google publishes without a login, and it collects no personal data. As with any scraping, you remain responsible for how you use the data, including compliance with applicable law and the source's terms.

### Feedback and support

Found a bug, or need a field that is not there yet? Open an issue on the **Issues** tab of this Actor. Feature requests are welcome and get prioritised by how many people ask for them.

# Actor input Schema

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

Two-letter country code of the trends you want (for example US, GB, BR, DE, ES, IN, AR). Use the same code you see in the trends.google.com/trending URL.

## `hours` (type: `string`):

How far back to look. Shorter windows return what is breaking right now; longer windows return a broader picture.

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

Language code used for the request, for example en, es, pt, de, fr.

## `categoryIds` (type: `array`):

Keep only trends in these categories. Leave empty to get every category.

## `minSearchVolume` (type: `integer`):

Drop trends below this approximate search volume. Use it to keep only the big movers.

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

Maximum number of trends to return. Set 0 for no limit.

## `sortBy` (type: `string`):

Order of the returned trends.

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

Include the list of related search queries for each trend.

## Actor input object example

```json
{
  "geo": "US",
  "hours": "24",
  "language": "en",
  "categoryIds": [],
  "minSearchVolume": 0,
  "maxItems": 100,
  "sortBy": "volume",
  "includeRelatedQueries": true
}
```

# 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 = {
    "geo": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automia-admin/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 = { "geo": "US" }

# Run the Actor and wait for it to finish
run = client.actor("automia-admin/google-trends-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "geo": "US"
}' |
apify call automia-admin/google-trends-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automia-admin/google-trends-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/PrLDyguYqP1PBhQFv/builds/EaEHFImqyPUpDftV4/openapi.json