# Google Trends Scraper: Multi-Country + Trending (`asia-data-desk/google-trends-sea`) Actor

Compare a keyword's interest over time across up to 15 countries on one 0-100 scale in a single run, and get today's trending searches for any supported country. Presets: SEA, ASEAN, APAC, EU5, ANGLO, G7. Optional related queries, province-level breakdowns and a category filter.

- **URL**: https://apify.com/asia-data-desk/google-trends-sea.md
- **Developed by:** [Aye Bot Data](https://apify.com/asia-data-desk) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 trending searches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Google Trends Scraper: Multi-Country Compare (one scale) + Trending Now

**A Google Trends scraper that compares a keyword across up to 15 countries on one 0-100 scale in a single run, and returns today's trending searches for each of those countries.**

Google Trends lets you compare at most five places at once, and most scrapers take one country per run, so every country comes back on its own 0-100 scale. This Actor joins the requests for you, so you can say "Malaysia searches for this twice as much as Singapore" and have the numbers mean it.

### What you get

- **Interest over time on one scale.** 1 to 5 keywords, up to 15 countries, one shared 0-100 scale per keyword, weekly, daily or hourly points depending on the timeframe.
- **Trending now by country.** The current trending searches for each country you pick (about 10 per country), with approximate search volume, start time and up to three news links.
- **Related queries (optional).** Top and rising related searches for each keyword in each country, with Google's "Breakout" flag.
- **Interest by subregion (optional).** Each country's states or provinces ranked for your keyword (for example 16 for Malaysia, 34 for Indonesia, 49 for Thailand).
- **Category filter (optional).** Narrow results to one Google Trends category, for example Food & Drink.
- **Country presets.** `SEA` (default), `ASEAN`, `APAC`, `EU5`, `ANGLO`, `G7`, or your own list of ISO country codes.
- **Ready to use.** Clean JSON records, one per keyword and country, exportable from the dataset as JSON, CSV, Excel, XML, HTML or RSS. No login, no browser, no proxy needed.
- **Pay only for results.** Empty series, blocked requests and countries without data cost nothing beyond the start fee.

### Who uses it

- **Market entry research.** Rank candidate countries by search demand for your product or category before you commit budget, on numbers that can be compared side by side.
- **Brand and product demand comparison.** Track one brand or product name across your markets and see where interest is growing, flat or seasonal.
- **SEO keyword planning per market.** Pull the top and rising related queries in each country to find the phrases local searchers actually use.
- **Trend monitoring.** Schedule a daily trending-now run across your markets and feed the list into a sheet, Slack channel or newsroom tool.
- **Agency and client reporting.** One run per client keyword set returns every market at once, ready to chart or drop into a monthly report.

### Quick start in 30 seconds

1. Press **Start** with the default input to get today's trending searches for six Southeast Asian countries (SG, MY, ID, TH, VN, PH).
2. To compare a keyword across countries, paste this input and press **Start**:

```json
{
  "mode": "compare",
  "keywords": ["durian"]
}
```

That uses the default `SEA` preset and the last 12 months. You get one record per country, all on one scale. Real result for "durian" from a run on 18 October 2026 (54 weekly points each; that run also compared "bubble tea"):

| Country | Average | Peak | Peak week |
|---|---|---|---|
| MY | 31.4 | 100 | 2026-06-21 |
| SG | 25.0 | 77 | 2026-06-21 |
| ID | 16.1 | 33 | 2025-12-28 |
| PH | 3.3 | 5 | 2026-01-11 |
| TH | 1.7 | 3 | 2026-05-17 |
| VN | 0.9 | 1 | 2025-10-12 |

Because every row is on the same scale, you can read it directly: at its peak week, Singapore searched for durian at 77% of Malaysia's peak level.

### Why multi-country on one scale matters

Google Trends scales every request so its own peak is 100. Run "durian" for Singapore alone and Singapore peaks at 100; run it for Malaysia alone and Malaysia peaks at 100. Two separate runs cannot be compared.

Popular Google Trends Actors on the Apify Store, such as `data_xplorer/google-trends-fast-scraper` and `data_xplorer/google-trends-trending-now`, take one country per run (a single `geo` or `country` value in their published input schemas, checked 18 October 2026). Apify's own `apify/google-trends-scraper`, run with a worldwide `geo`, does return interest by country on one scale, but as a single snapshot for the whole period, not a series per country over time.

This Actor returns up to 15 countries' interest over time in one run, on one scale per keyword. Google accepts at most five places per request, so more countries are split into batches joined through a shared "anchor" country (details below). Measured accuracy: for "durian" over 12 months, the six-country joined series matched Google's own five-country request within 1 point on the 0-100 scale at all 54 weekly points.

What the others do better, so you can choose: `apify/google-trends-scraper` accepts any Google Trends URL, and `data_xplorer/google-trends-trending-now` offers category filters and 4 hour to 7 day windows for trending searches. This Actor returns the current trending list with no category or window filter.

### Output examples

Real records from runs on 18 and 19 October 2026, shortened. Every record has a `record_type`.

`interest` (one per keyword and country):

```json
{
  "record_type": "interest",
  "keyword": "durian",
  "country": "MY",
  "timeframe": "today 12-m",
  "category": 0,
  "resolution": "WEEK",
  "points": 54,
  "has_data": true,
  "average": 31.4,
  "latest": 17,
  "latest_date": "2026-10-11",
  "peak": 100,
  "peak_date": "2026-06-21",
  "series": [{"date": "2025-10-12", "value": 23}, {"date": "2025-10-19", "value": 25}],
  "scale": "0-100; 100 = this keyword's peak across compared_countries",
  "scale_method": "anchor_rescaled",
  "scale_anchor": "MY",
  "compared_countries": ["SG", "MY", "ID", "TH", "VN", "PH"]
}
```

`trending` (one per trending search per country):

```json
{
  "record_type": "trending",
  "country": "SG",
  "country_name": "Singapore",
  "rank": 1,
  "title": "kitchen",
  "approx_traffic": 200,
  "approx_traffic_raw": "200+",
  "published_at": "2026-10-18T15:00:00Z",
  "news": [
    {
      "title": "HDB sheds light on 'small' kitchen of Tengah BTO flat in viral video, Singapore News",
      "source": "AsiaOne.com",
      "url": "https://www.asiaone.com/singapore/hdb-small-kitchen-tengah-bto-flat-garden-waterfront"
    }
  ],
  "trend_url": "https://trends.google.com/trends/explore?q=kitchen&date=now%201-d&geo=SG",
  "source_feed": "https://trends.google.com/trending/rss?geo=SG",
  "fetched_at": "2026-10-18T15:30:12Z"
}
```

`related` (optional, one per keyword and country):

```json
{
  "record_type": "related",
  "keyword": "durian",
  "country": "SG",
  "top": [{"query": "durian singapore", "value": 100}, {"query": "durian cake", "value": 27}],
  "rising": [{"query": "lorong lew lian durian warning", "value": 70750, "label": "Breakout", "breakout": true}],
  "top_count": 25,
  "rising_count": 22
}
```

`subregions` (optional, one per keyword and country; values are 0-100 within that country only):

```json
{
  "record_type": "subregions",
  "keyword": "durian",
  "country": "MY",
  "timeframe": "today 12-m",
  "category": 0,
  "resolution": "REGION",
  "subregion_count": 16,
  "subregions": [
    {"code": "MY-04", "name": "Malacca", "value": 100},
    {"code": "MY-11", "name": "Terengganu", "value": 45},
    {"code": "MY-06", "name": "Pahang", "value": 43}
  ],
  "scale": "0-100 within this country only; 100 = this keyword's strongest subregion in this country, not comparable between countries or with the interest series"
}
```

Weekly and daily series use `YYYY-MM-DD`; hourly and minute series use UTC timestamps. The last point can carry `"partial": true` because the current period is still filling; `latest` is the last complete point. `approx_traffic` is the lower bound Google publishes ("200+" is 200).

### Pricing

Pay per event: you pay for records delivered, plus a small start fee per run. Apify Store plan discounts apply to the two main events.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Actor start, once per run | US$0.02 | US$0.02 | US$0.02 | US$0.02 |
| Trending search (`trending-item`) | US$0.002 | US$0.0018 | US$0.0015 | US$0.001 |
| Interest series, one keyword in one country (`interest-series`) | US$0.008 | US$0.007 | US$0.006 | US$0.005 |
| Related queries, one set per keyword and country (`related-set`) | US$0.004 | US$0.004 | US$0.004 | US$0.004 |
| Subregions, one set per keyword and country (`subregion-set`) | US$0.004 | US$0.004 | US$0.004 | US$0.004 |

One interest series is a whole time series (for example 54 weekly points), not a single data point.

Worked examples at Free plan prices:

| Job | Arithmetic | Cost |
|---|---|---|
| Trending now, six SEA countries (60 searches) | 0.02 + 60 x 0.002 | US$0.14 |
| One keyword across six countries | 0.02 + 6 x 0.008 | US$0.068 |
| One keyword across ten countries | 0.02 + 10 x 0.008 | US$0.10 |
| Two keywords across six countries, with related queries | 0.02 + 12 x 0.008 + 12 x 0.004 | US$0.164 |

The same two-keyword job on Gold and above: 0.02 + 12 x 0.005 + 12 x 0.004 = US$0.128.

`maxItems` defaults to 100 billable records, so a first run costs at most 0.02 + 100 x 0.008 = US$0.82 on the Free plan.

### Integrations

Actor ID: `asia-data-desk/google-trends-sea`. Get your API token in Apify Console under Settings > Integrations.

Python ([Apify API client](https://docs.apify.com/api/client/python), `pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("MY-APIFY-TOKEN")
run = client.actor("asia-data-desk/google-trends-sea").call(run_input={
    "mode": "compare",
    "keywords": ["electric vehicle"],
    "countries": ["US", "GB", "AU", "SG"],
    "timeframe": "today 3-m",
})
for item in client.dataset(run.default_dataset_id).list_items().items:
    print(item["country"], item["average"], item["peak"])
```

curl ([run synchronously and get dataset items](https://docs.apify.com/api/v2/act-run-sync-get-dataset-items-post); add `&format=csv` for CSV):

```bash
curl -X POST "https://api.apify.com/v2/acts/asia-data-desk~google-trends-sea/run-sync-get-dataset-items?token=MY-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode": "trending_now", "countryPreset": "SEA"}'
```

The synchronous endpoint waits up to 300 seconds; for large compare runs, start the run and read the dataset when it finishes.

- **Make:** use Apify's native Make integration to run the Actor and pass the dataset to the next module ([docs](https://docs.apify.com/platform/integrations/make)).
- **Zapier:** use Apify's Zapier integration to trigger a run and act on the results ([docs](https://docs.apify.com/platform/integrations/zapier)).
- **n8n:** use Apify's n8n node to run the Actor inside a workflow ([docs](https://docs.apify.com/platform/integrations/n8n)).
- **AI agents:** connect an agent to Apify's MCP server and it can find, call and read this Actor like any other tool ([docs](https://docs.apify.com/platform/integrations/mcp)).

### FAQ

#### How accurate is the shared scale?

Up to five countries come straight from one Google request, nothing derived. Six or more are joined through an anchor country. Measured on 18 October 2026 for "durian" over 12 months: the six-country joined series matched Google's own five-country request within 1 point on the 0-100 scale at all 54 weekly points. A live ten-country check on 19 October 2026 ("electric vehicle", 3 months, daily) matched a direct Google request within 1 point at all 465 points compared. If the anchor is too weak to join a batch reliably, the Actor says so in `scale_method` instead of guessing (see How the one-scale comparison works).

#### What happens if Google rate-limits the run?

The Actor sends at most one request every 2 seconds. On HTTP 429 or Google's "unusual traffic" redirect it waits 8, 20 and 45 seconds and retries, then stops cleanly and keeps what it already has. Blocked requests are never charged. If it keeps happening, try later, use fewer keywords or countries, or switch on an Apify datacenter proxy group.

#### Which countries are supported?

Compare mode takes any assigned two-letter ISO 3166-1 country code (the United Kingdom is `GB`), up to 15 per run, or one of the presets. Trending now works for the 125 country codes Google serves a trending feed for (probed on 19 October 2026).

#### Why does a country return no trending searches?

Google has no trending feed for some countries, including CN, BN and LA. The Actor logs it, counts the country in `countries_failed` and charges nothing. Compare mode still works for those countries.

#### How fresh is the data?

Every run fetches live from Google Trends at run time; nothing is cached. Trending records carry `fetched_at`. Interest series run up to the latest period Google publishes, and the current, still-filling period is marked `partial`.

#### Can I cap what a run costs?

Yes. `maxItems` caps billable records for the whole run (default 100). The Actor also stops when the spending limit you set for the run on Apify is reached.

#### Am I charged for failed or empty results?

No. Beyond the start fee you are not charged for blocked requests, invalid records, duplicates, series where Google reports no data, empty related-query or subregion sets, a country Google maps only by city, or a country without a trending feed.

#### Is it legal to use? Does it respect robots.txt?

It reads public Google Trends data that the Trends website serves without a login. It downloads `trends.google.com/robots.txt` at the start of every run and refuses any request it disallows; the only disallowed paths (`/explore?`, `/trends/explore?`) are pages the Actor never requests. Google's Trends help page says Trends information can be used subject to the Google Terms of Service, with attribution to Google. This is a description, not legal advice; you are responsible for how you use the data.

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

Not on one scale. Each keyword is scaled across countries on its own 0-100 scale, so "durian" and "bubble tea" rows in the same run are not comparable with each other. Compare countries within a keyword.

#### Can I export to CSV or Excel?

Yes. Every Apify dataset exports as JSON, CSV, Excel, XML, HTML or RSS from the Console or the API (`format=csv`).

### Country presets

Pick `countryPreset`, or list your own `countries` (an explicit list overrides the preset).

| Preset | Countries | Count |
|---|---|---|
| `SEA` (default) | SG MY ID TH VN PH | 6 |
| `ASEAN` | SG MY ID TH VN PH BN KH LA MM | 10 |
| `APAC` | AU CN HK IN ID JP KR MY NZ PH SG TH TW VN | 14 |
| `EU5` | DE ES FR IT NL | 5 |
| `ANGLO` | AU CA GB IE NZ US | 6 |
| `G7` | CA DE FR GB IT JP US | 7 |

### Input

| Field | Meaning | Default |
|---|---|---|
| `mode` | `trending_now` or `compare` | `trending_now` |
| `countryPreset` | `SEA`, `ASEAN`, `APAC`, `EU5`, `ANGLO` or `G7`; used when `countries` is empty | `SEA` |
| `countries` | Up to 15 ISO 3166-1 alpha-2 codes. Overrides the preset | empty (use the preset) |
| `keywords` | Compare mode: 1 to 5 search terms, up to 100 characters each | none |
| `timeframe` | Compare mode: `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`, `today 3-m`, `today 12-m`, `today 5-y`, `all`, or `YYYY-MM-DD YYYY-MM-DD` | `today 12-m` |
| `includeRelated` | Compare mode: add a related-queries record per keyword and country | `false` |
| `includeSubregions` | Compare mode: add an interest-by-subregion record per keyword and country | `false` |
| `category` | Compare mode: Google Trends category id, `0` means all categories | `0` |
| `maxRelatedPerList` | Cap on each of the top and rising lists (1 to 25) | 25 |
| `maxItems` | Cap on billable records for the whole run | 100 |
| `proxyConfiguration` | Optional Apify Proxy, datacenter groups only. Residential groups and custom proxy URLs are refused | off |

In `trending_now` mode the compare-only fields are ignored, never rejected. A trending run over `APAC` (about 130 records) needs `maxItems` above its default of 100.

### Category ids

`category` narrows interest, related-query and subregion results to one Google Trends category. Google echoes the category it applied; if the echo differs, that keyword fails uncharged rather than being sold under the wrong category. A few ids, from Google's own public category list (`https://trends.google.com/trends/api/explore/pickers/category`, fetched 2026-10-19):

| id | name |
|---|---|
| 0 | All categories |
| 3 | Arts & Entertainment |
| 7 | Finance |
| 12 | Business & Industrial |
| 71 | Food & Drink |
| 45 | Health |
| 18 | Shopping |
| 67 | Travel |

Any other whole number from 0 to 100000 is passed to Google unchanged.

### How the one-scale comparison works

Google's compare request accepts at most five places (six returns HTTP 400). More countries take several requests joined through one **anchor** country:

1. Request 1 holds the first five countries. The anchor is the country with the highest interest in it.
2. Each further request holds the anchor plus up to four new countries, rescaled by (anchor in request 1) / (anchor in that request). This is only done when the anchor reads at least 10 in both requests.
3. Everything is then rescaled so the overall peak is 100.

| Countries | Requests (each is one explore call plus one data call) |
|---|---|
| 1 to 5 | 1 (Google's own scale) |
| 6 to 9 | 2 |
| 10 to 13 | 3 |
| 14 to 15 | 4 |

Every interest record states its `scale_method`:

- `google_native`: one Google request, nothing derived.
- `anchor_rescaled`: two or more requests joined through `scale_anchor`; every country shares one scale.
- `separate_scales`: the anchor peaked below 10 in a request (or the requests share no dates), so joining would be unreliable. That keyword's records say exactly which countries share a scale in `compared_countries` and `scale`. Expect this when one country is more than ten times bigger than the anchor.

### Data source

Public Google Trends endpoints that serve the Trends website without a login: the daily trending RSS feed (`/trending/rss`) and the JSON endpoints behind the interest charts (`/trends/api/explore`, `/trends/api/widgetdata/...`). If you republish the data, cite it as: Data source: Google Trends (https://www.google.com/trends). This Actor is not made, endorsed or sponsored by Google.

### Limits

- **Relative numbers.** Interest values are Google's 0-100 index from a sample of searches, not search counts. Two requests a few minutes apart can differ by a point. Low-volume terms show zeros.
- **Rate limits.** Google throttles Trends traffic, and the first compare call of a new session is sometimes redirected to an "unusual traffic" page; the backoff above usually gets through on the fourth attempt. Waiting time counts as run time. The Actor does not solve CAPTCHAs, run a browser or use residential proxies.
- **More countries, more requests.** 15 countries and 5 keywords is up to 40 requests before related queries, at least 80 seconds. If Google blocks a run part-way, the keyword in progress is lost (uncharged); delivered keywords are kept.
- **Trending feed.** About 10 searches per country, current list only, no category or time-window filter. 124 of 249 country codes have no feed; `APAC` returns 13 countries and `ASEAN` 8.
- **Subregions.** Values run 0-100 within each country, never across countries. Singapore is mapped by city, not subregion, so it gives no record. Subregions without enough data are left out.
- **Scope.** Up to 15 countries per run, web search only, one category per run, no city breakdown.
- **Unofficial interface.** These endpoints are not a documented API and can change without notice. If the response shape changes, records fail validation and are dropped uncharged.

### Keywords

Google Trends scraper, Google Trends API, compare Google Trends across countries, interest over time by country, trending searches by country, related queries, keyword research by market, Southeast Asia search trends.

### Changelog

- 2026-10-20: Store page rewritten (use cases, quick start, FAQ, integrations). No change to the Actor's behaviour or prices.
- 2026-10-19: Published on the Apify Store; verified on the platform (trending, six countries, 60 records, none failed). Plan discounts added for trending searches and interest series.

# Actor input Schema

## `mode` (type: `string`):

trending_now: the current trending searches per country (about 10 per country). compare: interest over time per keyword and country, with optional related queries.

## `countryPreset` (type: `string`):

A ready-made group of countries, used when the Countries field below is empty. SEA: SG MY ID TH VN PH. ASEAN: SG MY ID TH VN PH BN KH LA MM. APAC: AU CN HK IN ID JP KR MY NZ PH SG TH TW VN. EU5: DE ES FR IT NL. ANGLO: AU CA GB IE NZ US. G7: CA DE FR GB IT JP US.

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

Optional. Up to 15 two-letter ISO 3166-1 country codes, for example US, GB, SG, JP (the United Kingdom is GB). If you list any, the preset is ignored. Leave empty to use the preset. Compare mode needs one extra request for every four countries beyond the first five.

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

1 to 5 search terms, used only in compare mode. Each keyword is compared across the chosen countries on its own 0-100 scale, so keywords are not compared with each other.

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

One of: now 1-H, now 4-H, now 1-d, now 7-d, today 1-m, today 3-m, today 12-m, today 5-y, all, or a custom range written as 'YYYY-MM-DD YYYY-MM-DD'. Short windows give hourly or minute data; today 12-m gives weekly data.

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

Add one related-queries record (top and rising) per keyword and country. This adds one request per keyword and country, so runs take longer and cost more.

## `includeSubregions` (type: `boolean`):

Add one record per keyword and country with the interest of each subregion, strongest first, billed as a subregion-set. Values run 0-100 within each country only: they cannot be compared between countries. Countries Google maps only by city (for example Singapore) give no record and cost nothing.

## `category` (type: `integer`):

Google Trends category id; 0 means all categories. Narrows the interest, related and subregion results to one category, for example 71 is Food & Drink. Ignored in trending_now mode.

## `maxRelatedPerList` (type: `integer`):

Cap on entries in each of the top and rising lists of a related-queries record.

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

Hard cap on billable records (trending items, interest series and related sets together). The default keeps a first run under about US$1.

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

Off by default. If Google rate-limits the shared platform IP, switch on Apify Proxy and choose a datacenter group. Residential proxies are refused. Custom proxy URLs are not supported.

## Actor input object example

```json
{
  "mode": "trending_now",
  "countryPreset": "SEA",
  "countries": [
    "US",
    "GB",
    "SG"
  ],
  "keywords": [
    "electric vehicle"
  ],
  "timeframe": "today 12-m",
  "includeRelated": false,
  "includeSubregions": false,
  "category": 0,
  "maxRelatedPerList": 25,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All records from this run (see the Output tab views for each record type).

# 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 = {
    "keywords": [
        "durian",
        "bubble tea"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("asia-data-desk/google-trends-sea").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 = {
    "keywords": [
        "durian",
        "bubble tea",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("asia-data-desk/google-trends-sea").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 '{
  "keywords": [
    "durian",
    "bubble tea"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call asia-data-desk/google-trends-sea --silent --output-dataset

```

## MCP server setup

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

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/3Ce5llC0diLnlcejU/builds/tLoykfckfiOfmsrqs/openapi.json