# Breakout Keywords from Trends (`steadyfetch/breakout-keywords-scraper`) Actor

Never charged for an empty result. Breakout and rising search queries from Google Trends with the real growth percentage behind Google's Breakout label, plus current interest and the 12-month curve — by seed keyword, country and category.

- **URL**: https://apify.com/steadyfetch/breakout-keywords-scraper.md
- **Developed by:** [Steadyfetch Team](https://apify.com/steadyfetch) (community)
- **Categories:** SEO tools, AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 breakout keywords

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?

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

## Breakout Keywords from Trends

**Seed keywords in, Google's rising and Breakout queries out — with the growth number Google's own
UI hides.** When a query grows more than about +5,000%, Google Trends stops showing a percentage and
prints the word `Breakout`. The number is still in the payload, and this actor ships it: `nike mind
001` comes back as `+57,450%`, not as a label. A seed with no rising data comes back as an honest row
you are not charged for.

*Unofficial. This actor is not affiliated with, endorsed by, or sponsored by Google. "Google" and "Google Trends" are trademarks of Google LLC, used here only to describe what this tool reads.*

Issues answered in about 3 hours.

You only pay for keyword rows that are delivered. Every row carries `status` and `charged`, so the
invoice reconciles against the dataset itself. **Only rows with `charged: true` were billed.**

***

### Output

Real output, unedited:

```json
{
  "schemaVersion": 1,
  "seedKeyword": "ai agents",
  "query": "moltbook",
  "kind": "rising",
  "rank": 1,
  "isBreakout": true,
  "growthPercent": 64700,
  "value": 64700,
  "formattedValue": "Breakout",
  "trendsUrl": "https://trends.google.com/trends/explore?q=moltbook&date=today+12-m",
  "timeline": null,
  "geo": "",
  "timeRange": "today 12-m",
  "category": 0,
  "status": "ok",
  "message": null,
  "charged": true,
  "fetchedAt": "2026-08-27T05:52:11.104Z"
}
```

And the row you are **not** charged for, when a seed has too little search volume for Google to
compute a rising list at all:

```json
{
  "seedKeyword": "best project management software for small teams",
  "query": null,
  "status": "no_rising_data",
  "charged": false,
  "message": "Google Trends has no rising queries for this seed in the selected time range and region — this row was not charged. Seeds need real search volume before Google will compute a rising list."
}
```

**[Browse the full live example dataset →](https://api.apify.com/v2/datasets/MbHtaaCyMYqeGkq2m/items?clean=true\&format=json)**
— real output from a verified run: 12 rows, including one seed that returned nothing and was not
charged.

`isBreakout` is Google's own label and nothing else — we never derive it from the number. A query at
`+1,500%` is a big riser and is still not a Breakout, because Google did not call it one.

| Field | What it is |
|---|---|
| `seedKeyword` | the seed you passed |
| `query` | the rising (or top) query Google returned for it |
| `kind` | `rising` or `top` |
| `rank` | position in that list, 1 = strongest |
| `isBreakout` | `true` only when Google's own label is `Breakout` |
| `growthPercent` | the growth number — present on every rising row, Breakout rows included |
| `value` / `formattedValue` | Google's raw pair, exactly as returned |
| `trendsUrl` | the Google Trends page for that query |
| `timeline` | the 12-month curve, when you ask for it |
| `status` / `message` / `charged` | the honesty contract, see below |

The dataset schema and Output tab carry the same fields, so `status` and `charged` filter cleanly in
the console, the API and any spreadsheet export.

***

### Agent / API paste-block

```
Actor:      steadyfetch/breakout-keywords-scraper
Required:   searchTerms           (array of seed keywords — leave empty to get a sample of the output)
Optional:   geo                   (string, "" = worldwide, or "US", "GB", "DE", "US-CA")
            timeRange             (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 — default "today 12-m")
            category              (integer Google Trends category id, default 0 = all)
            breakoutOnly          (boolean, default false — only rows Google labels "Breakout")
            minGrowthPercent      (integer, default 0 — drop rising rows under this growth)
            includeTop            (boolean, default false — also return the top-queries list)
            maxResultsPerKeyword  (integer 1-25, default 25 — Google's own ceiling is 25)
            includeTimeline       (boolean, default false — attach the 12-month curve)
            timelineLimit         (integer 0-25, default 5 — curves per seed)
Charges:    breakout-keyword      once per delivered keyword row
Build spec: https://apify.com/steadyfetch/breakout-keywords-scraper/api
Token:      https://console.apify.com/settings/integrations
```

```bash
curl -X POST "https://api.apify.com/v2/acts/steadyfetch~breakout-keywords-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["ai agents","weight loss"],"geo":"US","breakoutOnly":true}'
```

Calling from an agent or MCP client: **omit** an option you do not want rather than sending `null` —
the platform rejects an explicit `null` before the run is even created.

***

### What each seed costs

One event, `breakout-keyword`, charged once per delivered keyword row — **from $1.50/1,000 breakout
keywords** on the volume tier, $0.0060 each on the free plan. No start fee, no minimum, no
subscription. Google caps each list at 25 rows per keyword, so a seed that returns a full rising set
is 25 rows; the median across 90 measured keyword × country combinations was 23.

Rows that were **not** charged, and never will be:

| `status` | What happened |
|---|---|
| `no_rising_data` | Google returned no rising queries for this seed (usually too little search volume) |
| `no_match` | rising queries existed but your filters removed all of them |
| `upstream_unavailable` | Google refused the fetch after every retry — re-run shortly |
| `demo` | the sample rows you get when the run has no search terms |

`Maximum cost per run` is the ceiling. The run stops cleanly against it and tells you how many seeds
were left, rather than being killed mid-way.

***

### Which seeds actually return data

Measured over 90 keyword × country combinations before this actor was built:

| Seed type | Returned a rising set |
|---|---|
| commercial head terms (`weight loss`, `crypto`) | 10 / 10 |
| brands (`nike`, `adidas`) | 10 / 10 |
| head terms (`insurance`, `mortgage`) | 10 / 10 |
| news spikes (`us open`) | 10 / 10 |
| mid-tail commercial (`skincare`, `electric vehicles`) | 15 / 15 |
| seasonal (`halloween costumes`) | 8 / 10 |
| thin niche phrases (`mechanical keyboard switches`) | 4 / 10 |
| whole sentences (`best project management software for small teams`) | 0 / 10 |

**Anything a keyword researcher would realistically type comes back full.** Sentences and very thin
niches come back empty — and an empty seed is never charged. Use the head term instead.

Country matters: the same seed returns different rising queries in the US, GB, IN and DE. So does
`category` — `ai agents` under *Computers & Electronics* returns a different top rising query than
under *all categories*.

***

### Chaining: from a breakout keyword to the ads already running on it

The natural next question after "what is breaking out?" is "who is already advertising on it, and
what do their ads say?" Look the breakout query up in an ad library, then hand the advertiser
domain or the ad links to the matching actor below and get the words those ads actually use.

There is a ready-made n8n workflow template here: github.com/steadyfetch/n8n-templates

***

### Freshness and failures

Rising data is computed by Google against the time range you pick, and it moves daily — the same
seed can return a different rising set tomorrow. Rows carry `fetchedAt` so you always know when a
figure was true.

This actor may fail when the platform changes things — failed items are never charged.

***

### FAQ

**How do I find breakout keywords on Google Trends?**
Pass your seed keywords in `searchTerms`. Each seed returns Google's rising related queries, and the
ones Google labels `Breakout` carry `isBreakout: true` plus the real growth percentage.

**What does "Breakout" mean in Google Trends?**
Google prints `Breakout` instead of a percentage when a query's growth is above roughly +5,000%.
It is a display cut-off, not a separate metric — this actor gives you the underlying number.

**Can I get rising keywords for a specific country?**
Yes, set `geo` to a country code (`US`, `GB`, `DE`) or a sub-region (`US-CA`). Leave it empty for
worldwide.

**Can I filter to only the fastest-growing queries?**
Set `breakoutOnly: true` for Google-labelled Breakouts, or `minGrowthPercent` for a numeric floor.
Filtered-out rows are never charged.

**Why did my keyword return no rising data?**
Google needs enough search volume to compute a rising list. Whole sentences and very thin niche
phrases usually return nothing at all — you get an uncharged `no_rising_data` row instead of an
empty run.

**Does it return related topics as well as queries?**
No — this actor is built around rising and Breakout **queries** only. Related **topics** are a
different surface, and its sibling
[Google Trends · No Charge on Miss](https://apify.com/steadyfetch/google-trends-scraper) delivers
them: add `relatedTopics` to that actor's `surfaces` for the top and rising topic entities with
their knowledge-graph ids.

**Can I use this through an MCP server?**
Yes. It is a standard Apify actor, so any MCP client that can call Apify actors can call it.

**Why does a run cost more than the keyword rows?**
Apify bills platform usage (compute and proxy) for what a run actually consumes, separately from
these events. `Maximum cost per run` is the ceiling that covers both.

***

### Steadyfetch trends & keyword suite

One actor per surface, one job each, the same contract everywhere: **all-inclusive pay per event,
no start fee, charged only on delivery** — so a workflow built for one of them ports to the next.

| What you want | Actor |
|---|---|
| Interest over time, related queries, regions, compare | [Google Trends · No Charge on Miss](https://apify.com/steadyfetch/google-trends-scraper) |
| What is trending right now, by country | [Google Trends Now · No Start Fee](https://apify.com/steadyfetch/google-trends-now-scraper) |
| Rising and Breakout queries, with the real growth number | **this actor** |
| Autocomplete suggestions across 5 engines | [Autocomplete Keywords · 5 Engines](https://apify.com/steadyfetch/google-keyword-suggest-scraper) |
| Monthly search volume and CPC for a keyword list | [Keyword Volume & CPC · No Minimum](https://apify.com/steadyfetch/keyword-search-volume-scraper) |
| What is trending on social platforms | [Social Trends · 4 Platforms](https://apify.com/steadyfetch/social-trends-scraper) |

**The rest of the steadyfetch shelf** — same contract everywhere: all-inclusive pay per event,
no start fee, charged only on delivery.

| Family | Actors |
|---|---|
| Ad creative intelligence | [Facebook](https://apify.com/steadyfetch/facebook-ads-transcript-scraper) · [Google Ads video](https://apify.com/steadyfetch/google-ads-video-transcript-scraper) · [TikTok](https://apify.com/steadyfetch/tiktok-ads-transcript-scraper) · [LinkedIn](https://apify.com/steadyfetch/linkedin-ads-transcript-scraper) · [Google Ads text & OCR](https://apify.com/steadyfetch/google-ads-creative-text-scraper) |
| **Trends & keywords** | [Google Trends](https://apify.com/steadyfetch/google-trends-scraper) · [Trends Now](https://apify.com/steadyfetch/google-trends-now-scraper) · [Breakout keywords](https://apify.com/steadyfetch/breakout-keywords-scraper) · [Autocomplete keywords](https://apify.com/steadyfetch/google-keyword-suggest-scraper) · [Keyword volume & CPC](https://apify.com/steadyfetch/keyword-search-volume-scraper) · [Social trends](https://apify.com/steadyfetch/social-trends-scraper) |
| YouTube transcripts | [YouTube videos](https://apify.com/steadyfetch/youtube-transcript-scraper) · [YouTube channels](https://apify.com/steadyfetch/youtube-channel-transcripts) |
| Instagram | [Reel transcripts](https://apify.com/steadyfetch/instagram-reel-transcript-scraper) · [Profile posts](https://apify.com/steadyfetch/instagram-profile-posts) |
| Jobs | [Indeed](https://apify.com/steadyfetch/indeed-jobs-scraper) · [Career sites by domain](https://apify.com/steadyfetch/company-jobs-by-domain) · [Glassdoor](https://apify.com/steadyfetch/glassdoor-jobs-scraper) · [Multi-board](https://apify.com/steadyfetch/multi-job-board-scraper) |
| Amazon | [Products](https://apify.com/steadyfetch/amazon-product-scraper) · [Search](https://apify.com/steadyfetch/amazon-search-scraper) · Bestsellers · Sellers |
| Any media file | [Speech to Text](https://apify.com/steadyfetch/media-transcriber) · any link or file |

Unlinked names are publishing shortly on the same account — search **steadyfetch** on Apify Store.

***

### Free templates

[github.com/steadyfetch/n8n-templates](https://github.com/steadyfetch/n8n-templates) —
import-validated n8n workflows.

# Actor input Schema

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

Seed keywords, one per line. Each seed returns its own rising queries. Seeds need real search volume: head terms, brands and product categories work; whole sentences usually return no rising data (you are not charged for those). Leave empty to see a sample of the output.

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

Two-letter country code (US, GB, DE), a sub-region (US-CA), or empty for worldwide. Rising queries differ a lot by country.

## `timeRange` (type: `string`):

The window Google compares against to decide what is rising.

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

Google Trends category id to narrow the results: 0 = all categories, 3 = News, 5 = Computers & Electronics, 7 = Finance, 12 = Business & Industrial, 45 = Health, 71 = Food & Drink, 1227 = Software. Each category returns a genuinely different set.

## `breakoutOnly` (type: `boolean`):

Keep only the queries Google itself labels "Breakout" (growth above roughly +5,000%). The top-queries list is skipped in this mode, since a top query is never a Breakout.

## `minGrowthPercent` (type: `integer`):

Drop rising queries below this growth percentage. 0 keeps everything. Applies to rising rows only — the top-queries list has interest scores, not growth.

## `includeTop` (type: `boolean`):

Add Google's top (most-searched) related queries alongside the rising ones. These rows carry an interest score of 0-100 instead of a growth percentage, and they are charged like any other delivered row.

## `maxResultsPerKeyword` (type: `integer`):

Cap the rows kept per seed and per list. Google returns at most 25 rising and 25 top queries per keyword, so 25 is the ceiling.

## `includeTimeline` (type: `boolean`):

Attach the interest-over-time curve behind each rising query. Off by default: every curve is an extra pair of requests, so a full seed takes minutes instead of seconds. Rows are never charged more for it.

## `timelineLimit` (type: `integer`):

How many of the top rising queries per seed get a curve when the option above is on.

## Actor input object example

```json
{
  "searchTerms": [
    "ai agents"
  ],
  "geo": "",
  "timeRange": "today 12-m",
  "category": 0,
  "breakoutOnly": false,
  "minGrowthPercent": 0,
  "includeTop": false,
  "maxResultsPerKeyword": 25,
  "includeTimeline": false,
  "timelineLimit": 5
}
```

# Actor output Schema

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

One row per query, with Google's own Breakout label and the growth percentage behind it. Seeds with no rising data ship as uncharged rows (charged: false).

## `summary` (type: `string`):

Seeds planned, delivered, charged and skipped, plus any input warnings.

## `errors` (type: `string`):

Present only when a seed failed after every retry: the seed and the reason.

# 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": [
        "ai agents"
    ],
    "geo": "",
    "category": 0,
    "minGrowthPercent": 0,
    "maxResultsPerKeyword": 25,
    "timelineLimit": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyfetch/breakout-keywords-scraper").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": ["ai agents"],
    "geo": "",
    "category": 0,
    "minGrowthPercent": 0,
    "maxResultsPerKeyword": 25,
    "timelineLimit": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("steadyfetch/breakout-keywords-scraper").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": [
    "ai agents"
  ],
  "geo": "",
  "category": 0,
  "minGrowthPercent": 0,
  "maxResultsPerKeyword": 25,
  "timelineLimit": 5
}' |
apify call steadyfetch/breakout-keywords-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyfetch/breakout-keywords-scraper"
        }
    }
}

```

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/pKqBf8OyrxUy5I8eX/builds/uP91n4kWQZBZTu8by/openapi.json