# Google Trends Scraper — New & Rising, 56 Countries (`quaffable_mettle/google-trends-trending-now`) Actor

Trending Google searches for 56 countries in one run — with what is NEW, what is RISING, and what trends in several countries at once. Official RSS feed, no proxies.

- **URL**: https://apify.com/quaffable\_mettle/google-trends-trending-now.md
- **Developed by:** [Emir Llonviche](https://apify.com/quaffable_mettle) (community)
- **Categories:** SEO tools, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 country processeds

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/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — New & Rising, 56 Countries

Get the **trending Google searches** for up to 56 countries in a single run — and, unlike a plain snapshot, **what is new, what is climbing, and what is trending in several countries at once**.

> **Unofficial.** This Actor is not affiliated with, endorsed by, or sponsored by Google LLC. "Google" and "Google Trends" are trademarks of Google LLC. This Actor reads the Trending Now RSS feed that Google publishes publicly.

Built on Google's **official Trending Now RSS feed** — not a headless browser, not a reverse-engineered private endpoint. That is why this Actor runs in about **two seconds per country**, needs **no proxies**, and does not break every time Google reships its front end.

***

### What makes it different

**It tells you what just broke, not just what is trending.** Google's feed is a snapshot with no memory. This Actor compares every run against your previous one and adds `isNew`, `rankChange`, `firstSeenAt` and `hoursTrending` to each row. A term that entered the list twenty minutes ago and a term that has been sitting there since breakfast look identical in the raw feed — here they do not.

**It spots what crosses borders.** Because every requested country is fetched in the same run, each row carries `alsoTrendingIn` and `countryCount`: the other markets where the exact same term is trending right now. A one-country-per-run scraper cannot compute this at all.

**One run, up to 56 countries**, in parallel batches — a full 56-country sweep takes well under a minute.

**News articles attached.** Each trend carries up to three articles Google associates with it: title, URL, source and image.

**Reads the feed Google publishes.** The widely-referenced `trends.google.com/trends/api/dailytrends` endpoint was retired and now returns 404. This Actor reads Google's Trending Now RSS feed, which Google maintains and serves in about two seconds. No headless browser, no proxies — that is why a country costs $0.05 rather than several times more.

**Built to fail loudly, not silently.** Countries are fetched independently, so one failure never aborts the rest. Three retries with exponential backoff. Every run writes a `RUN_SUMMARY` you can point a monitor at.

> **On your first run**, there is no previous run to compare against, so `isNew`, `rankChange` and `hoursTrending` come back `null` — we will not claim a term is new when we simply have no history. Run it a second time and the movement appears. Schedule it hourly or daily and it keeps improving.

***

### What you get

One row per trending search, per country:

```json
{
  "country": "FR",
  "countryName": "France",
  "rank": 1,
  "term": "météo",
  "isNew": false,
  "rankChange": 3,
  "firstSeenAt": "2026-08-25T08:00:00.000Z",
  "hoursTrending": 3,
  "alsoTrendingIn": ["BE", "CH"],
  "countryCount": 3,
  "trafficLabel": "50000+",
  "trafficMin": 50000,
  "publishedAt": "Sun, 23 Aug 2026 21:50:00 -0700",
  "imageUrl": "https://encrypted-tbn3.gstatic.com/images?q=tbn:AAA",
  "imageSource": "Le Monde",
  "newsCount": 3,
  "news": [
    {
      "title": "Canicule : alerte orange dans douze départements",
      "url": "https://www.lemonde.fr/meteo/article/canicule",
      "source": "Le Monde",
      "imageUrl": "https://encrypted-tbn3.gstatic.com/images?q=tbn:BBB",
      "snippet": null
    }
  ],
  "scrapedAt": "2026-08-24T19:30:00.000Z",
  "sourceUrl": "https://trends.google.com/trending/rss?geo=FR"
}
```

`trafficLabel` is Google's own threshold (`100+`, `1000+`, `50000+`). `trafficMin` is that threshold as a number, so you can sort and filter on it.

***

### Input

```json
{
  "countries": ["FR", "GB", "DE", "US"],
  "maxItemsPerCountry": 10,
  "includeNews": true,
  "minTraffic": 1000
}
```

| Field | Default | What it does |
|---|---|---|
| `countries` | `["FR"]` | Country codes to fetch. Each is fetched independently. |
| `maxItemsPerCountry` | `10` | Google publishes up to 10 trends per country. |
| `includeNews` | `true` | Attach related news articles to each trend. |
| `minTraffic` | `0` | Keep only trends above this search volume. |
| `language` | — | ISO 639-1 code for the news articles (`fr`, `en`, `de`…). |
| `timeoutSecs` | `30` | Per-country request timeout. |

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

An unrecognised code is reported before any request is made, so you never pay for a run that was doomed from the start.

***

### What people use it for

- **SEO and content teams** — catch a rising query the same day and publish against it.
- **Newsrooms** — see what a country is searching for right now, with the articles already covering it.
- **Social and brand monitoring** — track when a brand or product breaks into the trending list.
- **Market research across borders** — compare what France, Germany and the UK are searching for in one dataset.
- **Breaking-news detection** — schedule it hourly and filter on `isNew`; you see a story enter the national list within the hour.\n- **Cross-market signals** — filter on `countryCount > 1` to catch what is spreading across borders rather than staying local.

***

### Reliability

Reliability is the point of this Actor, so here is exactly what it does:

- **Each country is isolated.** One failure never aborts the others.
- **Three attempts with exponential backoff** on network errors and 5xx responses. A 404 is not retried — an invalid country code will not become valid.
- **Output is validated.** A feed that parses but contains no trends is treated as an anomaly and reported, not silently returned as an empty result.
- **Every run writes a `RUN_SUMMARY`** to the key-value store: countries requested, succeeded, failed, and why. Point a monitor at it and you will know a country started failing before your users tell you.

***

### Pricing

Pay per event: **$0.05 per country successfully processed**. A failed country is never charged. Four countries every day for a month costs about **$6**.

***

### Limits, stated plainly

- Google's feed publishes **10 trends per country**. This Actor cannot return more, and neither can anything else reading the same source.
- Volumes are **thresholds, not exact counts** — that is how Google publishes them.
- The feed covers **trending now**. History is built by this Actor from your own successive runs — the first run has no movement data, and the more often you run it, the finer the movement.
- Coverage is limited to the 56 countries Google publishes a feed for.

***

### Notes

This Actor reads a public RSS feed published by Google for automated consumption. It stores nothing and republishes nothing, and collects no individual user data — only aggregate search statistics published by Google and links to public news articles.

Found a bug or need a country added? Open an issue on the Actor page.

# Actor input Schema

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

Country codes to fetch trending searches for. Add as many as you need — each one is fetched independently, so one failing country never breaks the run.

## `maxItemsPerCountry` (type: `integer`):

Google's feed publishes up to 10 trending searches per country. Lower this if you only want the top few.

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

Attach the news articles Google associates with each trend (title, URL, source, image). Turn off for a smaller, flatter dataset.

## `minTraffic` (type: `integer`):

Keep only trends with at least this many searches. Google reports thresholds (100+, 1000+, 50000+), so this filters on the lower bound. Leave at 0 to keep everything.

## `language` (type: `string`):

Optional ISO 639-1 code (en, fr, de…) for the related news articles. Leave empty to use the country's default.

## `timeoutSecs` (type: `integer`):

How long to wait for each country before retrying. Raise it only if you see timeout warnings in the log.

## Actor input object example

```json
{
  "countries": [
    "FR",
    "GB",
    "DE"
  ],
  "maxItemsPerCountry": 10,
  "includeNews": true,
  "minTraffic": 0,
  "language": "fr",
  "timeoutSecs": 30
}
```

# Actor output Schema

## `trends` (type: `string`):

One row per trending search, per country: term, search volume, publication time and related news articles.

## `runSummary` (type: `string`):

Which countries were requested, how many succeeded or failed and why. Point a monitor at this to catch a country breaking before your users do.

# 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 = {
    "countries": [
        "FR",
        "GB",
        "DE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("quaffable_mettle/google-trends-trending-now").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "countries": [
        "FR",
        "GB",
        "DE",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("quaffable_mettle/google-trends-trending-now").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 '{
  "countries": [
    "FR",
    "GB",
    "DE"
  ]
}' |
apify call quaffable_mettle/google-trends-trending-now --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quaffable_mettle/google-trends-trending-now"
        }
    }
}

```

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/kIRXWq7a3sCPM4Nnq/builds/i4IkPd03sp3MlJq1J/openapi.json