# Google Trends Trending Searches Scraper (`mangudai/google-trends-trending-searches`) Actor

Scrape Google Trends trending searches for any country from Google's public trending RSS feed. Each result has the trending search term, approximate traffic, related news articles with source and link, and a Google Trends Explore URL. No login, no API key, no captcha.

- **URL**: https://apify.com/mangudai/google-trends-trending-searches.md
- **Developed by:** [Mangudäi](https://apify.com/mangudai) (community)
- **Categories:** News, Developer tools, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 1,000 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/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Google Trends Trending Searches Scraper

Pull the trending searches Google is showing right now, for any country you pick. The actor reads Google's public trending RSS feed, so there is no login, no API key, and no captcha. Each run gives you a clean table: the trending search term, roughly how much traffic it is getting, when it started trending, and the news stories Google ties to it.

### What you get

One row per trending search. Fields:

- `query`: the trending search term
- `rank`: its position in the country feed, 1 is the hottest
- `geo` and `geoName`: the country code and its name
- `approxTraffic`: Google's traffic label, for example `2,000+`
- `approxTrafficNumber`: that label parsed to an integer you can sort and filter on
- `pubDate` and `pubDateRaw`: when the term started trending, ISO 8601 and the original string
- `pictureUrl` and `pictureSource`: the image Google shows for the trend and who it came from
- `exploreUrl`: a ready link to open the term in Google Trends Explore
- `newsCount`, `firstNewsTitle`, `firstNewsUrl`, `firstNewsSource`: a quick handle on the top related story
- `relatedNews`: the full list of related stories, each with title, url, source, and image
- `scrapedAt`: when the row was collected

### Input

- `geos`: list of two-letter country codes, for example `["US", "GB", "IN"]`. One feed is fetched per country.
- `hl`: interface language such as `en`, `fr`, `de`, `ja`. Default `en`.
- `maxItemsPerGeo`: cap per country. `0` keeps everything Google returns, usually 10 to 20.
- `includeRelatedNews`: set false to drop the `relatedNews` array and keep rows lean.
- `proxyConfiguration`: Apify Proxy settings. The datacenter default is enough for this feed.

#### Example

```json
{
  "geos": ["US", "GB", "IN"],
  "hl": "en",
  "maxItemsPerGeo": 0,
  "includeRelatedNews": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

### How scale works

Google's trending feed returns the current top terms for one country per request, roughly 10 to 20. To cover more ground, add more countries. The actor fetches each country in turn and writes every trending search to the dataset.

### Good uses

- Track breaking topics across markets for a newsroom or social team
- Feed a content calendar with what people are searching for today
- Watch a brand or event surface in the trending list
- Build a daily trending-topics digest by scheduling the actor

### Notes

Trending searches are a live snapshot, so results change through the day. Run the actor on a schedule if you want history. Traffic labels come from Google as rounded bands, not exact counts. Country codes follow ISO 3166-1 alpha-2.

# Actor input Schema

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

Two-letter country codes (ISO 3166-1 alpha-2), for example US, GB, IN, DE, BR, JP. One trending feed is fetched per country.

## `hl` (type: `string`):

Interface language code passed to Google (hl), for example en, fr, de, es, pt, ja.

## `maxItemsPerGeo` (type: `integer`):

Cap the number of trending searches kept per country. Leave at 0 to keep everything Google returns (about 10 to 20 per country).

## `includeRelatedNews` (type: `boolean`):

Add a relatedNews array to each row with the news stories Google attaches to the trend (title, url, source, image).

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

Route requests through Apify Proxy. The default datacenter proxy works well for the trending feed.

## Actor input object example

```json
{
  "geos": [
    "US",
    "GB",
    "IN"
  ],
  "hl": "en",
  "maxItemsPerGeo": 0,
  "includeRelatedNews": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `trendingSearches` (type: `string`):

Every trending search scraped in this run.

# 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 = {
    "geos": [
        "US",
        "GB",
        "IN"
    ],
    "hl": "en",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mangudai/google-trends-trending-searches").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 = {
    "geos": [
        "US",
        "GB",
        "IN",
    ],
    "hl": "en",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("mangudai/google-trends-trending-searches").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 '{
  "geos": [
    "US",
    "GB",
    "IN"
  ],
  "hl": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call mangudai/google-trends-trending-searches --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Trending Searches Scraper",
        "description": "Scrape Google Trends trending searches for any country from Google's public trending RSS feed. Each result has the trending search term, approximate traffic, related news articles with source and link, and a Google Trends Explore URL. No login, no API key, no captcha.",
        "version": "0.0",
        "x-build-id": "btoBwmxzA0f4yO5oU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mangudai~google-trends-trending-searches/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mangudai-google-trends-trending-searches",
                "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/mangudai~google-trends-trending-searches/runs": {
            "post": {
                "operationId": "runs-sync-mangudai-google-trends-trending-searches",
                "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/mangudai~google-trends-trending-searches/run-sync": {
            "post": {
                "operationId": "run-sync-mangudai-google-trends-trending-searches",
                "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": [
                    "geos"
                ],
                "properties": {
                    "geos": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter country codes (ISO 3166-1 alpha-2), for example US, GB, IN, DE, BR, JP. One trending feed is fetched per country.",
                        "default": [
                            "US",
                            "GB",
                            "IN"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "hl": {
                        "title": "Language",
                        "type": "string",
                        "description": "Interface language code passed to Google (hl), for example en, fr, de, es, pt, ja.",
                        "default": "en"
                    },
                    "maxItemsPerGeo": {
                        "title": "Max results per country",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of trending searches kept per country. Leave at 0 to keep everything Google returns (about 10 to 20 per country).",
                        "default": 0
                    },
                    "includeRelatedNews": {
                        "title": "Include related news articles",
                        "type": "boolean",
                        "description": "Add a relatedNews array to each row with the news stories Google attaches to the trend (title, url, source, image).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Route requests through Apify Proxy. The default datacenter proxy works well for the trending feed.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
