# Google Trends Scraper & API — Interest & Rising (`dev_web_col/google-trends`) Actor

Google Trends data for keyword research and market research: interest over time, top regions, rising queries and today's trending topics by country.

- **URL**: https://apify.com/dev\_web\_col/google-trends.md
- **Developed by:** [Diseño Web de Colombia](https://apify.com/dev_web_col) (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

from $3.00 / 1,000 trend returneds

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

- **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 API — Interest, Regions & Rising

**The Google Trends scraper that finishes its runs.**

### Call it as an API

One keyword in, one row out with the full series, top regions and rising related
queries — in a single HTTP call, no polling.

```bash
curl -X POST "https://api.apify.com/v2/acts/dev_web_col~google-trends/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword": "bitcoin", "geo": "US", "timeframe": "today 12-m"}'
```

```python
import requests

r = requests.post(
    "https://api.apify.com/v2/acts/dev_web_col~google-trends/run-sync-get-dataset-items",
    params={"token": "YOUR_TOKEN"},
    json={"keyword": "bitcoin", "geo": "US", "timeframe": "today 12-m"},
)
trend = r.json()[0]
print(trend["averageInterest"], trend["direction"], trend["changePercent"])
```

```javascript
const res = await fetch(
  "https://api.apify.com/v2/acts/dev_web_col~google-trends/run-sync-get-dataset-items?token=YOUR_TOKEN",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ keyword: "bitcoin", geo: "US" }),
  },
);
const [trend] = await res.json();
```

Because `direction` and `changePercent` are computed for you, alerting on a
rising term is a one-line condition — no need to walk the series yourself.

Pass `keywords` instead of `keyword` to measure several terms in one call, and
`trendingCountries` to add today's trending searches for a country.

### What is this Google Trends Scraper?

This Actor pulls Google Trends data without a browser and without an API key: the full interest-over-time series for any keyword, the regions where it is searched most, and the related queries that are rising fastest. It also pulls today's trending searches for any country, each with its search volume and the news story behind it.

The most-used Trends scraper on Apify succeeds **71% of the time** and sits at ★3.1. The reason is always the same: Google answers HTTP 429 to anything that asks too fast. This one is built around that single problem — measured pacing, a fresh IP per attempt, retries on both rate limits and transient proxy errors — and returns data instead of an error.

### Measured against the alternative

| | The most-used Trends Actor | This one |
|---|---|---|
| Successful runs | **71%** | **100%** (10 of 10 cloud runs) |
| Rating | ★3.1 | new |

Three things make the difference, all of them measured rather than guessed:

1. **2,500 ms between widget calls.** With that pause all four Google widgets answer 200. Without it, Google returns 429 on the second call.
2. **A fresh proxy session per attempt**, so a single rate-limited IP cannot poison every run.
3. **Trending searches are fetched first**, from Google's RSS feed, which has no rate limit. Even if the keyword API turns difficult afterwards, the run already has results.

One subtle trap worth naming, because it is invisible from outside: Google's widget token is tied to the IP that requested the cookie. Rotating IPs between the two invalidates the token, and the time series silently comes back empty while the other widgets still work. Keeping one session per keyword took complete series from 50% to 95%.

### What you can use it for

| What you want | How to ask for it |
|---|---|
| **Keyword research** — is this term growing or dying? | `keyword` + `timeframe: "today 12-m"`, read `direction` and `changePercent` |
| **Market research** — where is demand concentrated? | `includeRegions: true`, read `topRegions` |
| **Content and SEO planning** — what to write next | `includeRelated: true`, read `risingQueries` |
| **Trend spotting** — catch a topic before it peaks | `trendingCountries: ["US"]`, run it on a schedule |
| **Seasonality** — when does this spike every year? | `timeframe: "today 5-y"`, read the `timeline` array |
| **Newsroom monitoring** — what is breaking right now | `trendingCountries`, each row carries the news headline and source |
| **Product and stock planning** | Regional interest before committing inventory |
| **Competitor brand tracking** | One `keyword` per brand, compare `averageInterest` over time |

Typical jobs: **keyword research**, **market research**, **SEO content planning**,
**trending topics** monitoring, and **search volume** trend analysis.

### What data you get

**Per keyword** — the full weekly series, plus the summary already computed for you: average interest, peak value and the date it happened, the latest value, the percentage change and whether the term is rising, falling or flat. Then the top 20 regions, the 25 top related queries and the 25 fastest-rising ones.

**Per trending search** — the topic, approximate search volume, the country, and the news headline, source and link driving it.

You do not need to post-process anything to answer "is this going up?" — `direction` and `changePercent` are in the row.

### Input

Every field is optional unless marked required.

| Field | Type | Description |
|---|---|---|
| `keywords` | array | Terms to measure interest for. Each one returns a full row: the weekly series, the peak, where it is searched most and which related queries are rising. |
| `geo` | string | Two-letter country code for the keyword search, for example US, GB, ES. Leave empty for worldwide. |
| `timeframe` | string | Google Trends syntax. 'today 12-m' is the last year, 'today 3-m' the last quarter, 'now 7-d' the last week, 'all' since 2004. |
| `trendingCountries` | array | Two-letter codes to pull today's trending searches from, with search volume and the news story behind each one. Works independently of the keywords above. |
| `includeRegions` | boolean | Adds the 20 regions where each keyword is searched most. One extra request per keyword. |
| `includeRelated` | boolean | Adds the top and the fastest-rising related searches for each keyword. One extra request per keyword. |
| `proxyConfiguration` | object | Required. Google Trends rate-limits hard and returns HTTP 429 to repeat callers, which is the main reason other Trends scrapers fail. A residential proxy plus retries is what keeps runs succeeding. |

#### Input sample

```json
{
  "keywords": [
    "bitcoin",
    "ethereum"
  ],
  "geo": "US",
  "trendingCountries": [
    "US"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Output sample

One real row from an actual run:

```json
{
  "type": "trending",
  "geo": "US",
  "title": "aerodiana",
  "approxTraffic": "500+",
  "trendUrl": "https://trends.google.com/trending/rss?geo=US",
  "newsTitle": "What we know so far about the plane crash that killed 11 European tourists near one of Peru’s most popular sites",
  "newsUrl": "https://www.cnn.com/2026/08/02/americas/nazca-plane-crash-dead-intl-latam",
  "newsSource": "CNN",
  "pictureUrl": "https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcQBUQXDfcKIfP0FyGnAYSw0Wkz4wZDytSmrfMqvLIOIZm1nMZEHFmJM-5GDv-c",
  "publishedAt": "Sun, 2 Aug 2026 20:20:00 -0700"
}
```

### Who uses this

- **SEO and content teams** — catch a rising query before the competition writes the article
- **Newsrooms** — what is trending right now, in your market, with the source story attached
- **Ecommerce** — seasonality and regional demand before committing to stock
- **Market researchers** — clean weekly series for any term going back to 2004
- **Traders and analysts** — retail attention as a signal, by region

### Honest limits

These are real and none of them is fixable by any tool. They are here so you know what you are buying before you run it.

- **A residential proxy is required.** Google rate-limits datacenter IPs almost immediately. The default input already asks for one.
- **Trends values are relative, not absolute.** 100 is the peak of that particular series, not a search volume. Two keywords fetched in separate runs cannot be compared against each other.
- **Rate limiting is the nature of this source.** Pacing and retries make runs succeed, but a long keyword list is slower than you might expect — roughly 10 seconds per keyword with all extras on. Runs stop after about 3.5 minutes and deliver what they have.
- **Trending searches return 10 topics per country.** That is everything Google publishes in the feed.
- **Related queries are sometimes empty** for low-volume terms. Google simply has no data to show there.

### FAQ

#### Why do other Google Trends scrapers fail so often?

Because Google returns HTTP 429 to callers that request too quickly, and most scrapers do not pace themselves or rotate IPs between attempts. The published success rate of the most popular Trends Actor is 71%. This one paces at 2,500 ms, uses a new IP per attempt and retries both rate limits and transient proxy failures.

#### What do the interest numbers mean?

They are a 0-100 index relative to the peak of that series. 100 is the highest point in the period you asked for, not a number of searches. Google never publishes absolute volumes.

#### Can I compare two keywords against each other?

Not across separate runs, because each series is normalised to its own peak. If you need a true comparison, that requires Google's multi-keyword comparison mode, which is a different request shape.

#### What time ranges can I use?

The input offers the standard Google set: last 24 hours, last 7 days, last month, last 3 months, last 12 months, last 5 years, and everything since 2004.

#### What are rising queries and why do they matter?

They are the searches growing fastest around your term, not the biggest ones. A query marked "Breakout" grew more than 5000%. This is where new demand shows up before it appears in any keyword tool.

#### Can I use this to monitor a keyword over time?

Yes, and it is the best use of it. Put it on a schedule and each run appends a fresh reading. Because the summary fields are pre-computed, alerting on `direction: "rising"` is a one-line filter.

#### Do I need an account or an API key for the source?

No. This Actor only reads public pages and public endpoints, the same ones any
logged-out visitor sees. You never give it credentials, and nothing is done on
your behalf.

#### Is it legal to scrape this data?

Scraping publicly available information is broadly accepted as legal, and this
Actor only ever touches pages that require no login. That said, what you may do
with the data afterwards is a separate question — personal data in particular is
regulated by GDPR and CCPA. If you plan to process personal data, take advice
first. Apify has a good primer: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

#### How much will a run cost me?

You are charged per result, so the cost scales with what you actually get back.
The pricing is shown on this page above the input form. Start with a small run to
see real numbers before you scale up.

#### Can I export to Excel, CSV or Google Sheets?

Yes. Every run's dataset can be downloaded as CSV, Excel, JSON, XML or HTML from
the **Storage** tab, and Apify integrates directly with Google Sheets, Airtable,
Zapier, Make and Slack.

#### Can I run this on a schedule?

Yes. Open the **Schedules** tab and pick an interval — hourly, daily, weekly.
Each run only costs you what it returns.

#### Can I call it from my own code instead of the console?

Yes. Every Actor on Apify is also an API endpoint. There are official clients for
[Python](https://docs.apify.com/api/client/python/) and
[JavaScript](https://docs.apify.com/api/client/js/), plus a plain REST API. The
**API** tab on this page shows ready-made snippets with your input already filled in.

#### Something came back empty. Is it broken?

Usually not. An empty result normally means the filters were too narrow, or the
source genuinely has nothing to return for that query. This Actor is written to
finish successfully and tell you what happened rather than fail — check the run
log, it says which step returned nothing.

### Related Actors

- **Company Enrichment** — turn domains into company records with emails
- **ATS Job Scraper** — hiring demand across a thousand company career pages

### Where the data comes from

The public Google Trends endpoints that trends.google.com itself calls, and Google's official trending-searches RSS feed. No login, no API key, no personal data — these are aggregated search terms.

# Actor input Schema

## `keyword` (type: `string`):

One search term, for when you call this Actor as an API from your own code — one call in, one row out with the full series, regions and rising queries. For several terms at once, use the field below.

## `keywords` (type: `array`):

Several terms at once, one per line. Each returns its own row. Use this for batch analysis rather than a live lookup.

## `geo` (type: `string`):

Two-letter country code for the keyword search, for example US, GB, ES. Leave empty for worldwide.

## `timeframe` (type: `string`):

Google Trends syntax. 'today 12-m' is the last year, 'today 3-m' the last quarter, 'now 7-d' the last week, 'all' since 2004.

## `trendingCountries` (type: `array`):

Two-letter codes to pull today's trending searches from, with search volume and the news story behind each one. Leave empty if you only want keyword data.

## `includeRegions` (type: `boolean`):

Adds the 20 regions where each keyword is searched most. One extra request per keyword.

## `includeRelated` (type: `boolean`):

Adds the top and the fastest-rising related searches for each keyword. One extra request per keyword.

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

Required. Google Trends rate-limits hard and returns HTTP 429 to repeat callers, which is the main reason other Trends scrapers fail. A residential proxy plus retries is what keeps runs succeeding.

## Actor input object example

```json
{
  "keyword": "bitcoin",
  "geo": "US",
  "timeframe": "today 12-m",
  "includeRegions": true,
  "includeRelated": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One dataset item per keyword or trending topic.

# 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 = {
    "keyword": "bitcoin",
    "geo": "US",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev_web_col/google-trends").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 = {
    "keyword": "bitcoin",
    "geo": "US",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("dev_web_col/google-trends").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 '{
  "keyword": "bitcoin",
  "geo": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call dev_web_col/google-trends --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nCWu5Dad5bOrqJKcZ/builds/g6cyXKWLIwc7YJdT4/openapi.json