# Google Realtime and Trending Searches Scraper (`searchapi/google-realtime-trends-data-scraper`) Actor

Real-time Google Trends data scraper that monitors trending search keywords across 40+ countries worldwide. Updated every 10 minutes, perfect for market research, content planning, and trend analysis.

- **URL**: https://apify.com/searchapi/google-realtime-trends-data-scraper.md
- **Developed by:** [Search API](https://apify.com/searchapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 search results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Google Trends Country RSS Scraper do?

This Actor fetches a current snapshot from the public [Google Trends country RSS feed](https://trends.google.com/trending/rss?geo=US). It normalizes each feed item into a trend record and includes related-news details when the feed provides them. Each run is a snapshot; it is not an automatically scheduled monitor.

The interactive [Trending Now page](https://trends.google.com/trending?geo=US) currently shows fields such as search-volume growth, start time, trend status, related-query terms, and an interest graph. This RSS Actor does not collect that full browser table. Optional output fields are omitted when their source values are absent; the Actor does not pad records with invented values.

### Why use this Actor?

- Collect current country-level trend terms from one or more of the 48 supported country feeds.
- Compare feed order, approximate traffic, publication time, and related-news sources across countries.
- Keep a reproducible source URL and scrape timestamp on each record.
- Use Apify datasets, run history, scheduling, and API integrations for your own monitoring workflow.

### What data can it extract?

The dataset schema declares **30 fields**. A complete RSS item can populate all 30; optional fields are present only when supplied by the feed or derived from a supplied value.

| Field | Type | Meaning |
| --- | --- | --- |
| `id` | string | Stable ID derived from country and normalized trend term. |
| `trendTerm`, `normalizedTerm` | string | Feed title and normalized title. |
| `country`, `countryName` | string | Country code and English country name. |
| `countryIndex`, `rank`, `globalPosition` | integer | Requested country order, rank within that country, and final output position. |
| `trafficText` | string | Approximate traffic label from the RSS item. |
| `trafficLowerBound` | integer | Parsed numeric lower bound when the label includes a supported magnitude and `+`. |
| `trafficQualifier` | string | The source `+` qualifier when parsed. |
| `publishedAt`, `publishedTimestamp` | date-time, integer | RSS publication date in ISO format and Unix milliseconds. |
| `sourceFeedUrl`, `feedLink`, `exploreUrl` | URL | Country RSS URL, feed item link, and generated Google Trends Explore URL. |
| `pictureUrl`, `pictureSource` | URL, string | Feed image and its named source, when present. |
| `newsCount`, `hasNews`, `includedNewsCount` | integer, boolean, integer | Related-news count, presence flag, and number of news records included. |
| `newsItems` | array | Ranked related-news headlines, URLs, domains, snippets, pictures, and sources. |
| `primaryNewsHeadline`, `primaryNewsUrl`, `primaryNewsSource` | string, URL, string | First related-news item’s headline, URL, and source. |
| `newsSources`, `newsDomains` | arrays of strings | Unique source names and domains derived from included news items. |
| `source`, `extractionMethod` | string | Identifies Google Trends and the RSS extraction method. |
| `scrapedAt` | date-time | Time this Actor created the record. |

### How to scrape Google Trends

1. Start the Actor and choose country codes in input order. Use `ALL` to expand to all supported countries.
2. Set the per-country trend limit and optional global cap. The global cap selects records round-robin so one country does not consume the full limit.
3. Leave `includeNews` enabled for related-news detail, or disable it to keep only aggregate news counts.
4. Run the Actor and inspect the default dataset and the `OUTPUT` key-value-store summary.

### How much does it cost?

Apify compute charges depend on your account plan and the time the run uses; this Actor does not promise a fixed price. Each selected country requires one feed request, so additional countries, retries, and slow responses can increase run time. The Actor does not open a browser or fetch separate article pages. Proxy traffic can incur separate account charges; proxy use is off by default.

### Input

See the input tab for the complete configuration. Country selection precedence is `countries`, then legacy `geos`, then legacy `country`, then the default `US`. `ALL` expands to the supported list and duplicate country codes are removed. `maxItems` overrides `maxTrends`; `includeNews` overrides `includeNewsItems`.

| Field | Default | Supported values / behavior |
| --- | --- | --- |
| `countries` | `['US']` | Ordered country-code array, 1–48 entries; accepts `ALL`. |
| `country` | — | Legacy single-country alias. |
| `geos` | — | Legacy country-array alias. |
| `maxTrends` | `20` | Per-country limit, 1–50. |
| `maxItems` | — | Legacy alias overriding `maxTrends`, 1–50. |
| `maxTotalItems` | countries × per-country limit | Global record cap, 1–2,400. |
| `includeNews` | `true` | Include related-news fields. Aggregate counts remain available when false. |
| `includeNewsItems` | — | Legacy alias for `includeNews`. |
| `maxConcurrency` | `3` | Concurrent country requests, 1–10. |
| `maxRequestRetries` | `3` | Retries for temporary network, rate-limit, and server errors, 0–8. |
| `requestTimeoutSecs` | `20` | Per-feed timeout, 5–120 seconds. |
| `useApifyProxy` | `false` | Use authorized Apify Proxy resources. |
| `proxyGroups` | — | Optional Apify Proxy group names. |
| `proxyCountryCode` | — | Optional two-letter Apify Proxy country. |
| `proxyUrls` | — | Optional custom HTTP(S) proxy URLs. Credentials are not logged or stored. |
| `proxyConfiguration` | — | Legacy Apify proxy editor object; do not combine with modern proxy fields. |
| `proxySessionId` | — | Optional stable proxy session ID. |

Example input:

```json
{
  "countries": ["US", "GB"],
  "maxTrends": 5,
  "maxTotalItems": 8,
  "includeNews": true
}
```

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

### Output

Records follow `.actor/dataset_schema.json`; the README field inventory above includes every declared field. Empty optional values are omitted. The following is an **illustrative schema example**, not a live Google Trends record:

```json
{
  "id": "google-trends:US:000000000000000000000000",
  "trendTerm": "Example trend term",
  "normalizedTerm": "example trend term",
  "country": "US",
  "countryName": "United States",
  "countryIndex": 1,
  "rank": 1,
  "globalPosition": 1,
  "trafficText": "1.2M+",
  "trafficLowerBound": 1200000,
  "trafficQualifier": "+",
  "publishedAt": "2026-09-22T12:00:00.000Z",
  "publishedTimestamp": 1790078400000,
  "sourceFeedUrl": "https://trends.google.com/trending/rss?geo=US",
  "feedLink": "https://trends.google.com/trends/explore?q=example&geo=US",
  "exploreUrl": "https://trends.google.com/trends/explore?q=Example%20trend%20term&geo=US",
  "pictureUrl": "https://example.com/trend.jpg",
  "pictureSource": "Example Images",
  "newsCount": 1,
  "hasNews": true,
  "includedNewsCount": 1,
  "newsItems": [
    {
      "rank": 1,
      "headline": "Example related headline",
      "url": "https://example.com/story",
      "domain": "example.com",
      "snippet": "Illustrative source-provided summary.",
      "pictureUrl": "https://example.com/story.jpg",
      "source": "Example News"
    }
  ],
  "primaryNewsHeadline": "Example related headline",
  "primaryNewsUrl": "https://example.com/story",
  "primaryNewsSource": "Example News",
  "newsSources": ["Example News"],
  "newsDomains": ["example.com"],
  "source": "Google Trends",
  "extractionMethod": "google-trends-rss",
  "scrapedAt": "2026-09-23T00:00:00.000Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Tips and advanced options

- Start with one or two countries and a small `maxTrends` value before expanding a run.
- Keep concurrency conservative and retries bounded. The feeds are requested directly unless proxy options are explicitly set.
- The Actor validates response status, XML content type, payload size, and RSS structure. An empty valid feed produces no records; malformed or blocked responses fail instead of returning fabricated data.
- The `OUTPUT` key contains record and country counts, selected limits, proxy-use status, and completion time.

### FAQ, support, and responsible use

This Actor reads public Google Trends RSS feeds and does not bypass access controls. It is not affiliated with Google. Follow Google’s terms, applicable rate limits, and local law. Public trend and news records may contain personal names; use and retain the data only for a legitimate purpose.

If a run fails, check its logs and the `OUTPUT` key-value entry. For bugs or feature requests, use the Actor’s Issues tab and include the run ID and a short error summary. See the API tab for programmatic runs and dataset access.

# Changelog

This Actor's version history is a separate document: https://apify.com/searchapi/google-realtime-trends-data-scraper/changelog.md

# Actor input Schema

## `countries` (type: `array`):

Country codes in requested order. Use ALL to expand to every supported country.

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

Backward-compatible single-country input, used when countries is omitted.

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

Backward-compatible alias for countries.

## `maxTrends` (type: `integer`):

Maximum unique trend terms retained for each country.

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

Backward-compatible alias for maxTrends.

## `maxTotalItems` (type: `integer`):

Global cap across countries. Results are selected round-robin so each country is represented fairly.

## `includeNews` (type: `boolean`):

Include related-news details; aggregate RSS news counts remain available when disabled.

## `includeNewsItems` (type: `boolean`):

Backward-compatible alias for includeNews.

## `maxConcurrency` (type: `integer`):

Maximum country feeds fetched simultaneously.

## `maxRequestRetries` (type: `integer`):

Retries for temporary network, rate-limit, and server failures.

## `requestTimeoutSecs` (type: `integer`):

Per-feed request timeout.

## `useApifyProxy` (type: `boolean`):

Route requests through authorized Apify Proxy resources.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups.

## `proxyCountryCode` (type: `string`):

Optional two-letter Apify Proxy country code.

## `proxyUrls` (type: `array`):

Optional HTTP(S) proxy URLs. Credentials are never logged.

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

Backward-compatible Apify proxy editor input. Do not combine with modern proxy fields.

## `fingerprintProfile` (type: `string`):

Accepted for input compatibility and ignored because this Actor calls a public RSS endpoint.

## `proxySessionId` (type: `string`):

Optional stable proxy-session ID.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "maxTrends": 20,
  "includeNews": true,
  "maxConcurrency": 3,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 20,
  "useApifyProxy": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `keyValueStore` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

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

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

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

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

```

## CLI example

```bash
echo '{}' |
apify call searchapi/google-realtime-trends-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,searchapi/google-realtime-trends-data-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0NshdhIhan1WKFxFC/builds/lQ24ZThiRCgHDxeOk/openapi.json