# Google Trends - Trending Now Scraper (`ryyos/google-trends-indonesia-trending`) Actor

\[$1/1000] Get real-time trending searches from Google Trends in seconds - topic, search volume, growth %, and related news, no browser or API key needed.

- **URL**: https://apify.com/ryyos/google-trends-indonesia-trending.md
- **Developed by:** [Rio Dwi Saputra](https://apify.com/ryyos) (community)
- **Categories:** SEO tools, Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 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 Indonesia - Trending Now Scraper

**Get Indonesia's real-time trending searches straight from [Google Trends](https://trends.google.com/trending?geo=ID)** - topic, approximate search volume, growth percentage, related search terms, and linked news articles, all in one clean dataset. No browser, no API key, and no CAPTCHA-solving required: this Actor talks directly to Google's own trending feed and returns structured JSON in seconds.

### Why use this Google Trends Trending scraper?

Google Trends has no official public API for "Sedang trending" (Trending Now), and its backend changed recently, so most existing tools and libraries are out of date. This Actor was built by reverse-engineering the **current, live** endpoint - not an old cached protocol - which means it keeps working while outdated scrapers break. It's a great fit for:

- **Content and social media teams** who need to know what's trending in Indonesia right now to plan timely posts.
- **Marketers and SEO researchers** tracking search volume spikes and breakout topics by category.
- **News and media monitoring** teams who want a trend's related news articles the moment it starts climbing.
- **Data analysts** building a historical trending-topics archive, since Google Trends itself only keeps a short lookback window.

Running it on the Apify platform also gets you scheduling, an instant API for every result, and one-click integrations with Zapier, Make, Google Sheets, and dozens of other tools - turning a manual page-refresh habit into an automated data feed.

### How to use the Trending Now scraper

1. Click **Try for free** (or **Start**) on this Actor's page.
2. Set **Country** (defaults to `ID` for Indonesia).
3. Optionally narrow results with **Time range**, **Category**, **Active trends only**, and **Sort by** - these mirror the filters on trends.google.com exactly.
4. Click **Start** and wait a few seconds for the run to finish.
5. Open the **Dataset** tab to view, filter, and export your results.

### Input

The Input tab lets you configure:

| Field | Description | Default |
|---|---|---|
| `geo` | ISO country code to fetch trending searches for | `ID` |
| `hours` | Time range: last 4, 24, 48 hours, or 7 days | `24` |
| `category` | Restrict to one category (Sports, Politics, Entertainment, etc.) or all | All categories |
| `activeOnly` | Only return currently active trends | `false` |
| `sortBy` | Order results by relevance, title, search volume, or recency | `relevance` |

```json
{
    "geo": "ID",
    "hours": "24",
    "category": "0",
    "activeOnly": false,
    "sortBy": "relevance"
}
```

### Output

Each dataset item is one trending topic:

```json
{
    "title": "gubernur bi",
    "geo": "ID",
    "started_at": "2026-07-25T06:00:00+00:00",
    "approx_volume": 50000,
    "growth_percent": 1000,
    "breakdown_terms": ["gubernur bi", "perry warjiyo", "destry damayanti"],
    "category_ids": [10, 14],
    "related_articles": [
        { "article_id": 4750050386, "lang": "id", "geo": "ID" }
    ]
}
```

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

#### Data table

| Field | Description |
|---|---|
| `title` | The trending search term |
| `geo` | Country code the trend applies to |
| `started_at` | ISO 8601 timestamp of when the trend started |
| `approx_volume` | Approximate search volume (e.g. `100000` matches the "100 rb+" badge in the UI) |
| `growth_percent` | Search interest growth, matching the "%" badge shown in the UI |
| `breakdown_terms` | Related/breakdown search queries for this trend |
| `category_ids` | Google Trends category id(s) this trend was tagged under |
| `related_articles` | News articles associated with the trend (`article_id`, `lang`, `geo`) |

### Cost estimation

This Actor uses plain HTTP requests (no browser), so a run is fast and cheap - a single fetch typically finishes in a few seconds and uses a fraction of a Compute Unit. On the Apify [free plan](https://apify.com/pricing), you can comfortably run this hundreds of times per month at no cost.

### Tips

- Combine **Time range = last 7 days** with **Sort by = search volume** to surface the week's biggest topics at a glance.
- Schedule this Actor hourly using Apify's built-in [scheduler](https://docs.apify.com/platform/schedules) to build your own trending-topics history, since Google Trends itself doesn't keep a long lookback for this view.
- Google's own category filter is a ranking bias rather than a hard filter - if you need a strict category match, filter on the `category_ids` array client-side after export.

### FAQ, limitations & support

- **What data isn't included?** The "Aktif" (active) status badge and the 24-hour interest graph could not be reliably traced in the underlying data during reverse-engineering, so they're not part of the output yet.
- **Is this legal to use?** This Actor only reads the same public page a browser would load - it does not bypass CAPTCHAs, logins, or any anti-bot protection. Use responsibly and respect Google's Terms of Service.
- **Looking for Explore or Related Queries data?** Check the companion Actors in this collection - see the root of this repository for status.
- Found a bug or want a feature added? Use the Issues tab on this Actor's page, or reach out - a custom solution is also available on request.

# Actor input Schema

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

ISO country code to fetch trending searches for, e.g. ID for Indonesia.

## `hours` (type: `string`):

How far back to look for trending searches.

## `category` (type: `string`):

Restrict results to a single trending category, or leave on All categories.

## `activeOnly` (type: `boolean`):

Only return trends that are currently active.

## `sortBy` (type: `string`):

Order in which trends are returned.

## Actor input object example

```json
{
  "geo": "ID",
  "hours": "24",
  "category": "0",
  "activeOnly": false,
  "sortBy": "relevance"
}
```

# Actor output Schema

## `dataset` (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("ryyos/google-trends-indonesia-trending").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("ryyos/google-trends-indonesia-trending").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 '{}' |
apify call ryyos/google-trends-indonesia-trending --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends - Trending Now Scraper",
        "description": "[$1/1000] Get real-time trending searches from Google Trends in seconds - topic, search volume, growth %, and related news, no browser or API key needed.",
        "version": "0.1",
        "x-build-id": "XeI0MD3zOFzsYZ7KS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryyos~google-trends-indonesia-trending/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryyos-google-trends-indonesia-trending",
                "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/ryyos~google-trends-indonesia-trending/runs": {
            "post": {
                "operationId": "runs-sync-ryyos-google-trends-indonesia-trending",
                "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/ryyos~google-trends-indonesia-trending/run-sync": {
            "post": {
                "operationId": "run-sync-ryyos-google-trends-indonesia-trending",
                "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",
                "required": [
                    "geo"
                ],
                "properties": {
                    "geo": {
                        "title": "Country",
                        "type": "string",
                        "description": "ISO country code to fetch trending searches for, e.g. ID for Indonesia.",
                        "default": "ID"
                    },
                    "hours": {
                        "title": "Time range",
                        "enum": [
                            "4",
                            "24",
                            "48",
                            "168"
                        ],
                        "type": "string",
                        "description": "How far back to look for trending searches.",
                        "default": "24"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "0",
                            "16",
                            "3",
                            "6",
                            "13",
                            "4",
                            "8",
                            "10",
                            "20",
                            "2",
                            "7",
                            "11",
                            "5",
                            "17",
                            "1",
                            "9",
                            "14",
                            "15",
                            "18",
                            "19"
                        ],
                        "type": "string",
                        "description": "Restrict results to a single trending category, or leave on All categories.",
                        "default": "0"
                    },
                    "activeOnly": {
                        "title": "Active trends only",
                        "type": "boolean",
                        "description": "Only return trends that are currently active.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "title",
                            "search-volume",
                            "recency"
                        ],
                        "type": "string",
                        "description": "Order in which trends are returned.",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
