# Google Trends RSS Scraper - Trending Searches (`benthepythondev/google-trends-rss-scraper`) Actor

Scrape Google Trends RSS trending searches by country: query, traffic, publish date, image and related news items.

- **URL**: https://apify.com/benthepythondev/google-trends-rss-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Marketing, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Google Trends RSS Scraper - Trending Searches

Scrape Google Trends RSS trending searches by country and export clean trend data in one run. Get the trending query, approximate traffic, publish date, picture, picture source and related news items. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the Google Trends RSS Scraper?

Google Trends exposes a lightweight RSS feed for currently trending searches. This actor turns that feed into structured rows you can use for SEO monitoring, news tracking, content planning, market research and social media workflows. It is intentionally built on the RSS endpoint instead of heavy browser automation, which keeps it fast, cheap and suitable for daily scheduled runs.

#### What data does it extract?

- **Trend query:** the keyword or phrase currently trending.
- **Traffic signal:** Google's approximate traffic label when available.
- **Publish date:** the RSS item timestamp.
- **Image:** picture URL and source when present.
- **Related news:** title, URL, source and snippet for news items connected to the trend.
- **Geo:** the country code used for the feed.

### Input

Add one or more Google Trends geo codes to `geos`, such as `US`, `GB`, `DE`, `FR` or `IN`. Set `maxResults` to limit how many trend rows are returned per geo.

#### Example input

```json
{
  "geos": ["US", "GB", "DE"],
  "maxResults": 25
}
````

### Output

Each dataset row can include:

```json
{
  "geo": "US",
  "feed_title": "Daily Search Trends",
  "query": "example trending topic",
  "traffic": "50K+",
  "pub_date": "Tue, 07 Jul 2026 08:00:00 -0700",
  "picture": "https://...",
  "picture_source": "Example News",
  "news": [
    {
      "title": "Related article title",
      "url": "https://example.com/article",
      "source": "Example News",
      "snippet": "Short news snippet..."
    }
  ]
}
```

### Use cases

🔎 **SEO research:** Watch current trending searches and turn them into content ideas, article briefs or keyword monitoring dashboards.

📰 **News monitoring:** Track trending topics by country and collect related article links in a structured format.

📣 **Social media planning:** Find timely topics for posts, videos, newsletters and campaign hooks.

📊 **Market research:** Compare trends across countries to spot regional differences in public attention.

⚡ **Automation:** Schedule the actor hourly or daily and push trend rows to Slack, Sheets, Airtable, Make, Zapier or n8n.

### Workflow ideas

Create one task for your main markets and run it every morning. Send the dataset to a spreadsheet, then have an editor or marketer tag each trend as relevant, irrelevant or worth researching. For newsrooms and agencies, store runs over time and compare which topics repeat across countries. For SEO teams, connect the output to a content calendar and use the related news URLs as research sources.

Because every row includes the `geo`, you can monitor several countries in one run while keeping the output easy to filter. If you need clean historical tracking, schedule the same input every day and append results to a database.

### Reliability notes

This actor uses Google's public Trends RSS feed, not a browser session and not the full Google Trends web application. That makes it reliable and lightweight, but it also means the output is limited to what the RSS feed exposes. It does not return full historical trend curves or every Google Trends UI metric.

If a geo code returns no rows, verify that the code is supported by Google Trends RSS. Keep scheduled runs modest and avoid unnecessary high-frequency polling.

### Data quality tips

Google's traffic labels are approximate buckets, not exact search volumes. Treat them as directional signals for what is moving right now, not as keyword-planner volume. The related news list is also editorially shaped by Google and can vary by country and time of day.

For cleaner analysis, store each scheduled run with a timestamp and deduplicate by `geo` plus `query`. That lets you see whether a trend was a one-time spike or a topic that kept appearing across multiple runs. If you monitor multiple countries, compare both the query and the related news sources because the same global story may appear under different wording in each market.

For content workflows, add a manual review step before publishing. Trends move quickly, and not every trending topic is brand-safe or relevant.

### Pricing

This actor uses pay-per-result pricing. You are charged for each trend row pushed to the dataset, plus a tiny actor-start event.

### FAQ

#### Does it need a Google API key?

No. It reads the public Google Trends RSS feed.

#### Does it scrape full Google Trends charts?

No. It extracts current RSS trend items and related news, not full historical chart data.

#### Can I monitor multiple countries?

Yes. Add multiple geo codes to `geos`.

#### Can I schedule it?

Yes. Save a task and run it hourly, daily or weekly.

#### Does it include related news?

Yes, when the RSS item includes Google Trends news item fields.

#### Is it legal?

This actor extracts publicly available RSS data. You are responsible for using the output lawfully and respecting Google's terms and applicable rules.

#### Why use RSS instead of a browser scraper?

RSS is faster, cheaper and more reliable for daily trend monitoring. Browser scraping is only needed for UI-only metrics.

#### Can I use this for historical Google Trends analysis?

No. This actor is for current RSS trending searches. Use a dedicated historical Trends tool when you need time-series interest charts.

#### Why are some trend rows missing pictures or news?

Those fields are optional in the RSS feed. The actor keeps missing fields as `null` so the output remains honest and easy to process.

#### Can I use it for alerts?

Yes. Schedule the actor and send new rows into Slack, email, Sheets, Airtable or your own alerting system.

### You might also like

- Google News Scraper - monitor news results
- YouTube Search Results Scraper - discover trending videos
- Website Contact Extractor - enrich websites from trend research
- RSS Feed Scraper - extract articles from RSS feeds

### Keywords

Google Trends scraper, Google Trends RSS, trending searches API, daily search trends, trend monitoring, SEO trend scraper, content ideas, news monitoring, Google Trends export, marketing trends data.

# Actor input Schema

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

Google Trends geo codes, e.g. US, GB, DE, FR, IN.

## `maxResults` (type: `integer`):

Maximum number of trending searches to return per geo.

## Actor input object example

```json
{
  "geos": [
    "US"
  ],
  "maxResults": 10
}
```

# 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"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/google-trends-rss-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 = {
    "geos": ["US"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/google-trends-rss-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 '{
  "geos": [
    "US"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/google-trends-rss-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends RSS Scraper - Trending Searches",
        "description": "Scrape Google Trends RSS trending searches by country: query, traffic, publish date, image and related news items.",
        "version": "1.0",
        "x-build-id": "0Z5VV4rUx9GB2uAvW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~google-trends-rss-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-google-trends-rss-scraper",
                "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/benthepythondev~google-trends-rss-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-google-trends-rss-scraper",
                "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/benthepythondev~google-trends-rss-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-google-trends-rss-scraper",
                "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 / geos",
                        "type": "array",
                        "description": "Google Trends geo codes, e.g. US, GB, DE, FR, IN.",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per geo",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of trending searches to return per geo.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
