# Google Trending Searches — No Rate Limits! (`dr_ben/google-trending-searches`) Actor

Trending Google searches for 49 countries with traffic estimates and the news stories behind each trend. Built on Google's public RSS feed, so no proxies and no 429 errors — every run returns data. Trending-now only, not interest-over-time.

- **URL**: https://apify.com/dr\_ben/google-trending-searches.md
- **Developed by:** [Benedikt](https://apify.com/dr_ben) (community)
- **Categories:** News, SEO tools, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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 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.

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 Trending Searches — the one that doesn't rate-limit

Get the searches trending on Google right now, in any of 49 countries, with
Google's own traffic estimate and the news stories driving each trend.

**Why this Actor exists:** most Google Trends Actors are built on Google's
`explore` and `widgetdata` endpoints — the ones behind the interest-over-time
charts. Those endpoints return **HTTP 429 to datacenter IPs**, which is where
every Apify Actor runs. Measured on 2026-07-22: four attempts over 44 seconds
from a freshly cookie-primed session, all 429. That is why Trends Actors on this
Store carry 1.5 to 3.3 star ratings, and why runs come back empty.

This Actor uses Google's public trending RSS feed instead. No token handshake,
no cookie priming, no proxy, no rate limit observed across 12 countries tested.
It returns less than the others promise, and it returns it every time.

### What you get

One row per trending search:

- the search term, and its rank in that country
- Google's traffic estimate, both raw (`"200+"`) and as a sortable number
- when it started trending
- every news story Google links to the trend — title, URL, publisher
- a thumbnail and its credit
- the exact feed URL the row came from

### What this Actor does NOT do

**It does not return interest-over-time**, the 0–100 popularity curve for a
keyword you choose. That is the `widgetdata` endpoint described above, and it
cannot be served reliably from Apify without residential proxies. If you need
keyword history, this is the wrong Actor and you should not buy it.

This one answers "what is trending right now, where, and why" — for newsrooms,
social and content teams, trend monitoring, and AI agents that need a live
read on public attention.

### Input

```json
{
  "geos": ["US", "AU", "GB"]
}
````

Each country returns its current top 10, so three countries returns 30 results.
Leave it as `["US"]` for a single country.

Supported: AR AT AU BE BR CA CH CL CO CZ DE DK EG ES FI FR GB GR HK HU ID IE IL
IN IT JP KE KR MX MY NG NL NO NZ PH PL PT RO RU SA SE SG TH TR TW UA US VN ZA.

An unrecognised code fails the run immediately rather than after the fetch —
Google answers an unknown country with an empty `200`, which would otherwise
look like a successful run that returned nothing.

### Output

Captured from a real run, 2026-07-22:

```json
{
  "geo": "US",
  "rank": 1,
  "query": "nottm forest vs blackburn rovers",
  "approx_traffic": "200+",
  "approx_traffic_min": 200,
  "started_at": "Wed, 22 Jul 2026 02:40:00 -0700",
  "picture": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTmlzigFLxgYOjaFmIQGM1kyvaa7SsZTC29Ydo10X7zJI9pVdLeeMezX5n4CoA",
  "picture_source": "Lancashire Telegraph",
  "news_item_count": 3,
  "news": [
    {
      "title": "Nottingham Forest view on Blackburn Rovers friendly and clear marker awaiting",
      "url": "https://www.lancashiretelegraph.co.uk/sport/26297524.nottingham-forest-view-blackburn-rovers-friendly/",
      "source": "Lancashire Telegraph",
      "snippet": null
    }
  ],
  "source_url": "https://trends.google.com/trending/rss?geo=US"
}
```

`approx_traffic` is Google's published estimate and is a floor, not a
measurement — `"200+"` means at least 200. `approx_traffic_min` is the same
value as an integer so you can sort and filter on it; it does not add precision
Google did not give.

### Notes on the data

- Google publishes exactly 10 trending searches per country. That is the feed's
  limit, not a setting.
- `snippet` is usually `null` — Google leaves it empty in the feed. It is kept
  in the shape so the schema is stable rather than dropped.
- Trends move fast. Schedule the Actor if you want a history; each run is a
  snapshot of that moment.

### Reliability

The test suite includes a live check that the feed still returns 10 rows for
US, GB and AU. If Google ever starts throttling this feed the way it throttles
`widgetdata`, that check fails and the Actor gets fixed rather than quietly
returning empty runs.

# Actor input Schema

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

Two-letter country codes, e.g. US, GB, AU, DE, IN. Each country returns its current top 10 trending searches, so 3 countries returns 30 results.

## Actor input object example

```json
{
  "geos": [
    "US"
  ]
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dr_ben/google-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"] }

# Run the Actor and wait for it to finish
run = client.actor("dr_ben/google-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"
  ]
}' |
apify call dr_ben/google-trending-searches --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trending Searches — No Rate Limits!",
        "description": "Trending Google searches for 49 countries with traffic estimates and the news stories behind each trend. Built on Google's public RSS feed, so no proxies and no 429 errors — every run returns data. Trending-now only, not interest-over-time.",
        "version": "0.1",
        "x-build-id": "yltck1D8fAKvZ36y1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dr_ben~google-trending-searches/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dr_ben-google-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/dr_ben~google-trending-searches/runs": {
            "post": {
                "operationId": "runs-sync-dr_ben-google-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/dr_ben~google-trending-searches/run-sync": {
            "post": {
                "operationId": "run-sync-dr_ben-google-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",
                "properties": {
                    "geos": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Two-letter country codes, e.g. US, GB, AU, DE, IN. Each country returns its current top 10 trending searches, so 3 countries returns 30 results.",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
