# Google Trends Keyword Research: Rising Queries (`deepmine/google-trends-keyword-research`) Actor

Google Trends keyword research scraper and API: rising and top related queries (with Breakout flags), interest over time and interest by region for any keywords, country and date range, one row per keyword plus a Rising queries table. No login, no browser.

- **URL**: https://apify.com/deepmine/google-trends-keyword-research.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.19 / 1,000 search terms

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 Keyword Research: Rising Queries

Keyword research with Google Trends: type your keywords and get the rising and top related queries Google shows for each (with Breakout flags), plus interest over time and interest by region, for any country, time range, category or search type.

| 🔍 Keyword | 🚀 Rising query | 📈 Growth |
|---|---|---|
| bitcoin | how to buy bitcoin safely | Breakout |
| bitcoin | spacex stock | +1,750% |
| taylor swift | taylor swift toy story 5 | Breakout |
| air fryer | best air fryer 2026 | Breakout |
| air fryer | ninja glass air fryer | +700% |

<sub>Collected 2026-10-05 from the prefilled run (United States, past 12 months).</sub>

**$0.59 per 1,000 search terms on Starter** ($1.19 Free, $0.29 Scale, $0.19 Business). The prefilled run (3 terms: bitcoin, taylor swift, air fryer) costs about $0.002. Keywords Google has no data for are free, and there's no start fee.

### What you get for each keyword

- **Rising related queries**: up to 25 searches growing fastest around your keyword, with Google's value (`+1,750%`, `Breakout`), a Breakout flag and a link to each on Google Trends. The **Rising queries** table view puts each one on its own line.
- **Top related queries**: the 25 most-searched related searches (`topQueries` holds just the text, for spreadsheets).
- **Interest over time** (0-100, by the minute up to by the month since 2004) with peak, average, latest and change %.
- **Interest by region** (the **Regions** view), US metro area, country and city.
- Any location, time range, category (1,100+) or search type (web, YouTube, News, Images, Shopping); compare up to 5 keywords on one scale.

### How to use it

1. Put your keywords in **Search terms**, one per line, or paste Google Trends explore links.
2. Pick a **Location** and a **Time range** (past 12 months is a good start for keyword research).
3. Run it, then open the **Rising queries** view or download JSON, CSV or Excel. Schedule it weekly to catch new rising keywords early.

Repeated keywords are read once and charged once; rows come in your order as each one is ready.

### Output

One row per keyword with data, the same fields as our [Google Trends API](https://apify.com/deepmine/google-trends-api): `keyword`, `geo`, `timeframe`, summary numbers, `topQueries`, `risingQueries`, `interestOverTime`, `interestByRegion`, `interestByMetro`, `interestByCountry`, `interestByCity`, `relatedQueriesTop`, `relatedQueriesRising`, `trendsUrl` and more. Keywords without data get a free row in the **Issues** dataset.

### Feedback

Questions, a missing field or a bug? Open an issue on the Issues tab; we answer within 48 hours. If the Actor saves you time, a review on its Store page helps a lot.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to look up, one per line: words (bitcoin), phrases ("electric car"), topic ids (/m/05p0rrx) or Google Trends explore links (trends.google.com/trends/explore?q=...; the link's own location, time range, category and search type are used). You pay per term that has data; terms without data are free.

## `compareTerms` (type: `boolean`):

On: each line can hold up to 5 terms separated by commas (coca cola, pepsi), and Google scores them on one scale, like the Compare box on Google Trends. Each term is still its own row.

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

Worldwide, a country or a region (state, province). US locations also get interest by metro area (DMA).

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

How far back to look. Past hour and past 4 hours come by the minute, past day and 7 days by the hour, up to 9 months by the day, then by the week or month. For any other range, set dates under Custom date range.

## `property` (type: `string`):

Which Google search to measure: web search, YouTube, Google News, Google Images or Google Shopping.

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

Narrow the data to searches in one Google Trends category (e.g. 'jaguar' in Autos & Vehicles).

## `startDate` (type: `string`):

First day (YYYY-MM-DD).

## `endDate` (type: `string`):

Last day (YYYY-MM-DD). Empty = today.

## `sections` (type: `array`):

What each row holds. City data is off by default (long lists of small places). Fewer parts = faster runs.

## `includeLowVolumeRegions` (type: `boolean`):

Also list places with little search volume (Google's own checkbox).

## `includeFlatTimeline` (type: `boolean`):

Also saves every term's interest over time as one CSV file per run (keyword, date, value), ready for spreadsheets and charts. Find it in the Output tab; each row links to it in flatTimelineUrl. Free: you pay per term, not per data point.

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

Language of place names and dates (e.g. en-US, de, ja).

## `timezoneOffsetMinutes` (type: `integer`):

Minutes BEHIND UTC, as Google Trends counts them: 0 = UTC, 300 = New York (EST), -60 = Berlin (CET). Timestamps in the rows are always UTC.

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

Stop after this many rows, e.g. 50. Each search term with data is one row. Empty = all terms.

## `maxConcurrency` (type: `integer`):

How many terms are read at once.

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

Leave as is: Google Trends answers Apify's datacenter proxy (no proxy traffic for you). A residential pick is switched to datacenter.

## Actor input object example

```json
{
  "searchTerms": [
    "bitcoin",
    "taylor swift",
    "air fryer"
  ],
  "compareTerms": false,
  "geo": "US",
  "timeframe": "today 12-m",
  "property": "web",
  "category": "0",
  "sections": [
    "interestOverTime",
    "interestByRegion",
    "interestByMetro",
    "relatedQueries",
    "relatedTopics"
  ],
  "includeLowVolumeRegions": false,
  "includeFlatTimeline": false,
  "language": "en-US",
  "timezoneOffsetMinutes": 0,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `issues` (type: `string`):

No description

## `timeline` (type: `string`):

No description

## `summary` (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 = {
    "searchTerms": [
        "bitcoin",
        "taylor swift",
        "air fryer"
    ],
    "geo": "US",
    "timeframe": "today 12-m",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/google-trends-keyword-research").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 = {
    "searchTerms": [
        "bitcoin",
        "taylor swift",
        "air fryer",
    ],
    "geo": "US",
    "timeframe": "today 12-m",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/google-trends-keyword-research").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 '{
  "searchTerms": [
    "bitcoin",
    "taylor swift",
    "air fryer"
  ],
  "geo": "US",
  "timeframe": "today 12-m",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/google-trends-keyword-research --silent --output-dataset

```

## MCP server setup

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

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/jQBtZPcdYnZxXjddv/builds/S3cX0bjqsqQuUKidb/openapi.json