# SEMrush Authority Score Scraper (`khadinakbar/semrush-domain-authority-scraper`) Actor

Collect public Semrush Authority Score, backlinks, referring domains, and estimated visits for up to 50 domains per run.

- **URL**: https://apify.com/khadinakbar/semrush-domain-authority-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 60.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 domain authority 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

## SEMrush Authority Score Scraper

Collect one structured Semrush Website Traffic Checker record for each domain: Authority Score, backlinks, referring domains, estimated visits, the public source URL, and collection time. It is designed for SEO agencies, link-building teams, and AI agents that need a small, source-linked batch for domain comparison alongside dedicated keyword, rank-tracking, and backlink-export workflows.

### Best fit for this Actor

Choose this Actor when you have 1–50 domains and need Semrush's public Authority Score alongside the core website metrics displayed on its overview page. It works as a focused standalone workflow: provide domains, read the terminal outcome, then export the default dataset. For rank positions or a keyword-level workflow, use the separate [Keyword Rank Tracker](https://apify.com/khadinakbar/keyword-rank-tracker) after this step; it measures Google result positions rather than Semrush website authority.

### From outreach shortlist to domain comparison

An SEO team starts with a shortlist of potential publications, then submits the domains here. Next, it sorts the returned rows by `authorityScore` or `referringDomains`, validates the public source URL for the finalists, and exports the dataset to its outreach or reporting workflow. One row represents one domain at the time it was collected; values can change as Semrush refreshes its data.

### Quick start input

```json
{
    "domains": ["example.com", "openai.com"],
    "maxResults": 2,
    "maxConcurrency": 2
}
```

`domains` is required. Bare domains are best; `https://` and `www.` are normalized. `RUN_SUMMARY` preserves domain-specific collection details, and billing begins only after a complete public metric set is written to the dataset.

### What data you receive

| Field                       | Meaning                                                       |
| --------------------------- | ------------------------------------------------------------- |
| `authorityScore`            | Semrush's 0–100 proprietary Authority Score for the domain.   |
| `backlinks`                 | Semrush's current public total backlink count.                |
| `referringDomains`          | Semrush's current public unique referring-domain count.       |
| `visits`                    | Semrush's public estimated visits value on the overview page. |
| `sourceUrl` and `fetchedAt` | The public source used and the UTC collection time.           |

```json
{
    "domain": "example.com",
    "authorityScore": 47,
    "backlinks": 305710590,
    "referringDomains": 691652,
    "visits": 18863290,
    "sourceUrl": "https://www.semrush.com/website/example.com/overview/",
    "source": "Semrush Website Traffic Checker",
    "fetchedAt": "UTC ISO 8601 collection timestamp"
}
```

### Use through the API

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~semrush-domain-authority-scraper/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"domains":["example.com","openai.com"],"maxResults":2}'
```

After the run, read `OUTPUT` and `RUN_SUMMARY`, then retrieve the default dataset from the run's dataset URL. The Actor focuses on Semrush's public overview page and supports source-linked authority comparison.

### Use with an AI agent through Apify MCP

> Compare `example.com` and `openai.com` using public Semrush Authority Score. Return the authority score, backlinks, referring domains, visits, source URL, and collection time. Read the terminal outcome before reporting results; if a domain is unavailable, preserve the reason instead of inventing a score. Keep the batch at two domains so the cost is clear.

The Actor is read-only and returns one dataset row per completed domain. It charges after a full record is written; use `maxResults` to cap paid records and export the resulting dataset when your workflow retains prior batches.

### Pricing

Pay per event: **$0.005 per completed domain authority record** plus a **$0.00005 Actor start** event. Platform usage is additional because Pay per event + usage is enabled in the live Pricing tab. A two-domain request has up to $0.010 in result events plus the start event and platform usage; result events follow complete dataset writes.

### Best results and data quality

Start with canonical registrable domains, check up to 50 per run, and retain `sourceUrl` plus `fetchedAt` with downstream decisions. Semrush calls this metric **Authority Score**; Moz uses its own separate Domain Authority measure. Use Authority Score for relative comparison within a defined workflow, then validate high-stakes decisions against the source and other evidence. Pair it with the [Keyword Rank Tracker](https://apify.com/khadinakbar/keyword-rank-tracker) when you need observed Google positions after comparing authority signals.

### Builder's note

I built this as a narrow public-data path after confirming that Semrush's website overview exposes a complete serialized metric set with public access. My goal was a dependable one-domain-one-record contract: the terminal handler preserves a clear upstream outcome whenever the page lacks the complete advertised metric set.

### Responsible use

Use domains and data you are authorized to assess, and comply with applicable laws and Semrush's terms. The returned estimates and proprietary score are source-provided indicators for comparative research and evidence-led decisions.

# Actor input Schema

## `domains` (type: `array`):

Domains to look up in Semrush's public Website Traffic Checker, such as "google.com" or "amazon.com". Accepts bare domains and normalizes an optional https:// or www. prefix. Supply 1 to 50 domains; duplicates are checked once. Low-traffic or reserved domains may return no public metrics. This is not a URL crawler, keyword query, IP address, or email address.

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

Maximum number of unique valid domains that can produce a billable record in this run. Use an integer from 1 to 50; the default is 50. Lowering this value is a direct cost cap because one complete domain record is one event. This is not a pagination size because Semrush supplies one overview per domain.

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

Number of Semrush overview pages requested at the same time. Use an integer from 1 to 5; the default of 3 keeps a small batch polite and predictable. Lower it when diagnosing an upstream response issue. This is not a result limit and does not change the per-record event price.

## Actor input object example

```json
{
  "domains": [
    "google.com",
    "amazon.com"
  ],
  "maxResults": 10,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

One complete Semrush metric record per successfully collected domain.

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

Compact run outcome, record count, and failure count.

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

Detailed diagnostics for invalid or upstream-unavailable domains.

# 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 = {
    "domains": [
        "google.com"
    ],
    "maxResults": 1,
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/semrush-domain-authority-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 = {
    "domains": ["google.com"],
    "maxResults": 1,
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/semrush-domain-authority-scraper").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 '{
  "domains": [
    "google.com"
  ],
  "maxResults": 1,
  "maxConcurrency": 3
}' |
apify call khadinakbar/semrush-domain-authority-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/E4mA5CtenlTJVlNlh/builds/bha84YBW5CulwiW3B/openapi.json