# Semrush Backlink Analytics (`pnda/semrush-backlink-analytics`) Actor

Export authority-scored backlinks for any domain or URL: Page Authority Score, source URL, source title, anchor text, first/last seen dates. Pre-filtered (follow, content, one per referring domain) and sorted by authority — outreach-ready data, pushed straight to an Apify dataset.

- **URL**: https://apify.com/pnda/semrush-backlink-analytics.md
- **Developed by:** [PNDA](https://apify.com/pnda) (community)
- **Categories:** Automation, E-commerce, SEO tools
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

- **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 Backlink Scraper — Authority-Scored Backlinks for Any Domain or URL

Pull the **full list of backlinks** pointing to any website — with Authority Score, source URL, source title, anchor text, follow/nofollow status, and first/last-seen dates. Semrush link intelligence, on demand, pushed straight into an Apify dataset.

This Actor accepts a domain or URL, handles authentication and pagination, and returns a clean, flat backlink table ready for **JSON, CSV, Excel, Google Sheets, outreach workflows or GPT pipelines**. No Semrush login required.

***

### 💡 Who is it for?

- **Link-building teams** generating outreach lists scored by Page Authority.
- **SEO agencies** running backlink audits and disavow reviews for clients.
- **Competitive researchers** reverse-engineering a competitor's link profile.
- **Affiliate & niche-site operators** scouting referring domains for partnership deals.
- **PR & digital marketing teams** tracking earned media and unlinked mentions.
- **Data teams** enriching a CRM or BI dashboard with backlink metrics.

***

### ⚙️ How it works

You give the Actor a domain or URL and a target type. It hits the Semrush backlink report, applies smart filters (follow, content links, de-duplicated per referring domain, sorted by page Authority Score) and pushes every backlink as its own row to the Apify dataset.

#### Target types supported

| Target type | Scope |
|---|---|
| **Root Domain** | All backlinks pointing to any subdomain of the root (e.g. `example.com` + `blog.example.com`) |
| **Domain** | Backlinks to one specific subdomain only |
| **URL** | Backlinks to one exact page URL |

#### Built-in quality filters

- Follow links only (nofollow excluded)
- Content-position links only (sidebars / footers filtered out)
- Text links (images and forms excluded)
- Mobile-indexed sources
- One link per referring domain (de-duplicated)
- Sorted by **page Authority Score**, highest first

You get the *quality* backlinks, not the noise.

***

### 📥 Input

| Field | Type | Required | Description |
|---|---|---|---|
| `q` | string | ✅ | Domain or URL to analyze (e.g. `example.com`) |
| `target` | string | — | Specific target URL (when narrower than `q`) |
| `target_type` | string | — | `root_domain` (default), `domain`, or `url` |

#### Example input

```json
{
  "q": "example.com",
  "target_type": "root_domain"
}
```

***

### 📤 Output

Each backlink is pushed as one row in the dataset. Example item:

```json
{
  "page_ascore": 62,
  "source_title": "Best Running Shoes 2026 — Expert Reviews",
  "source_url": "https://authoritysite.com/best-running-shoes/",
  "external_link_num": 8,
  "internal_link_num": 124,
  "target_anchor": "running shoes guide",
  "target_url": "https://example.com/guide/",
  "first_seen": "2024-02-14",
  "last_seen": "2026-04-12"
}
```

#### Field reference

| Field | Meaning |
|---|---|
| `page_ascore` | Authority Score of the linking page (0 → 100) |
| `source_title` | Title of the page hosting the backlink |
| `source_url` | URL of the page hosting the backlink |
| `external_link_num` | Total external links on the source page (dilution signal) |
| `internal_link_num` | Internal links on the source page |
| `target_anchor` | Anchor text used for the link |
| `target_url` | Page on your (or the audited) domain receiving the link |
| `first_seen` | When Semrush first indexed this backlink |
| `last_seen` | When Semrush last confirmed this backlink |

***

### 🚀 Why use this Actor

- ✅ **Authority-scored results** — sort/filter by `page_ascore` to find only high-value links.
- ✅ **Noise pre-filtered** — follow, content, text, one-per-domain: outreach-ready by default.
- ✅ **Flat, typed schema** — plug straight into BigQuery, Postgres, Sheets or a GPT.
- ✅ **Any domain, any subdomain, any URL** — one Actor covers site-wide and page-level audits.
- ✅ **No login, no scraping, no pagination to maintain** — authentication handled for you.
- ✅ **Pipeline-ready** — trigger from n8n, Make, Zapier, Apify Schedules or the Apify API.

***

### 💼 Use cases

- **Outreach lists**: filter `page_ascore ≥ 40` to build a high-quality prospect CSV in seconds.
- **Competitor link audits**: export every backlink a competitor earned last quarter.
- **Disavow file prep**: surface low-quality or suspicious referring pages.
- **Anchor text analysis**: spot over-optimized or brand-diluted anchors across a link profile.
- **PR tracking**: detect new earned placements over time via scheduled runs.
- **Lost-link monitoring**: compare `last_seen` dates month over month to flag drops.

***

### 🧩 Part of the Semrush suite

Chain this Actor with the rest of the suite for a full SEO workflow:

| Actor | What it does |
|---|---|
| 🔗 [Semrush Backlink Analytics](https://apify.com/pnda/semrush-backlink-analytics) | Authority-scored backlinks, anchors, referring domains (this Actor) |
| 🔍 [Semrush Keyword](https://apify.com/pnda/semrush-keyword) | Keyword ideas — volume, CPC, difficulty, intent |
| 🌐 [Semrush Domain](https://apify.com/pnda/semrush-domain) | Full domain audit — authority, traffic, top keywords |
| 🥊 [Semrush Competitor](https://apify.com/pnda/semrush-competitor) | Up to 200 organic competitors and keyword overlap |

***

### 💰 Pricing

**Pay-per-result** — you're charged **$0.012 per backlink returned**, plus a small per-run start fee. You only pay for backlinks you actually receive.

| Backlinks returned | Approx. cost |
|---|---|
| 100 | ~$1.20 |
| 500 | ~$6 |
| 2,000 | ~$24 |

New users get free result credits to try the Actor before spending anything.

***

### ▶️ Start now

Enter a domain. Pick a target type. Hit **Run**. Export your dataset.
High-authority backlinks on tap — for any website on the web.

# Actor input Schema

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

Domain or URL to analyze

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

Specific target URL for backlink analysis (optional)

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

Target type for backlink analysis

## Actor input object example

```json
{
  "q": "example.com",
  "target_type": "root_domain"
}
```

# Actor output Schema

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

All backlinks returned by this run (JSON, CSV, Excel, HTML, RSS).

# 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 = {
    "q": "example.com",
    "target_type": "root_domain"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pnda/semrush-backlink-analytics").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 = {
    "q": "example.com",
    "target_type": "root_domain",
}

# Run the Actor and wait for it to finish
run = client.actor("pnda/semrush-backlink-analytics").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 '{
  "q": "example.com",
  "target_type": "root_domain"
}' |
apify call pnda/semrush-backlink-analytics --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PDNAhdV8JKsgnac6f/builds/XbFqcFFmJ6c0WtP4F/openapi.json