# 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
- **Stats:** 36 total users, 28 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 keyword results

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/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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## 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

### 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 [Keyword Fan-out](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
- Bulk-friendly: lists run in parallel batches of 1,000 keywords

### 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 Keyword Fan-out

Run [Keyword Fan-out](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 — unlike batch-priced tools where checking 5 keywords costs the same as 1,000
- Ideas mode is capped by `maxIdeas` (default 100), so a single seed never surprises you with a huge bill

### FAQ

**Is this real Google data?**
Yes — metrics come from Google Ads Keyword Planner data (the same source advertisers use for campaign planning), not a third-party estimate database.

**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 [Keyword Fan-out](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.

### Related actors

- [Keyword Fan-out — Autocomplete Keyword Discovery](https://apify.com/aitorsm/keyword-fanout) — discover 100s of long-tail keywords, then enrich them here (`enrichVolume`)
- [Keyword FAQ Generator](https://apify.com/aitorsm/keyword-faq-generator) — turn keywords into FAQ/PAA-style content briefs
- [Google Search Scraper](https://apify.com/apify/google-search-scraper) — SERP results for your target keywords
- [Email Extractor](https://apify.com/aitorsm/email-extractor) — extract contacts from the sites ranking for your keywords

### 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 single seed can expand into ~1,000 ideas. Raise it deliberately for big expansions. Ignored in metrics mode.

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

Country code/name (us, gb, es, de, france…) or a numeric geoTargetConstant id. Leave empty for worldwide.

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

Language code/name (en, es, de, french…) or a numeric languageConstant id. Leave empty for all languages.

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

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

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

Include adult keywords in the results.

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

Parallel batch requests to the metrics service. Keep modest to respect API quota.

## 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",
  "includeAdultKeywords": false,
  "maxConcurrency": 5
}
```

# 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"
};

// 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",
}

# 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("💾 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 '{
  "keywords": [
    "facebook",
    "google",
    "youtube"
  ],
  "geo": "us",
  "language": "en"
}' |
apify call aitorsm/keyword-volume --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=aitorsm/keyword-volume",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Keyword Search Volume — Bulk Google Metrics (CPC & Trend)",
        "description": "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.",
        "version": "0.0",
        "x-build-id": "96TlY26A4DdYKCnUW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aitorsm~keyword-volume/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aitorsm-keyword-volume",
                "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/aitorsm~keyword-volume/runs": {
            "post": {
                "operationId": "runs-sync-aitorsm-keyword-volume",
                "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/aitorsm~keyword-volume/run-sync": {
            "post": {
                "operationId": "run-sync-aitorsm-keyword-volume",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "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.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "metrics",
                            "ideas"
                        ],
                        "type": "string",
                        "description": "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).",
                        "default": "metrics"
                    },
                    "maxIdeas": {
                        "title": "Max idea rows (ideas mode)",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Ideas mode only: cap on the TOTAL number of keyword rows returned (seeds + expansions) — you are charged per returned row, and a single seed can expand into ~1,000 ideas. Raise it deliberately for big expansions. Ignored in metrics mode.",
                        "default": 100
                    },
                    "geo": {
                        "title": "Location",
                        "type": "string",
                        "description": "Country code/name (us, gb, es, de, france…) or a numeric geoTargetConstant id. Leave empty for worldwide."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code/name (en, es, de, french…) or a numeric languageConstant id. Leave empty for all languages."
                    },
                    "network": {
                        "title": "Network",
                        "enum": [
                            "GOOGLE_SEARCH",
                            "GOOGLE_SEARCH_AND_PARTNERS"
                        ],
                        "type": "string",
                        "description": "Search only, or Search + partner sites (higher volumes).",
                        "default": "GOOGLE_SEARCH"
                    },
                    "includeAdultKeywords": {
                        "title": "Include adult keywords",
                        "type": "boolean",
                        "description": "Include adult keywords in the results.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Parallel batch requests to the metrics service. Keep modest to respect API quota.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```