# Google Trends Trending Now (`data_xplorer/google-trends-trending-now`) Actor

🔥 Scrape Google Trends trending searches in real-time. Get search volume, categories & related terms for 45+ countries. Each trend = 1 result. Fast, no browser needed. Perfect for SEO, market research & content strategy.

- **URL**: https://apify.com/data\_xplorer/google-trends-trending-now.md
- **Developed by:** [Data Xplorer](https://apify.com/data_xplorer) (community)
- **Categories:** SEO tools, News, Automation
- **Stats:** 36 total users, 17 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### 🔥 What is Google Trends Trending Searches Scraper?

**Google Trends Trending Searches Scraper** extracts real-time trending search queries directly from [Google Trends](https://trends.google.com/trending). Each trending query is returned as an **individual dataset item**, making it perfect for pay-per-result workflows, automated pipelines, and large-scale trend monitoring.

Unlike other Google Trends scrapers that bundle all results into a single output, this Actor gives you **one row per trending search** — with search volume, category, related terms, and a direct Google Trends link. Ready to export as JSON, CSV, Excel, or XML.

![trends scraper](https://i.ibb.co/20Dy2KP0/Phoenix-10-I-want-a-banner-in-the-atmosphere-of-GTA-Vice-City-0.jpg)

### ✨ Why use this Google Trends Trending Searches Scraper?

- 🚀 **Blazing fast** — No browser needed. Direct API extraction returns hundreds of results in seconds
- 📊 **One result per trending query** — Perfect for analytics pipelines, and spreadsheet workflows
- 🌍 **45+ countries supported** — From the US and UK to South Korea, Indonesia, and Saudi Arabia
- 🏷️ **19 category filters** — Sports, Technology, Entertainment, Health, Politics, and more
- ⏱️ **Flexible timeframes** — Past 4 hours, 24 hours, 48 hours, or 7 days
- 🔗 **Direct Google Trends URL** — Each result includes a clickable link to explore the trend further
- 🛡️ **Anti-blocking built-in** — Smart proxy rotation ensures reliable data collection
- 📦 **Apify platform power** — API access, scheduling, webhooks, and 30+ integrations included

### 📋 What data can you extract from Google Trends?

| Field | Description |
|---|---|
| 🏅 `rank` | Position in the trending list |
| 🔍 `term` | The trending search query |
| 🏷️ `category` | Category (e.g. Sports, Technology, Entertainment) |
| 📈 `trend_volume` | Formatted search volume (e.g. "500K+", "1M+") |
| 🔢 `trend_volume_raw` | Raw numeric volume for sorting & analysis |
| 🔗 `related_terms` | Associated search queries |
| 🌍 `geo` | Country code |
| 🗣️ `language` | Language used for the request |
| ⏱️ `timeframe_hours` | Time window (4, 24, 48, or 168 hours) |
| 🔗 `trends_url` | Direct link to Google Trends for this query |
| 🕐 `scraped_at` | Timestamp of extraction |

### 🚀 How to scrape Google Trends trending searches

1. [Create](https://console.apify.com/sign-up) a free Apify account
2. Open **Google Trends Trending Searches Scraper**
3. Select your **country** (e.g. United States, France, Japan)
4. Choose a **time period** (Past 4h, 24h, 48h, or 7 days)
5. Optionally filter by **categories** (Sports, Tech, Entertainment…)
6. Click **Start** and wait a few seconds
7. Download your data in **JSON, CSV, Excel, XML, or HTML**

That's it — no coding required. Each trending query appears as its own row in the dataset.

### ⬇️ Input example



```json
{
    "country": "US",
    "timeframe": "24",
    "categories": [],
    "maxItems": null,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `country` | string | `"US"` | Country code (US, FR, GB, DE, JP, etc.) |
| `timeframe` | string | `"24"` | Time window: `4`, `24`, `48`, or `168` hours |
| `categories` | array | `[]` | Filter by category IDs (empty = all categories) |
| `maxItems` | integer | unlimited | Max results to return. Leave empty for all available |
| `proxyConfiguration` | object | Apify Auto | Proxy settings |

#### Available categories

| ID | Category | ID | Category |
|---|---|---|---|
| 1 | Autos & Vehicles | 11 | Other |
| 2 | Beauty & Fashion | 13 | Pets & Animals |
| 3 | Business & Finance | 14 | Politics |
| 4 | Entertainment | 15 | Science |
| 5 | Food & Drink | 16 | Shopping |
| 6 | Games | 17 | Sports |
| 7 | Health | 18 | Technology |
| 8 | Hobbies & Leisure | 19 | Travel & Transportation |
| 9 | Jobs & Education | 20 | Climate |
| 10 | Law & Government | | |

### ⬆️ Output example

Each trending search is an individual item in the dataset:

```json
{
    "rank": 1,
    "term": "Champions League",
    "category": "Sports",
    "trend_volume": "500K+",
    "trend_volume_raw": 500000,
    "related_terms": [
        "Champions League results",
        "Champions League draw",
        "UEFA Champions League"
    ],
    "geo": "US",
    "language": "en-US",
    "timeframe_hours": "24",
    "trends_url": "https://trends.google.com/trends/explore?geo=US&q=Champions+League&hl=en-US",
    "scraped_at": "2026-03-05 12:30:00"
}
```

### 💡 Use cases for Google Trends trending data

🔍 **SEO & Content Strategy** — Discover what people are searching for right now and create timely content that ranks

📊 **Market Research** — Track emerging trends across categories and countries to identify business opportunities

📰 **News & Media Monitoring** — Stay ahead of breaking news by monitoring trending searches in real-time

📈 **Social Media Marketing** — Align your social content with what's trending to maximize engagement

🤖 **AI & Data Pipelines** — Feed trending data into your ML models, chatbots, or automated reporting systems

🌍 **Multi-market Intelligence** — Compare trending topics across 45+ countries for global insights

### 🔗 Integrations

Connect this scraper to your favorite tools and automate your trend monitoring:

- ⚡ **Make (Integromat)** — [Apify + Make Integration](https://docs.apify.com/platform/integrations/make)
- 🔄 **N8N** — [Apify + N8N Integration](https://docs.apify.com/platform/integrations/n8n)
- 📊 **Google Sheets** — Export trending searches directly to a spreadsheet
- 🤖 **MCP (AI Agents)** — [Apify MCP Server](https://docs.apify.com/platform/integrations/mcp)
- 🔧 **Zapier, Slack, Airbyte, GitHub** — [See all integrations](https://docs.apify.com/integrations)

You can also use the [Apify API](api) to run this Actor programmatically from Python, Node.js, or any HTTP client. Schedule runs hourly, daily, or weekly to automatically track trending changes over time.

### 💡 Pro tips

- **Leave `maxItems` empty** to get all available trending searches (typically 200-500+ items per country)
- **Use category filters** to focus on your niche — e.g. only Technology + Science trends
- **Schedule hourly runs** to build a historical database of trending searches for trend analysis
- **Combine with Google Sheets** integration to maintain a live trending dashboard
- **Use the `trend_volume_raw` field** for sorting and filtering in your data pipeline — it's the raw numeric value
- **Compare countries**: run the Actor multiple times with different `country` values to spot global vs. local trends

### ❓ FAQ

#### Is there a Google Trends API for trending searches?

Google does not offer an official public API for Google Trends data. This Actor serves as a **reliable API alternative** that extracts trending searches directly from Google Trends' internal data endpoints. Use it via the [Apify API](api) for full programmatic access.

#### How often is the trending data updated?

Google Trends updates trending searches continuously. You can run this Actor as frequently as you need. For real-time monitoring, schedule it every hour or every 4 hours.

#### Can I use this data with Python?

Yes! Use the `apify-client` [PyPI package](api/client/python) to run this Actor and retrieve results programmatically:

#### How many results can I get per run?

It depends on the country and timeframe. Typically, Google Trends returns **200 to 500+ trending searches** per country. Use `maxItems` to limit the results if needed, or leave it empty to get everything available.

### 🤝 Support

Need help or have a feature request? We'd love to hear from you!

- 🐛 **Found a bug?Feature request?** → Open an issue in the [Issues tab](https://console.apify.com/actors/ZBIglG4wEYlaG2xPi/issues)

# Actor input Schema

## `country` (type: `string`):

Select a country for trending searches

## `timeframe` (type: `string`):

Select a time period for trending searches

## `categories` (type: `array`):

Select one or more categories to filter trending searches (leave empty for all categories)

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

Maximum number of trending search results to return. Leave empty for unlimited (all available results).

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

Select proxies to be used by your Actor

## Actor input object example

```json
{
  "country": "US",
  "timeframe": "24",
  "categories": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Link to the full dataset of trending searches.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_xplorer/google-trends-trending-now").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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("data_xplorer/google-trends-trending-now").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 '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_xplorer/google-trends-trending-now --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Trending Now",
        "description": "🔥 Scrape Google Trends trending searches in real-time. Get search volume, categories & related terms for 45+ countries. Each trend = 1 result. Fast, no browser needed. Perfect for SEO, market research & content strategy.",
        "version": "0.0",
        "x-build-id": "XVT52z7P0xoj6fFNW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_xplorer~google-trends-trending-now/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_xplorer-google-trends-trending-now",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/data_xplorer~google-trends-trending-now/runs": {
            "post": {
                "operationId": "runs-sync-data_xplorer-google-trends-trending-now",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/data_xplorer~google-trends-trending-now/run-sync": {
            "post": {
                "operationId": "run-sync-data_xplorer-google-trends-trending-now",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "country"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "FR",
                            "GB",
                            "DE",
                            "IT",
                            "ES",
                            "BR",
                            "AU",
                            "IN",
                            "CA",
                            "RU",
                            "JP",
                            "NL",
                            "PL",
                            "TR",
                            "BE",
                            "SE",
                            "CH",
                            "AT",
                            "MX",
                            "DK",
                            "NO",
                            "FI",
                            "NZ",
                            "SG",
                            "ZA",
                            "IE",
                            "HK",
                            "PT",
                            "GR",
                            "IL",
                            "AR",
                            "CL",
                            "CO",
                            "HU",
                            "MY",
                            "PH",
                            "RO",
                            "SA",
                            "TH",
                            "AE",
                            "VN",
                            "KR",
                            "TW",
                            "ID"
                        ],
                        "type": "string",
                        "description": "Select a country for trending searches",
                        "default": "US"
                    },
                    "timeframe": {
                        "title": "Time Period",
                        "enum": [
                            "4",
                            "24",
                            "48",
                            "168"
                        ],
                        "type": "string",
                        "description": "Select a time period for trending searches",
                        "default": "24"
                    },
                    "categories": {
                        "title": "Categories Filter (Optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more categories to filter trending searches (leave empty for all categories)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6",
                                "7",
                                "8",
                                "9",
                                "10",
                                "11",
                                "13",
                                "14",
                                "15",
                                "16",
                                "17",
                                "18",
                                "19",
                                "20"
                            ],
                            "enumTitles": [
                                "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"
                            ]
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max Trending Items (Optional)",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of trending search results to return. Leave empty for unlimited (all available results)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your Actor",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
