# SEO Competitor Analyzer — Semrush Alternative (`khadinakbar/semrush-alternative`) Actor

Analyze SEO competitors from domains or seed keywords. Export organic keywords, competing domains, volume, CPC, difficulty, ranking URLs, and backlink context for repeatable competitive-research reports.

- **URL**: https://apify.com/khadinakbar/semrush-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 seo records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SEO Competitor Analyzer — Semrush Alternative

Analyze SEO competitors from domains or seed keywords. Export organic keywords, competing domains, volume, CPC, difficulty, ranking URLs, and backlink context for repeatable competitive-research reports. For competitive-research teams, the dataset returns the selected domain overview or detailed keyword, competitor, and backlink records.

### Workflow: put the results to work

Use the domain overview to establish the competitor's search footprint, then explore competing domains or organic keywords. Turn the selected rows into a focused competitive report and retain market settings for comparison. Review modeled metrics alongside the ranking evidence.

### SEMRush Alternative — Keywords & Backlinks

This Apify Actor helps SEO teams, analysts, and AI agents turn a domain or seed keywords into Semrush-style SEO reports. It accepts a domain or URL for domain overview, organic keywords, competitors, and backlinks, plus keyword lists for keyword overview and keyword ideas. One dataset record represents one domain, keyword, competitor, or backlink row. Valuable fields include `organicTraffic`, `organicKeywordCount`, `searchVolume`, `rank`, `backlinks`, `referringDomains`, `rankScore`, `anchor`, and `sourceUrl`. The outcome is a structured dataset that is easy to review, export, or pass to an Apify MCP workflow.

### Best fit and connected workflows

This Actor fits workflows where the next step needs structured SEO intelligence rather than raw page HTML.

- Use `domain_overview` for a quick domain snapshot with organic traffic, keyword count, and backlink summary.
- Use `organic_keywords` to review the keywords a domain ranks for, along with volume, CPC, difficulty, intent, and rank.
- Use `competitors` to surface overlapping domains for market mapping.
- Use `keyword_overview` to score seed phrases.
- Use `keyword_ideas` to expand seeds into a broader list.
- Use `backlinks` to review referring URLs, anchors, and dofollow signals.

### How this workflow compares with Semrush

| Decision | This Actor | Semrush | Suitable fit |
|---|---|---|---|
| Scope | Six bounded domain, keyword, competitor, and backlink report modes | A broader SEO product experience with its own interface and product workflows | Use this Actor for focused, programmable reports; use Semrush when the broader product experience is central to the work |
| Starting point | A domain, URL, or seed-keyword list supplied for one selected mode | Inputs and projects managed inside the Semrush product | Use this Actor when the starting information already exists in an automated workflow |
| Output | Structured Apify dataset rows plus `OUTPUT` and `RUN_SUMMARY` | Output presented through Semrush's own product surfaces | Use this Actor when dataset export, API readback, or Actor chaining is required |
| Billing | Pay per event plus Apify platform usage, with current terms on the live Pricing tab | Semrush's own current commercial terms | Compare the current plans against the exact report volume and operating workflow |
| Integrations | Apify API, dataset exports, schedules, webhooks, and Apify MCP | Semrush's broader native product workflows | Choose according to the downstream system that needs the result |

This Actor is a focused automation route for the documented reports rather than a representation of Semrush's complete product suite.

### Input fields

| Field | Type | Purpose |
|---|---|---|
| `mode` | string | Selects the report type. Supported values: `domain_overview`, `organic_keywords`, `competitors`, `keyword_overview`, `keyword_ideas`, `backlinks`. |
| `target` | string | Domain or URL to analyze for domain-based and backlink modes. Example: `ahrefs.com`. |
| `keywords` | array of strings | Seed phrases for `keyword_overview` and `keyword_ideas`. Example: `["seo tools"]`. |
| `locationName` | string | Country for keyword and domain Labs reports. Default: `United States`. |
| `languageCode` | string | Language code matching the country, such as `en`, `de`, or `es`. Default: `en`. |
| `maxResults` | integer | Maximum rows to write, from 1 to 100. Default: `5`. |
| `includeSubdomains` | boolean | Includes subdomain data in organic keyword and backlink summary output. Default: `true`. |
| `excludeTopDomains` | boolean | Filters large generic domains from competitor results. Default: `true`. |

#### Valid input example

```json
{
  "mode": "organic_keywords",
  "target": "ahrefs.com",
  "locationName": "United States",
  "languageCode": "en",
  "maxResults": 5,
  "includeSubdomains": true
}
```

### Output fields

One dataset item represents one row for the selected report type.

| Field | Meaning |
|---|---|
| `mode` | Report type that produced the row. |
| `target` | Normalized domain or page analyzed. |
| `keyword` | Keyword associated with the row, when present. |
| `domain` | Domain associated with the row, when present. |
| `locationName` | Country used for the report. |
| `languageCode` | Language used for the report. |
| `searchVolume` | Estimated search volume for a keyword row. |
| `cpcUsd` | CPC value in USD for a keyword row. |
| `keywordDifficulty` | Difficulty score for a keyword row. |
| `searchIntent` | Search intent label for a keyword row. |
| `rank` | Position or rank for the row. |
| `rankingUrl` | URL associated with the ranking keyword row. |
| `estimatedTraffic` | Estimated traffic for a keyword row. |
| `organicKeywordCount` | Organic keyword count for a domain row. |
| `organicTraffic` | Organic traffic estimate for a domain row. |
| `backlinks` | Backlink count for a domain or backlink summary row. |
| `referringDomains` | Referring domain count for a domain or backlink summary row. |
| `rankScore` | SEO rank score included in the report. |
| `sourceUrl` | Source URL for backlink rows. |
| `targetUrl` | Target URL for backlink rows. |
| `anchor` | Anchor text for backlink rows. |
| `dofollow` | Dofollow signal for backlink rows. |
| `source` | Provenance label for the row. |
| `fetchedAt` | Fetch timestamp. |
| `status` | Row status. |

#### Illustrative dataset record

```json
{
  "mode": "domain_overview",
  "target": "ahrefs.com",
  "domain": "ahrefs.com",
  "locationName": "United States",
  "languageCode": "en",
  "organicTraffic": 45000,
  "organicKeywordCount": 1200,
  "backlinks": 9000,
  "referringDomains": 1200,
  "rankScore": 450,
  "source": "semrush_alternative/domain_overview",
  "fetchedAt": "2026-08-21T18:00:00.000Z",
  "status": "OK"
}
```

### How it works

This Actor uses owner-managed DataForSEO credentials configured in Apify secrets. The selected mode determines the upstream SEO task. Domain modes normalize the target to a hostname, while backlink mode keeps page-level URLs when present. Keyword modes read from the `keywords` array. Rows are written to the default dataset, and execution metadata is stored in the default key-value store as `OUTPUT` and `RUN_SUMMARY`.

### Use with AI agents (MCP)

This Actor is available as an Apify Actor usable through Apify MCP. The precise tool behavior is to generate Semrush-style SEO rows for a chosen mode and persist them to the Apify dataset for downstream reading.

Actor identity: `khadinakbar/semrush-alternative`

> Use `khadinakbar/semrush-alternative` in `domain_overview` mode for `ahrefs.com` in the United States. Return the dataset rows and summarize `organicTraffic`, `organicKeywordCount`, `backlinks`, `referringDomains`, `rankScore`, `source`, and `fetchedAt`. Read the `OUTPUT` record for outcome and items pushed, then check `RUN_SUMMARY` for event counts and provider cost.

When interpreting results, treat each dataset row as one SEO record from the selected mode. `source` and `fetchedAt` provide provenance and freshness context. Pagination is controlled by `maxResults`, and keyword modes cap the returned rows accordingly. For cost planning, consider both event counts and Apify platform usage, then review the live Pricing tab before running larger batches.

### Apify API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor('khadinakbar/semrush-alternative').call({
  mode: 'organic_keywords',
  target: 'ahrefs.com',
  locationName: 'United States',
  languageCode: 'en',
  maxResults: 5,
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);

const output = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('OUTPUT');
console.log(output.value);
```

### Best results and outcome guidance

Use a valid hostname such as `ahrefs.com` when you need a domain report. Choose `keywords` for keyword overview or keyword ideas, and keep `target` for domain and backlink modes. Start with a small `maxResults` value when you want to inspect the row shape, then increase it for larger exports. `includeSubdomains` is useful when subdomain coverage matters in keyword and backlink summaries. `excludeTopDomains` helps competitor research stay closer to market rivals.

### Design note

I found that the dataset contract exposes a single shared schema across modes, with rows that may populate different field groups such as keyword metrics, domain metrics, or backlink details. That makes the mode value especially important for interpreting which fields are meaningful in each record.

### FAQ

#### Which mode should I use for a domain snapshot?

Use `domain_overview`. It returns one domain row with organic traffic estimate, organic keyword count, backlinks, and referring domains.

#### Which mode works for keyword research from seed phrases?

Use `keyword_overview` for scoring seed phrases and `keyword_ideas` for expansion. Both use the `keywords` input array.

#### Which mode is the right fit for competitor discovery?

Use `competitors`. The `excludeTopDomains` input helps keep the list focused on closer market rivals.

#### Which mode returns referring URLs and anchors?

Use `backlinks`. That mode is built around `sourceUrl`, `targetUrl`, `anchor`, `dofollow`, and related backlink fields.

#### Can I use this Actor through Apify MCP?

Yes. The Actor is MCP-ready and designed for Apify MCP workflows that read the dataset and the key-value store records after a run.

### Responsible use

Semrush is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by Semrush.

Use this Actor for public SEO research and internal analysis that you are authorized to perform. Review the returned metrics in the context of your own compliance and data-governance process.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/semrush-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `seo-api-request` | SEO API request | Charged once for each successful upstream SEO API task used to build the report. |
| `seo-record` | SEO record | Charged once for each validated domain, keyword, competitor, or backlink row persisted to the dataset. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

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

Which Semrush-style report to run. domain\_overview returns one domain row (organic traffic estimate plus backlink summary). organic\_keywords lists keywords a domain ranks for. competitors lists overlapping domains. keyword\_overview scores seed phrases. keyword\_ideas expands seeds. backlinks lists referring URLs. Default domain\_overview. This is NOT a Semrush login or API key field.

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

Website to analyze for domain\_overview, organic keywords, competitors, or backlinks. Accepts ahrefs.com or https://www.ahrefs.com. Protocol and www are stripped to the hostname except for page-level backlinks. Prefill ahrefs.com. Not a keyword and not a Semrush project URL.

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

Seed phrases for keyword\_overview or keyword\_ideas. Example: \["seo tools"]. Duplicates collapse. Capped by maxResults. Ignored in domain modes. This is NOT a domain list.

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

Country name for keyword and domain Labs reports, such as United States or United Kingdom. Defaults to United States. Use the full country name, not a city. Ignored for backlinks mode.

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

Language code matching the country, such as en, de, or es. Defaults to en. This is a short code, not a language name like English.

## `maxResults` (type: `integer`):

Maximum dataset rows to write (1-100). Defaults to 5 so quality tests and agent calls stay cheap. domain\_overview always writes at most one row. Caps keyword lists in keyword\_overview.

## `includeSubdomains` (type: `boolean`):

When true, organic keywords and backlink summary include subdomain data. Defaults to true. Does not crawl the live website.

## `excludeTopDomains` (type: `boolean`):

When true, competitors mode drops giant generic sites so the list stays closer to real market rivals. Defaults to true. Ignored in other modes.

## Actor input object example

```json
{
  "mode": "domain_overview",
  "target": "ahrefs.com",
  "keywords": [
    "seo tools"
  ],
  "locationName": "United States",
  "languageCode": "en",
  "maxResults": 5,
  "includeSubdomains": true,
  "excludeTopDomains": true
}
```

# Actor output Schema

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

Domain, keyword, competitor, or backlink rows.

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

Compact OUTPUT record with outcome, itemsPushed, charges, and warnings.

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

Detailed RUN\_SUMMARY including providerCostUsd and request counts.

# 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": "domain_overview",
    "target": "ahrefs.com",
    "keywords": [
        "seo tools"
    ],
    "locationName": "United States",
    "languageCode": "en",
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/semrush-alternative").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": "domain_overview",
    "target": "ahrefs.com",
    "keywords": ["seo tools"],
    "locationName": "United States",
    "languageCode": "en",
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/semrush-alternative").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": "domain_overview",
  "target": "ahrefs.com",
  "keywords": [
    "seo tools"
  ],
  "locationName": "United States",
  "languageCode": "en",
  "maxResults": 5
}' |
apify call khadinakbar/semrush-alternative --silent --output-dataset

```

## MCP server setup

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

```

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/Xgrnb0FF7Jn8g7WrL/builds/DhiPGDfnEIdldZ8Wy/openapi.json