Google Trends Scraper & API Alternative — Trending Searches by Country

What it does

Google Trends has no official public API, and the website is built for clicking, not for feeding a newsroom alert, a content calendar or an ad team every hour. This actor reads Google's official Trending Now RSS feed for any of the 125 countries the feed accepts and turns it into one row per trend: country, rank, keyword, approximate search traffic parsed to a number (2K+ becomes 2000, with the original text kept), the time the trend started, a picture and the news articles behind it.

Switch on onlyNewSinceLastRun and schedule it, and each run returns only the trends it has not delivered before for that country, keyword and start day. Skipped trends are not charged, so an hourly monitor costs only what is genuinely new.

There is a second, best-effort part for keyword research: up to 20 keywords with interest over time, interest by region and top + rising related queries, for any timeframe, location, category and search type (web, news, YouTube, images or Google Shopping). Google rate-limits those endpoints, so when it answers with a 429, 403 or CAPTCHA the actor stops that part, keeps what it already has and charges nothing for unfinished keywords.

How it works

1. For each country in geos, the actor requests Google's official Trending Now RSS feed (one request per country, paced at about one per second).
2. Each trend becomes a row with its rank, keyword, traffic bucket parsed to a number, start time, picture and news articles (title, URL, publisher, picture).
3. With onlyNewSinceLastRun, trends already returned under the same monitorName are skipped and not charged; the memory lives in the key-value store trends-seen-<name>.
4. If you add keywords, it calls the same JSON endpoints the Trends website uses, one request every 3 seconds, and returns timeline, region and related-query rows.
5. On any rate limit or CAPTCHA it stops the explore part for the rest of the run, never retries blocks, uses no proxies, and respects robots.txt and your run budget.

Input example

A typical run input (JSON). Every field is also available as a form in the Apify console.

{
  "geos": [
    "US",
    "GB",
    "DE",
    "BR"
  ],
  "maxItemsPerGeo": 10,
  "onlyNewSinceLastRun": true,
  "monitorName": "newsroom-hourly",
  "keywords": [],
  "timeframe": "today 12-m",
  "property": "web"
}

Output example

Trending Now rows look like this, one per trend and country, with the parsed traffic number next to Google's original bucket text:

Pricing

Pay per event: you are charged only for the results you receive, with no subscription. Set a maximum total charge on any run and it stops cleanly at the cap.

Prices are read from the live Apify Store listing when this page is built. The listing is always authoritative.

Use cases

How it compares

If you need a handful of keyword comparisons once in a while, the Trends website itself is free and more reliable for a person than any automated call. This actor is the better fit when you want trending searches across many countries on a schedule, as structured data.

Limits and honest notes

• Trending Now comes from Google's official RSS feed, which currently lists about 10 trends per country (fewer for small countries) — the newest ones, not the full Trending Now page with 24/48-hour filters. Traffic is Google's bucketed estimate (200+, 2K+, 1M+), not an exact count.
• The 125 countries in the input list are every ISO country code the feed accepted on 2026-10-20; Google answers unknown codes with an error.
• Interest over time / by region / related queries is best-effort. It uses the same JSON endpoints as trends.google.com and Google rate-limits them, especially from shared cloud IPs. On a 429, 401/403, CAPTCHA or 'unusual traffic' page the actor stops that part for the rest of the run (blocks are never retried and no proxies are used; only network errors and Google 5xx errors are retried once), delivers what it already has and charges nothing for unfinished keywords. Run small keyword lists and try again later if you are blocked.
• Requests are sequential and paced (one every 3 seconds for explore, one per second for the feed), so 20 keywords take about 1-2 minutes.
• Values are Google's relative scores (0-100 within a comparison, region values 0-100 per keyword), not search volumes. Related 'rising' values are growth percentages; 'Breakout' means more than +5000%. Regions without enough data are left out.
• robots.txt on trends.google.com is re-read every run and respected: the /explore? web pages are never requested (trendsUrl in the output is only a link for you to open).
• The run's spend limit is respected: rows are charged before they are delivered and the run stops when the limit is reached.

FAQ

Use it from code

Run the actor through the Apify API with the input above.

cURL

curl -X POST "https://api.apify.com/v2/acts/actor-forge~google-trends/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"geos": ["US", "GB", "DE", "BR"], "maxItemsPerGeo": 10, "onlyNewSinceLastRun": true, "monitorName": "newsroom-hourly", "keywords": [], "timeframe": "today 12-m", "property": "web"}'

JavaScript (Node.js)

// Node.js 18+ (built-in fetch). Set APIFY_TOKEN in your environment.
const input = {
  "geos": [
    "US",
    "GB",
    "DE",
    "BR"
  ],
  "maxItemsPerGeo": 10,
  "onlyNewSinceLastRun": true,
  "monitorName": "newsroom-hourly",
  "keywords": [],
  "timeframe": "today 12-m",
  "property": "web"
};

const res = await fetch(
  "https://api.apify.com/v2/acts/actor-forge~google-trends/run-sync-get-dataset-items",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(input),
  }
);
const items = await res.json();
console.log(items.length, items[0]);

Python

# pip install apify-client   (set APIFY_TOKEN in your environment)
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run_input = {
    "geos": [
        "US",
        "GB",
        "DE",
        "BR"
    ],
    "maxItemsPerGeo": 10,
    "onlyNewSinceLastRun": True,
    "monitorName": "newsroom-hourly",
    "keywords": [],
    "timeframe": "today 12-m",
    "property": "web"
}

run = client.actor("actor-forge/google-trends").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

The run-sync-get-dataset-items endpoint waits for the run (up to 5 minutes) and returns the dataset rows directly. For longer runs, start the run asynchronously and read the dataset when it finishes, as the Python example does. Replace APIFY_TOKEN with your own token from the Apify console.

Step-by-step guides

Related actors

More SEO & Marketing Intelligence tools · All actors