# Semrush Keyword Overview Scraper — Volume, KD, CPC & Intent (`bovi/semrush-keyword-scraper`) Actor

Get Semrush keyword metrics in bulk: monthly search volume, CPC, competition, Keyword Difficulty (0-100), search intent, number of results, SERP features and the 12-month volume trend — plus optional related keyword ideas and the organic SERP. No Semrush login or API key. Pay per keyword.

- **URL**: https://apify.com/bovi/semrush-keyword-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $17.46 / 1,000 keyword metrics 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

**Pull Semrush keyword overview data at scale — search volume, Keyword Difficulty, CPC, search intent, 12-month trend, global per-country breakdowns, related keyword ideas, and the full organic SERP — with no Semrush subscription, no API key, and pay only per successful result.**

This **Semrush keyword scraper** delivers the complete keyword overview dataset for any list of keywords. Feed it your keyword list, choose a country database, and get back a structured record per keyword with every metric the Keyword Overview tool surfaces — plus structured global volumes across ~120 countries and optional organic SERP results that competing tools don't include. It runs entirely on Apify's residential proxy for reliable access, so you never need to configure anything on your end.

### Features

- **Full keyword overview metrics** — monthly search volume, CPC (USD), competition level, Keyword Difficulty (numeric 0–100), number of search results, referring domains median, and search intent (commercial / informational / navigational / transactional).
- **12-month volume trend** — a month-by-month array showing how search demand for the keyword moves over time, useful for seasonality analysis.
- **Structured global volumes** — per-country breakdown (volume, CPC, competition, KD) across ~120 country databases, returned as a structured array. Not a flat string like some alternatives — every country is a queryable object, sorted by volume descending.
- **Keyword ideas** (optional, on by default) — up to 30 related keyword suggestions per keyword, each with its own volume and KD score.
- **Organic SERP** (optional, off by default) — up to 100 organic results per keyword, including position, domain, URL, and SERP features present on each result.
- **SERP features list** — which rich results appear on the SERP (featured snippet, video, local pack, image pack, etc.).
- **No Semrush account or API key required** — the actor handles access internally.
- **Pay only for successful results** — keywords that return no Semrush data are shown in the output with an error note but are never billed.
- **Fault-tolerant delivery** — each result row is pushed to the dataset the instant it is ready, so a run timeout never discards work already completed.

### What data you get

One record per keyword. All fields verified on a live cloud run:

| Field | Description |
|---|---|
| `keyword` | The input keyword phrase |
| `database` | The country database used (e.g. `us`, `uk`, `de`) |
| `volume` | Monthly search volume in the selected country |
| `cpc` | Cost-per-click in USD |
| `competition_level` | Ad competition level (0–1 float) |
| `keyword_difficulty` | Numeric KD score (0–100) |
| `results_count` | Number of results returned by the search engine |
| `referring_domains_median` | Median referring domains of the top-10 ranking pages |
| `intents` / `intent_labels` | Search intent codes and human-readable labels |
| `serp_features` | Array of rich SERP features active for this keyword |
| `trend` | Array of 12 monthly search volume data points |
| `global_volumes` | Per-country array: database, volume, cpc, competition_level, keyword_difficulty |
| `global_country_count` | Number of countries with non-zero volume (~120 max) |
| `ideas` | Related keyword suggestions, each with phrase, volume, and KD |
| `serp` | Organic SERP rows: position, domain, url, serp_features (when enabled) |
| `checked_at` | ISO timestamp when the keyword was processed |
| `error` | Populated only on failed lookups (not billed) |

**Example result for "seo tools":** volume 40 500 · KD 90 · CPC $7.04 · results 128 · rds_median 589 · intent commercial · global_country_count 120 · ideas[30] · serp[100].

This actor is a **strict superset** of the leading alternative: where that tool ships global multi-country volume as an unstructured flat string, we return a fully structured `global_volumes[]` array per country. We also add `ideas[]`, a full organic `serp[]`, and a numeric `referring_domains_median` that the market leader does not expose.

### Input

```json
{
  "keywords": ["seo tools", "keyword research", "content marketing"],
  "database": "us",
  "includeIdeas": true,
  "maxIdeas": 30,
  "includeSerp": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | required | List of keywords to look up |
| `database` | string | `us` | Two-letter country database code (`us`, `uk`, `de`, `in`, …) |
| `includeIdeas` | boolean | `true` | Return related keyword ideas per keyword |
| `maxIdeas` | integer | `30` | Cap on ideas per keyword |
| `includeSerp` | boolean | `false` | Return the full organic SERP per keyword |
| `maxItems` | integer | `0` | Cap total keywords processed (0 = no cap) |
| `proxyConfiguration` | object | RESIDENTIAL | Proxy setting — defaults to Apify RESIDENTIAL |

### Pricing

**Pay per result, not per run.**

- **$0.018 per keyword** that returns metrics (charge event: `keyword-result`).
- Keywords that fail to return data are included in the output for transparency but are **not billed**.
- At 100 keywords, the run costs ~$1.80. The organic SERP option adds no extra cost — it is included in the same per-keyword charge.
- This rate is approximately 10% below the comparable market-leader's per-result price.

### FAQ

**Do I need a Semrush subscription or API key?**
No. This actor handles access internally using a residential proxy for reliable access. You do not need a Semrush account, a paid plan, or any external API credentials.

**How many keywords can I process per run?**
The actor is throughput-capped by design — it is built for focused, high-value keyword research rather than mass bulk extraction. It works well for typical research workloads (tens to low hundreds of keywords per run). Very large batches may run into session limits before completing; if you have a large list, split it across multiple runs and the actor will pick up reliably each time. Each successful row is pushed immediately, so no work is lost.

**Which country databases are supported?**
Any two-letter Semrush database code: `us` (United States), `uk` (United Kingdom), `de` (Germany), `fr` (France), `in` (India), `ca` (Canada), `au` (Australia), and many more. Set the `database` field to the code you need. Regardless of which database you pick, the `global_volumes[]` field returns volume data across ~120 countries in a single call.

**What is `referring_domains_median` and why does it matter?**
It is the median number of referring (linking) domains that the top-10 ranking pages have. It is a direct proxy for the link authority you need to compete for a keyword — more useful for practical SEO planning than raw KD alone, and not available in comparable scrapers.

### Use cases

**Keyword research and content planning** — bulk-fetch volume, KD, CPC, and intent for any keyword list without opening the Semrush UI. Filter by KD range or intent to find content opportunities that match your site's authority level.

**International and global SEO** — use `global_volumes[]` to compare how the same keyword performs across 120 countries in a single run. Identify markets where a keyword has high volume but lower competition before committing to a geo-expansion strategy.

**SERP analysis and competitor mapping** — enable `includeSerp` to retrieve up to 100 organic results per keyword. See exactly which domains dominate each SERP, identify SERP features that affect click-through, and map content gaps.

**Keyword clustering and topic modeling** — combine the `ideas[]` field (related suggestions with volume + KD) across multiple seed keywords to build keyword clusters and topic maps programmatically, without paying per idea lookup.

**Trend and seasonality detection** — the `trend[]` array gives 12 months of monthly search volume. Use it to detect seasonal peaks, declining topics, or emerging demand before publishing content.

# Actor input Schema

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

Keywords to look up Semrush metrics for. One row is returned per keyword.

## `database` (type: `string`):

Semrush regional database — a two-letter country code. Volume, CPC, KD and SERP are country-specific. E.g. "us", "uk", "de", "in".

## `includeIdeas` (type: `boolean`):

Also return related keyword ideas for each keyword (phrase, volume, difficulty).

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

Cap on how many related keyword ideas to return per keyword.

## `includeSerp` (type: `boolean`):

Also return the organic SERP (position, domain, url, SERP features) for each keyword.

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

Optional cap on how many keywords to process (0 = no cap).

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

Proxy used to reach the target. A residential exit is recommended for reliable access; it defaults to Apify RESIDENTIAL.

## Actor input object example

```json
{
  "keywords": [
    "seo tools",
    "keyword research"
  ],
  "database": "us",
  "includeIdeas": true,
  "maxIdeas": 30,
  "includeSerp": false,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of keyword metric records, one per keyword.

# 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": [
        "seo tools",
        "keyword research",
        "content marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/semrush-keyword-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 = { "keywords": [
        "seo tools",
        "keyword research",
        "content marketing",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bovi/semrush-keyword-scraper").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": [
    "seo tools",
    "keyword research",
    "content marketing"
  ]
}' |
apify call bovi/semrush-keyword-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Semrush Keyword Overview Scraper — Volume, KD, CPC & Intent",
        "description": "Get Semrush keyword metrics in bulk: monthly search volume, CPC, competition, Keyword Difficulty (0-100), search intent, number of results, SERP features and the 12-month volume trend — plus optional related keyword ideas and the organic SERP. No Semrush login or API key. Pay per keyword.",
        "version": "0.1",
        "x-build-id": "0hiFX4P8zFiHbTTju"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~semrush-keyword-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-semrush-keyword-scraper",
                "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/bovi~semrush-keyword-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-semrush-keyword-scraper",
                "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/bovi~semrush-keyword-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-semrush-keyword-scraper",
                "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 Semrush metrics for. One row is returned per keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "database": {
                        "title": "Database (country)",
                        "type": "string",
                        "description": "Semrush regional database — a two-letter country code. Volume, CPC, KD and SERP are country-specific. E.g. \"us\", \"uk\", \"de\", \"in\".",
                        "default": "us"
                    },
                    "includeIdeas": {
                        "title": "Include keyword ideas",
                        "type": "boolean",
                        "description": "Also return related keyword ideas for each keyword (phrase, volume, difficulty).",
                        "default": true
                    },
                    "maxIdeas": {
                        "title": "Max ideas per keyword",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on how many related keyword ideas to return per keyword.",
                        "default": 30
                    },
                    "includeSerp": {
                        "title": "Include organic SERP",
                        "type": "boolean",
                        "description": "Also return the organic SERP (position, domain, url, SERP features) for each keyword.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max keywords",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional cap on how many keywords to process (0 = no cap).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach the target. A residential exit is recommended for reliable access; it defaults to Apify RESIDENTIAL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```