# Keyword Search Volume — Bulk Google Metrics (CPC & Trend) (`aitorsm/keyword-volume`) Actor

Check Google keyword search volume, CPC & competition in bulk — real Keyword Planner data, no Google Ads account needed. 12-month trend per keyword, country/language targeting, plus an Ideas mode that expands seeds into related keywords.

- **URL**: https://apify.com/aitorsm/keyword-volume.md
- **Developed by:** [Aitor Sanchez-Mansilla](https://apify.com/aitorsm) (community)
- **Categories:** SEO tools, AI, Developer tools
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 2,968 total users, 987 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 keyword results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Keyword Search Volume — Bulk Google Metrics (CPC & Trend)

**Check Google keyword search volume, CPC, and competition for thousands of keywords at once — real Google Ads Keyword Planner data, no Google Ads account needed.** Paste your keyword list and get back average monthly searches, cost-per-click, competition, top-of-page bid ranges, and a 12-month search-volume trend for every keyword. Or switch to **Ideas mode** and expand a few seed keywords into hundreds of related keyword ideas, each with full metrics.

Use it for:

- **SEO keyword research** — prioritize terms by real search demand before writing content
- **PPC & Google Ads planning** — real CPC and top-of-page bid estimates for budget forecasting
- **Bulk search volume checks** — validate 1,000s of keywords in one run (agencies, programmatic SEO, content audits)
- **Keyword ideas generation** — expand seed terms into related keywords with volume and CPC included
- **Market & niche validation** — the 12-month trend series shows seasonality and whether demand is growing
- **AI agents & automation** — clean JSON with stable field names, ready for LLM pipelines, n8n, Make, or the Apify API

> **No keyword list yet?** Start with the [Long Tail Keyword Generator](https://apify.com/aitorsm/keyword-fanout) — it discovers hundreds of long-tail keywords and questions from one seed, and can call this actor automatically to attach volumes in the same run.

### What you get per keyword

Every dataset row is one keyword with its complete metrics:

```json
{
  "keyword": "event organizer software",
  "search_volume": 2900,
  "cpc": 40.37,
  "competition": "LOW",
  "competition_index": 33,
  "low_top_of_page_bid": 8.76,
  "high_top_of_page_bid": 48.06,
  "monthly_searches": [
    { "year": 2025, "month": "JULY", "monthly_searches": 3600 },
    { "year": 2025, "month": "AUGUST", "monthly_searches": 12100 }
  ],
  "search_partners": false,
  "language_code": "1000",
  "location_code": "2840"
}
```

| Field | Meaning |
|---|---|
| `search_volume` | Average monthly Google searches |
| `cpc` | Average cost-per-click (USD) |
| `competition` | `LOW` / `MEDIUM` / `HIGH` |
| `competition_index` | 0–100 numeric competition score |
| `low_top_of_page_bid` / `high_top_of_page_bid` | Top-of-page bid range advertisers pay (USD) |
| `monthly_searches` | Last 12 months of volume — spot trends & seasonality |
| `search_partners` | Whether partner-network volume is included |
| `language_code` / `location_code` | The language & location the metrics are for |

### Two modes

- **Metrics** (default) — measure **exactly** the keywords you provide. One row per keyword. Ideal when you already have a list (a content plan, a competitor export, or output from [Long Tail Keyword Generator](https://apify.com/aitorsm/keyword-fanout)).
- **Ideas** — treat your keywords as **seeds** and expand them into related keyword ideas, each with full metrics. `maxIdeas` (default 100) caps how many rows come back so costs stay predictable — raise it deliberately when you want a big expansion.

### Localized by location & language

Target a **specific country and language** per run (`geo: "us"`, `language: "en"`, names like `germany`/`spanish`, or numeric ids) — volumes and CPC reflect the market you actually care about, not a worldwide blur. Leave empty for worldwide/all languages.

### Input example

```json
{
  "keywords": ["event ticketing", "sell tickets online"],
  "mode": "metrics",
  "geo": "us",
  "language": "en"
}
```

- **keywords** *(required)* — your keywords (or seeds when `mode: ideas`), one per line
- **mode** — `metrics` or `ideas`
- **maxIdeas** — ideas mode only: cap on total returned rows (default 100)
- **network** — Google Search, or Search + partners
- **aiVolume** — optional add-on: also return AI-assistant search volume per keyword
- Bulk-friendly: lists run in parallel batches of 1,000 keywords

### Real-time HTTP API

Besides the batch run, the Actor runs in **Standby mode**: a warm HTTP API that answers in a second or two, with the rows in the same response — no run to start, no dataset to fetch. Batch runs work exactly as before; use them for lists over 1,000 keywords or big expansions.

```bash
## Metrics for up to 1,000 keywords
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://<standby-url>/volume?keywords=web%20scraping,event%20ticketing&geo=us&language=en"

## Related ideas for up to 20 seeds (maxIdeas default 100)
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://<standby-url>/ideas?seeds=web%20scraping&geo=es&language=es&maxIdeas=20"
```

Optional parameters: `network`, `includeTrend` (default `true`), and `aiVolume` on `/volume`. Copy the real `<standby-url>` from the Actor's **Endpoints** tab. Errors come back as `{"error":{"code","message"}}`; a `503` with `Retry-After` means the service is briefly unavailable — retry.

**AI agents:** Use Apify’s MCP connector to call this Actor as a batch run, then fetch its dataset items for the results. The Standby HTTP endpoints are separate from this connector.

**Cost per call:** the same events as a batch run — $0.012 per keyword row returned (less on higher Apify plans), plus the AI-volume event per keyword with a number when enabled.

### Why use this instead of the Google Ads API or Keyword Planner?

- **No Google Ads account, developer token, or OAuth setup** — the usual barrier to Keyword Planner data. Getting your own Google Ads API access takes days (token approval, OAuth consent screen, code). Here you paste keywords and run.
- **No monthly SEO-suite subscription** — Keyword Planner-grade numbers per run, instead of $100+/month for a full suite when you only need volumes.
- **Exact averages, not ranges** — logged-out Keyword Planner shows "1K–10K" ranges; this returns actual averages plus the monthly breakdown.
- **Automation-ready** — call it from the Apify API, schedule it, chain it with other actors, or use it from AI agents via MCP.

### Pairs with the Long Tail Keyword Generator

Run the [Long Tail Keyword Generator](https://apify.com/aitorsm/keyword-fanout) to *discover* the long-tail queries and questions around a topic, then feed them here to *rank them by real search volume*. Or just enable that actor's **enrichVolume** option — it calls this actor for you: discovery + volume in a single run.

### Pricing

Pay-per-result: you're charged **per keyword row returned** (plus a small run-start fee) — no subscription, no batch minimums.

- 100 keywords in Metrics mode → 100 rows → about a dollar
- Small test runs cost cents — checking 5 keywords costs a fraction of checking 1,000
- Ideas mode is capped by `maxIdeas` (default 100), so a single seed never surprises you with a huge bill
- The `aiVolume` add-on is off by default and charged only for keywords that come back with an AI number

### AI search volume (optional)

Google search volume tells you how many people type a keyword into Google. It says
nothing about the growing share of those questions now being asked to an AI assistant
instead.

Turn on **`aiVolume`** and every row also carries `ai_search_volume` — how often the
keyword is actually used inside AI assistants — plus `ai_monthly_searches`, the same
metric month by month.

The two numbers are genuinely different. Measured in August 2026:

| keyword | Google searches / mo | AI uses / mo |
|---|---:|---:|
| web scraping | 9,900 | 1,938 |

…and its AI trail ran 3,194 (Feb) → 2,743 (Apr) → 1,991 (Jun) → 1,938 (Jul).

Use it to spot keywords whose demand is migrating to AI answers before your Google
traffic reflects it — then check whether those AI answers mention you with the
[AI Visibility Tracker](https://apify.com/aitorsm/ai-visibility-tracker).

### FAQ

**Is this real Google data?**
Yes — metrics come from Google Ads Keyword Planner data (the same numbers advertisers use for campaign planning), not modelled estimates.

**Can I see how often a keyword is used in ChatGPT or other AI assistants?**
Yes — enable `aiVolume` and every row adds `ai_search_volume`, an estimate of how
often that keyword is actually used inside AI assistants, plus a month-by-month
series. It is a separate number from Google search volume and often tells a very
different story.

**What is AI search volume, and how is it different from Google search volume?**
Google search volume counts queries typed into Google. AI search volume estimates
how often the same keyword is used inside AI assistants. In August 2026 "web
scraping" had 9,900 Google searches a month but 1,938 AI uses — and the AI figure
had fallen from 3,194 in February, while the Google figure had not moved nearly as
much. Tracking both shows you where demand is shifting before your traffic does.

**How many keywords can I check at once?**
No hard input limit — lists are deduplicated and processed in parallel batches of 1,000. A 10,000-keyword run completes in seconds.

**What does it cost?**
You pay per keyword row returned: a 100-keyword metrics run = 100 rows. In Ideas mode, `maxIdeas` (default 100) caps the rows so one seed can't surprise you with a huge bill.

**Can I get keyword ideas, not just metrics for my list?**
Yes — set `mode: "ideas"`: your keywords become seeds and you get related suggestions with volume, CPC, and competition. For autocomplete-style discovery (questions, prepositions, comparisons), pair with [Long Tail Keyword Generator](https://apify.com/aitorsm/keyword-fanout).

**Does it show search volume for a specific country or language?**
Yes — set `geo` and `language`; metrics are localized to that market (e.g. `geo: "es", language: "es"` for Spain/Spanish).

**Why are some keywords missing or `null`?**
Google returns no metrics for negligible-volume keywords and groups close variants. Unknown fields stay `null` — never fake zeros.

**Can AI agents use this actor?**
Yes — it works through Apify's MCP integration, and the stable JSON schema above is designed to be parsed by LLM agents.

### A note on the `source` field

`google_ads` marks a row delivered by the primary path. If it reads `fallback`,
the primary path was briefly unavailable and the run was served by a backup
instead of failing — same fields, same metrics — so a scheduled job keeps
producing rows through an outage instead of leaving a hole in your history.

### Related Actors

- [Long Tail Keyword Generator](https://apify.com/aitorsm/keyword-fanout) — discover the long-tail keywords and questions around a seed, then rank them here by volume.
- [AI Visibility Tracker](https://apify.com/aitorsm/ai-visibility-tracker) — for keywords moving to AI assistants, check whether ChatGPT, Perplexity or AI Overviews mention your brand.
- [YouTube Transcript Extractor](https://apify.com/aitorsm/youtube-transcript-extractor) — transcribe the top videos for a high-volume keyword to see what existing content already covers.
- [Google Rank Tracker](https://apify.com/aitorsm/google-rank-tracker) — once you know what each keyword is worth, track where your domain actually ranks for it.

### Support

Questions or a custom keyword/volume workflow? **business@aitorsm.com**

# Actor input Schema

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

Keywords to look up (one per line). In 'metrics' mode these are measured directly; in 'ideas' mode they are seeds that get expanded into related keywords.

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

metrics = get volume/CPC/competition for exactly the keywords you provide. ideas = expand your seeds into related keywords and return their metrics too (a superset).

## `maxIdeas` (type: `integer`):

Ideas mode only: cap on the TOTAL number of keyword rows returned (seeds + expansions) — you are charged per returned row, and a few seeds can expand into thousands of ideas. Raise it deliberately for big expansions. Ignored in metrics mode.

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

Country code or name (any country: us, gb, es, ae, sg, uae, singapore, united arab emirates…) or a numeric Google location id (e.g. 2840 for the US). Leave empty for worldwide.

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

Language code/name (en, es, de, french…) or a numeric Google language id (e.g. 1000 for English). Leave empty for all languages.

## `network` (type: `string`):

Search only, or Search + partner sites (higher volumes).

## `aiVolume` (type: `boolean`):

Optional paid add-on. Adds how often each keyword is actually used inside AI assistants, plus month-by-month history — a different number from Google search volume. Example measured in August 2026: "web scraping" gets 9,900 Google searches a month but 1,938 AI uses, down from 3,194 in February. Charged only for keywords that come back with a number.

## `includeAdultKeywords` (type: `boolean`):

Include adult keywords in the results.

## Actor input object example

```json
{
  "keywords": [
    "event organizer software",
    "eventbrite alternative",
    "sell tickets online"
  ],
  "mode": "metrics",
  "maxIdeas": 100,
  "geo": "us",
  "language": "en",
  "network": "GOOGLE_SEARCH",
  "aiVolume": false,
  "includeAdultKeywords": false
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "facebook",
        "google",
        "youtube"
    ],
    "geo": "us",
    "language": "en",
    "aiVolume": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("aitorsm/keyword-volume").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": [
        "facebook",
        "google",
        "youtube",
    ],
    "geo": "us",
    "language": "en",
    "aiVolume": False,
}

# Run the Actor and wait for it to finish
run = client.actor("aitorsm/keyword-volume").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": [
    "facebook",
    "google",
    "youtube"
  ],
  "geo": "us",
  "language": "en",
  "aiVolume": false
}' |
apify call aitorsm/keyword-volume --silent --output-dataset

```

## MCP server setup

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

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/eDlqVN04IqlJpom0Z/builds/Q6mIPfwIus1hhnodg/openapi.json