# Semrush SEO API - Keyword Research, Domain & Backlinks (`pnda/semrush-keyword`) Actor

Semrush keyword research API, no login or subscription: keyword ideas with search volume, keyword difficulty, CPC and intent, plus domain overview, competitor analysis and a backlink checker. 47 countries. From $2 per 1,000 keywords.

- **URL**: https://apify.com/pnda/semrush-keyword.md
- **Developed by:** [PNDA](https://apify.com/pnda) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Features:** Limited permissions
- **Stats:** 795 total users, 357 monthly users, 100.0% runs succeeded, 19 bookmarks
- **User rating**: 4.86 out of 5 stars

## Pricing

from $1.80 / 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/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

## Semrush API Scraper - Keyword Research, Domain & Backlinks

**Semrush data without a Semrush subscription.** One actor, four modes: **keyword research** (search volume, keyword difficulty, CPC, intent, related keyword ideas), **domain overview** (authority score, traffic trend, top keywords), **competitor analysis** (organic competitors) and a **backlink checker** (authority-scored backlinks, anchors, referring domains).

No login, no API key, no cookies to manage. Pick a mode, type a keyword or a domain, choose one of **47 country databases**, click **Run**. Results land in a clean Apify dataset you can export to **JSON, CSV, Excel or HTML**, or pull from the Apify API, n8n, Make, Zapier or your own code.

***

### What can this Semrush scraper do?

| Mode | Input | What you get |
|---|---|---|
| 🔍 `keyword` - **Keyword research** | a seed keyword | Keyword ideas with search volume, keyword difficulty (KD), CPC, competition, intent, SERP features, 12-month trend. Up to 10,000 keywords per run. |
| 🌐 `domain` - **Domain overview** | a domain | Authority score, number of backlinks, organic traffic trend, top organic keywords, main competitors, referring domains. |
| 🥊 `competitors` - **Competitor analysis** | a domain | Organic competitors with competition level, shared keywords, ranking keywords, traffic, traffic value, paid keywords. |
| 🔗 `backlinks` - **Backlink checker** | a domain or URL | Authority-scored backlinks: page authority score, source URL and title, anchor text, target URL, first and last seen. |

Every mode accepts a **batch of up to 100 keywords or domains** in a single run (`queries`). Each output row carries a `query` field, so you can split the batch apart again.

***

### Why use it

- ✅ **Semrush keyword research for the price of the rows** - no $139+/month plan, no seat, no export limits.
- ✅ **Keyword difficulty, search volume and CPC in one row** - ready for content planning and PPC bid lists.
- ✅ **Keyword ideas at scale** - phrase, exact, broad and related match, up to 10,000 keywords per run.
- ✅ **47 countries** - US, UK, CA, AU, FR, DE, IT, ES, BR, NL, JP, IN, MX, AE and 33 more.
- ✅ **SEO + competitor analysis + backlinks in one actor** - one input, one dataset, one bill.
- ✅ **Pay per result** - empty results are never charged.
- ✅ **API-first** - call it from the Apify API, Python/JS clients, n8n, Make, Zapier, or schedule it.

***

### How to use it

1. Click **Try for free**.
2. Choose a **Mode** (`keyword`, `domain`, `competitors` or `backlinks`).
3. Enter a keyword (keyword mode) or a domain (other modes) in **Query**, or paste up to 100 in **Queries**.
4. Pick a **Database / country** (default `us`).
5. Click **Run**, then export the dataset.

***

### Input

| Field | Type | Modes | Description |
|---|---|---|---|
| `mode` | string | all | `keyword` (default), `domain`, `competitors`, `backlinks` |
| `q` | string | all | One keyword (keyword mode) or one domain (other modes) |
| `queries` | array | all | Batch of up to 100 keywords or domains. Takes precedence over `q` |
| `db` | string | keyword, domain, competitors | Country database: `us`, `uk`, `fr`, `de`, … (default `us`) |
| `type` | string | keyword | Match type: `phrase` (default), `exact`, `broad`, `related` |
| `pages` | integer | keyword | Pages of keyword ideas, 100 keywords per page (default `1`, max `100`) |
| `sort_by` | string | competitors | `competition_level` (default), `common_keywords`, `traffic` |
| `target` | string | backlinks | Specific URL for the backlink report (single query only) |
| `target_type` | string | backlinks | `root_domain` (default), `domain`, `url` |

#### Keyword match types

| Match type | Returns |
|---|---|
| `phrase` | Keywords containing the phrase |
| `exact` | Keywords containing the exact phrase as-is |
| `broad` | Broad variations, synonyms included |
| `related` | Semantically related keywords - ideal for topic clusters |

#### Example input - keyword research

```json
{
  "mode": "keyword",
  "q": "running shoes",
  "db": "us",
  "type": "phrase",
  "pages": 2
}
```

#### Example input - batch competitor analysis

```json
{
  "mode": "competitors",
  "queries": ["nike.com", "adidas.com", "newbalance.com"],
  "db": "uk",
  "sort_by": "common_keywords"
}
```

***

### Output

#### Keyword mode (one row per keyword)

```json
{
  "query": "running shoes",
  "phrase": "running shoes",
  "database": "us",
  "volume": 246000,
  "cpc": 0.88,
  "competition_level": 1,
  "difficulty": 71,
  "intents": [2],
  "results": 238,
  "serp_features": [3, 6, 9, 13, 25, 28, 41, 43, 50],
  "trend": [81, 44, 66, 66, 54, 66, 44, 54, 44, 81, 100, 81],
  "snapshot_date": "20260801"
}
```

| Field | Meaning |
|---|---|
| `phrase` | The keyword idea |
| `volume` | Average monthly search volume |
| `cpc` | Cost per click in USD |
| `competition_level` | Paid competition (0 → 1) |
| `difficulty` | Keyword difficulty, KD (0 → 100) |
| `results` | Number of SERP results, as reported by Semrush |
| `intents` | Search intent codes (informational, navigational, commercial, transactional) |
| `serp_features` | SERP feature codes (featured snippet, People Also Ask, local pack, video…) |
| `trend` | 12-month relative search trend (100 = peak month) |
| `snapshot_date` | Date of the Semrush data snapshot (YYYYMMDD) |

#### Domain mode (one report per domain)

```json
{
  "query": "example.com",
  "authority_score": 62,
  "number_of_backlinks": 1840233,
  "search_traffic": { "2026-07-01": 412000, "2026-08-01": 438500 },
  "competitors": [{ "domain": "competitor.com", "level": 0.31, "common_keywords": 5120, "positions": 48210 }],
  "top_keywords": [{ "phrase": "example product", "intents": [3], "cpc": 0.9, "position": 1, "traffic_percent": 4.2, "volume": 27100, "url": "https://example.com/product" }],
  "referring_domains": []
}
```

#### Competitors mode (one row per organic competitor)

```json
{
  "query": "example.com",
  "domain": "competitor.com",
  "competition_level": 0.31,
  "common_keywords": 5120,
  "se_keywords": 48210,
  "traffic": 351000,
  "traffic_cost": 210400,
  "paid_keywords": 120
}
```

#### Backlinks mode (one row per backlink)

```json
{
  "query": "example.com",
  "page_ascore": 54,
  "source_title": "The 10 best tools of the year",
  "source_url": "https://blog.example.org/best-tools",
  "external_link_num": 37,
  "internal_link_num": 112,
  "target_anchor": "Example",
  "target_url": "https://example.com/",
  "first_seen": 1718236800,
  "last_seen": 1727222400
}
```

The keyword row is a real result (October 2026, `us`). The other examples use illustrative values; field names match the real output.

***

### Use cases

- **Keyword research for SEO content** - turn one seed into hundreds of keyword ideas, sort by volume and keyword difficulty, build your content calendar.
- **Topic clusters** - use `related` match to group keywords into pillars and supporting articles.
- **PPC and Google Ads** - pull search volume, CPC and competition before you bid.
- **Competitor analysis** - find who you compete with organically, how many keywords you share and what their traffic is worth.
- **Domain authority checks** - score a list of domains by authority score and backlinks (link building, partnerships, acquisitions).
- **Backlink audits and link prospecting** - list a competitor's best backlinks with anchors and authority, then pitch the same sites.
- **International SEO** - compare the same keywords across 47 country databases.
- **Agencies and SaaS** - feed Semrush metrics into dashboards, Google Sheets, BigQuery or an AI writing pipeline.

***

### Pricing

Pay per result, billed per mode. Empty results are not charged.

| Mode | Unit | Free plan | Paid Apify plans (Bronze) |
|---|---|---|---|
| `keyword` | per keyword | $0.006 | $0.002 |
| `competitors` | per competitor | $0.0075 | $0.002 |
| `backlinks` | per backlink | $0.0075 | $0.002 |
| `domain` | per domain report | $0.02 | $0.01 |

Examples on a paid plan: 1,000 keywords ≈ **$2**, 100 domain reports ≈ **$1**. Compare with a monthly Semrush subscription.

**Store discounts:** Silver, Gold, Platinum and Diamond Apify plans pay up to 20 % less than the Bronze price. The Pricing tab of the Store page shows the exact price for each plan.

**Works with a free Apify account too**, billed at the Free plan price above from your monthly Apify credit. A query that was fetched recently may be answered from stored data (same price).

***

### Daily limits

The Semrush data behind this actor is shared by all its users, so every Apify account has a **daily allowance of Semrush requests**. It is large enough for normal use (95 % of accounts use far less), and it keeps one very big batch from blocking everybody else.

| Apify plan | Semrush requests per day |
|---|---|
| Free | 150 (free accounts also share a common daily capacity) |
| Paid (Bronze and above) | 1,000 |

**What one query uses:**

| Mode | Semrush requests per query | ≈ queries per day on a paid plan |
|---|---|---|
| `keyword` | 1 + 1 per page of 100 ideas (`pages: 1` = 2) | 500 seed keywords |
| `domain` | 6 | 166 domain reports |
| `competitors` | 1 | 1,000 domains |
| `backlinks` | 2 | 500 domains |

**The day resets at 07:30 UTC** (not at midnight).

**What happens at the limit - no surprise, no charge:**

- The run processes every query that fits, delivers and bills those results, then stops cleanly (status SUCCEEDED).
- The last dataset item explains it, for example:

```json
{
  "status": "daily-limit-reached",
  "message": "Daily limit of your account reached: 1,000 Semrush requests per day (paid Apify plan), 998 used. 63 of 100 queries were processed and billed for their results; 37 queries were not processed and not charged (listed in \"notProcessedQueries\"). Your limit resets at 07:30 UTC (in 3 h 12 min): rerun them then, or split big batches over several days. ...",
  "dailyLimit": 1000,
  "usedToday": 998,
  "queriesServed": 63,
  "queriesNotServed": 37,
  "notProcessedQueries": ["example.com", "..."],
  "retryAfter": "2026-11-07T07:30:00Z",
  "charged": false
}
```

- Rerun exactly `notProcessedQueries` after `retryAfter` and you get the rest. Nothing is ever charged for a query that was not processed.

**Rare maintenance window.** If the shared Semrush capacity itself runs out, the run stops the same way with a `service-unavailable` item: *"Service under maintenance - Semrush data is back at 07:30 UTC (in …)"*, with the same `notProcessedQueries` and `retryAfter`. A short refusal from Semrush (rate limit) is retried automatically before stopping.

**Tip for big jobs:** spread them over several days, or schedule the run daily on the remaining list.

***

### FAQ

**Can I use it on the free Apify plan?**
Yes. It works with a free Apify account too, at the Free plan price per result, with 150 Semrush requests a day (see [Daily limits](#daily-limits)). Free accounts also share a common daily capacity: when it is reached, the run ends with a `free-plan-limit` item and nothing is charged for the queries not processed. Paid Apify plans get 1,000 requests a day.

**Is there a daily limit?**
Yes, per Apify account: 150 Semrush requests a day on the free plan, 1,000 on paid plans, reset at 07:30 UTC. At the limit the run delivers what fits, bills only that, and lists the queries to rerun (`notProcessedQueries`, `retryAfter`). See [Daily limits](#daily-limits).

**Do I need a Semrush account or API key?**
No. The actor handles access for you. You only need an Apify account.

**Is this the same data as the Semrush keyword research tool?**
Yes - volume, keyword difficulty, CPC, competition, intent and SERP features come from Semrush's own keyword database, for the country database you choose.

**How many keywords can I get per run?**
Up to 10,000 for one seed keyword (`pages: 100`, 101 Semrush requests of your daily allowance). In a batch, the page budget is shared across queries (100 pages per run in total), so split very large batches across several runs.

**Can I check many domains at once?**
Yes. Put up to 100 domains in `queries`. Each row has a `query` field telling you which domain it belongs to.

**Which countries are supported?**
47 databases: us, uk, ca, au, br, fr, de, it, es, nl, se, dk, be, no, ie, ar, mx, co, cl, pe, in, sg, id, ph, my, th, vn, jp, hk, cn, tr, za, il, sa, ae, pl, cz, ro, hu, at, ch, pt, fi, gr, nz, ru, ua. Backlinks mode is global.

**Can I use it as a Semrush alternative or Ahrefs alternative for keyword research?**
If you need keyword volume, keyword difficulty, competitors and backlinks as data rather than a dashboard, yes: you pay per row instead of a monthly seat.

**Can I call it from code or no-code tools?**
Yes. Use the Apify API, the Python or JavaScript client, or the Apify integrations for n8n, Make, Zapier and Google Sheets. You can also schedule runs.

**What happens if one query in a batch fails?**
The run continues with the other queries. The failed query is logged and not charged.

***

### Related actors

- [Google SERP API](https://apify.com/pnda/google-search-scraper): Need the live Google results for your keywords? Rankings, ads and People Also Ask as JSON, any country.
- [Email Extractor](https://apify.com/pnda/email-extractor): Doing link building? Extract the contact emails of the referring domains or sites you want a link from.
- [Email Finder](https://apify.com/pnda/email-finder): Need the editor or owner behind a site? Find a named person's email from the domain.

***

### Start now

Pick a mode, type a keyword or a domain, choose a country, click **Run**. Semrush keyword research, competitor analysis and backlinks, on tap.

# Actor input Schema

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

What to extract. Keyword research, full domain overview, organic competitors, or backlink profile. Each mode uses a different set of the fields below.

## `q` (type: `string`):

One target to analyze: a keyword in `keyword` mode (e.g. "digital marketing"), a domain in `domain`, `competitors` and `backlinks` modes (e.g. "example.com"). Ignored when Queries below is filled.

## `queries` (type: `array`):

Analyze up to 100 targets in a single run instead of one run per target. Takes precedence over Query above. Every output row carries a `query` field naming the target it came from, so the batch can be split apart again.

## `db` (type: `string`):

Country database. Used in `keyword`, `domain` and `competitors` modes. Ignored in `backlinks` mode.

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

Keyword match type. Used in `keyword` mode only.

## `pages` (type: `integer`):

How many pages of keywords to fetch per query, 100 results per page. Used in `keyword` mode only.

## `sort_by` (type: `string`):

How to rank the organic competitors returned. Used in `competitors` mode only.

## `target` (type: `string`):

Specific target URL for the backlink report. Optional - defaults to the value of Query. Ignored when running a batch. If Query and Queries are both empty, this value is analyzed instead (in `domain`, `competitors` and `backlinks` modes).

## `target_type` (type: `string`):

Scope of the backlink report. Used in `backlinks` mode only.

## Actor input object example

```json
{
  "mode": "keyword",
  "q": "digital marketing",
  "db": "us",
  "type": "phrase",
  "pages": 1,
  "sort_by": "competition_level",
  "target_type": "root_domain"
}
```

# Actor output Schema

## `dataset` (type: `string`):

All rows of this run: keywords, domain reports, competitors or backlinks (JSON, CSV, Excel, HTML).

# 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 = {
    "mode": "keyword",
    "q": "digital marketing",
    "db": "us",
    "type": "phrase",
    "pages": 1,
    "sort_by": "competition_level",
    "target_type": "root_domain"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pnda/semrush-keyword").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 = {
    "mode": "keyword",
    "q": "digital marketing",
    "db": "us",
    "type": "phrase",
    "pages": 1,
    "sort_by": "competition_level",
    "target_type": "root_domain",
}

# Run the Actor and wait for it to finish
run = client.actor("pnda/semrush-keyword").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 '{
  "mode": "keyword",
  "q": "digital marketing",
  "db": "us",
  "type": "phrase",
  "pages": 1,
  "sort_by": "competition_level",
  "target_type": "root_domain"
}' |
apify call pnda/semrush-keyword --silent --output-dataset

```

## MCP server setup

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

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/7LH0CgHLrGbpFh49M/builds/iK05OijguRBQLTdSw/openapi.json