# Backlink Checker API: New and Lost Link Monitor (`steady-scrape/backlink-explorer`) Actor

Get backlinks, referring domains, anchors, dofollow status and domain rank for any domain or URL, plus a scheduled new/lost backlink monitor that remembers the last run. Licensed SEO data API, no page scraping.

- **URL**: https://apify.com/steady-scrape/backlink-explorer.md
- **Developed by:** [SteadyScrape](https://apify.com/steady-scrape) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 backlinks

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

## 🔗 Backlink Checker API: New and Lost Link Monitor

Get the **backlinks and referring domains of any website or page**, with anchor text, dofollow/nofollow, first and last seen dates and the rank of every linking domain. Then **schedule it as a monitor** and get only the links that were **gained or lost since the last run**.

- 🔗 **Backlinks list**: linking page, linking domain, target URL, anchor text, dofollow, link type, first seen / last seen, linking domain rank (0–100), page rank, link spam score, broken-link flag
- 🌐 **Referring domains**: one row per linking domain with its rank, how many backlinks it sends, first seen and lost date
- 📊 **Summary**: domain rank, total backlinks, referring domains and root domains, dofollow share, spam score, broken backlinks, top linking countries and TLDs, for up to 10,000 domains per run
- 🔔 **New/lost link monitor**: remembers each domain's last check in a key-value store in *your* account and reports only the changes, each one once. Perfect for a daily or weekly schedule
- ⚡ **API-based, no blocked runs**: data comes from a licensed backlink index (DataForSEO). No scraping of SEO tool pages, no proxies, no captchas
- 💸 **Fair billing**: invalid lines, domains with no backlinks and failed lookups are free. Domains that had no data are remembered for 30 days and are not looked up again

### Quick start

Backlinks of two sites (100 strongest each):

```json
{ "domains": ["backlinko.com", "searchengineland.com"], "mode": "backlinks", "maxRowsPerDomain": 100 }
```

Only dofollow links from strong domains, one per linking domain:

```json
{ "domains": ["competitor.com"], "mode": "backlinks", "dofollowOnly": true, "minSourceRank": 40, "onePerDomain": true, "maxRowsPerDomain": 500 }
```

Referring domains:

```json
{ "domains": ["competitor.com"], "mode": "referring_domains", "maxRowsPerDomain": 1000 }
```

Bulk summary for a list of guest-post sites:

```json
{ "domains": ["site-one.com", "site-two.net", "site-three.io"], "mode": "summary" }
```

**Monitor**: schedule this daily or weekly (Apify Console → Schedules):

```json
{ "domains": ["mysite.com", "competitor.com"], "mode": "monitor", "monitorId": "client-a", "firstRunLookbackDays": 7 }
```

### Modes

| Mode | Rows | Best for |
|---|---|---|
| `backlinks` | one row per backlink (+ one summary row per domain) | link audits, outreach lists, competitor link research |
| `referring_domains` | one row per linking domain (+ summary) | link-gap and domain-level analysis |
| `summary` | one row per domain | vetting lists of sites, bulk authority checks |
| `monitor` | one row per **new or lost** link since the last run (+ summary) | scheduled link monitoring, lost-link reclamation, competitor alerts |

#### How the monitor works

1. The first run for a domain reports links gained/lost in the last `firstRunLookbackDays` days (0 = just save a baseline).
2. It saves the check time in a key-value store in your account (`backlink-explorer-monitor`, or your own `monitorStoreName`).
3. Each later run asks the index for links **first seen** or **found missing** since the previous check (with a 48-hour overlap, because the index updates with some delay), and skips anything it already reported. Every change is reported, and charged, once.
4. Use `monitorId` to keep separate monitors (e.g. one per client). Use `monitorLevel: "referring_domains"` for fewer, domain-level alerts.
5. A domain with no changes costs only the `monitor-check` event. The per-link lookup is skipped.

### Output

Every row has a `rowType`: `summary`, `backlink`, `referring_domain` or `change`. Dataset views: **Summary per domain**, **Backlinks**, **Referring domains**, **New / lost links**.

| Field | Example | Notes |
|---|---|---|
| `target` | `backlinko.com` | Normalized (no `https://`, `www.`); page URLs are kept when *Analyze as* = exactly as entered |
| `sourceUrl` / `sourceDomain` | `https://example.org/post` / `example.org` | Linking page and domain |
| `targetUrl` | `https://backlinko.com/seo-tools` | The page that is linked to |
| `anchor` | `best SEO tools` | Anchor text (image alt text for image links) |
| `dofollow` | `true` | `false` = nofollow / ugc / sponsored |
| `linkType` | `anchor` | `anchor`, `image`, `redirect`, `canonical`, `alternate`, `meta` |
| `firstSeen` / `lastSeen` | `2025-03-02T10:11:12Z` | When the crawler first and last saw the link |
| `sourceDomainRank` / `sourcePageRank` / `linkRank` | `76` / `54` / `31` | 0–100 link-graph scores (PageRank-style), this index's own scale |
| `isNew` / `isLost` / `isBroken` | | |
| `change` / `changeDate` | `lost` / `2026-10-27T21:57:59Z` | Monitor mode only |
| `domainRank`, `backlinks`, `referringDomains`, `referringMainDomains`, `dofollowReferringDomainsPct`, `backlinksSpamScore`, `brokenBacklinks`, `linksFirstSeen`, `topLinkCountries`, `topLinkTlds` | | Summary rows |
| `status` | `ok` | Summary rows: `ok`, `no_data`, `error`, `skipped`. Only rows with data are charged |

The run summary (`OUTPUT` in the key-value store) has totals, new/lost counts, charges and notes.

### Pricing (pay per event)

You pay only for what is delivered. Typical runs:

- 1 domain, 100 strongest backlinks: **$0.16**
- 20 domains × 50 backlinks: **$1.83**
- 100-domain summary: **$0.43**
- Monitor check of 10 domains: **$0.53** plus $0.002 per new or lost link reported

| Event | Price | When |
|---|---|---|
| `actor-start` | $0.03 | once per run, only if at least one domain returned data |
| `domain-lookup` | $0.05 | per domain that returned rows in backlinks / referring-domains mode (its summary row is included) |
| `backlink-row` | $0.0008 ($0.80 per 1,000) | per backlink row |
| `referring-domain-row` | $0.001 ($1 per 1,000) | per referring-domain row |
| `domain-summary` | $0.004 ($4 per 1,000) | per domain in summary mode |
| `monitor-check` | $0.05 | per domain checked in monitor mode |
| `link-change` | $0.002 ($2 per 1,000) | per new or lost link reported |

**Paid Apify plans get lower per-result prices automatically:**

| Event | Free plan | Starter (Bronze) | Scale (Silver) | Business (Gold) |
|---|---|---|---|---|
| backlink-row | $0.0008 | $0.00072 | $0.00064 | $0.0006 |
| referring-domain-row | $0.001 | $0.0009 | $0.0008 | $0.00075 |
| domain-summary | $0.004 | $0.0036 | $0.0032 | $0.003 |
| link-change | $0.002 | $0.0018 | $0.0016 | $0.0015 |

`actor-start`, `domain-lookup` and `monitor-check` are the same on every plan.

**Free:** invalid lines, duplicates, domains with no backlink data, failed lookups and skipped rows. Set **Maximum cost per run** in the run options; the Actor plans its work so it never goes past it.

### Cost examples

Costs use the current list prices on the Apify Free plan, including Apify's $0.00005 start event. Run time depends on the number of domains and rows you ask for.

| Run | Cost (Free plan) |
|---|---|
| 1 domain, 100 strongest backlinks | about $0.16 |
| 100-domain summary | about $0.43 |
| Monitor check of 10 domains | about $0.53 |

Backlink row: $0.0008 on the Apify Free plan, $0.00072 on Starter (Bronze), $0.00064 on Scale (Silver), $0.0006 on Business (Gold) and above. The discount is applied automatically. Referring-domain row: $0.001 / $0.0009 / $0.0008 / $0.00075. Summary: $0.004 / $0.0036 / $0.0032 / $0.003.

### Use it from an AI agent (Apify MCP)

Give Claude, Cursor, VS Code or any other MCP client this Actor as a tool through the [Apify MCP server](https://mcp.apify.com). Add this to your client's MCP config; you sign in to Apify with OAuth on first connect:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=steady-scrape/backlink-explorer"
    }
  }
}
```

Clients without OAuth can send an `Authorization: Bearer <APIFY_TOKEN>` header instead. Then ask, for example: *"List the 100 strongest backlinks to competitor.com and tell me which referring domains link to them but not to us."* The agent starts a normal run, so the prices above and your maximum charge per run still apply.

### FAQ

**Is this the same data as other SEO tools show?** No. It's an independent backlink index (DataForSEO, one of the largest commercial link indexes), licensed for this use. Counts differ between all link tools, so compare trends rather than exact numbers.

**Why do my ranks differ from the authority score in another SEO tool?** `domainRank` is the index's own 0–100 link-graph score. Each tool uses its own scale, though the scores tend to move in the same direction.

**How fresh is the data?** The index is crawled continuously. Monitor mode uses a 48-hour overlap window so links that show up late in the index are still caught.

**Can I monitor many domains?** Yes. Put all of them into one scheduled run (up to 1,000 per run in list and monitor modes). Domains without changes skip the per-link lookup.

**Is any personal data collected?** No. Only public link data (URLs, anchor text, page titles). No emails or contact details.

**How do I check backlinks for any website?** Enter the domain or URL and pick backlinks mode. You get each linking page, anchor text, dofollow status, first and last seen dates and the linking domain's rank.

**Can I get alerts for new and lost backlinks?** Yes. Use monitor mode on a schedule. It remembers the last run and reports only new and lost links ($0.05 per domain checked plus $0.002 per change).

**Is there a cheap backlink API without a monthly plan?** Yes. You pay per row delivered: 100 backlinks for one domain cost about $0.16, with no subscription.

### More from SteadyScrape

- [Bulk Domain Rank & Traffic Checker](https://apify.com/steady-scrape/domain-seo-metrics): domain rank, backlinks, referring domains, spam score and estimated Google traffic for up to 10,000 domains.
- [Keyword Search Volume](https://apify.com/steady-scrape/keyword-search-volume): Google search volume, CPC, competition and a 12-month trend for up to 10,000 keywords per run.
- [Google Ads Transparency Scraper](https://apify.com/steady-scrape/google-ads-transparency): every Google ad a competitor runs (Search, YouTube, Shopping), with first and last shown dates and a new-ads monitor.
- [AI Visibility & Share of Voice Tracker](https://apify.com/steady-scrape/ai-brand-visibility-tracker): see whether ChatGPT and Perplexity mention, rank and cite your brand versus your competitors.

See every **SteadyScrape (steady-scrape)** Actor on [our Apify profile](https://apify.com/steady-scrape).

Questions or a feature request? Open an issue on the **Issues** tab.

### Acceptable use

You may not use results from this service to build or operate a search engine, or any product or service that competes with or harms the business of search engine providers.

— SteadyScrape

# Actor input Schema

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

Domains or page URLs, one per line. Duplicates are removed; invalid lines are reported for free. Example: example.com or https://example.com/blog/post

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

What to return. 'Monitor' remembers each domain's last check in a key-value store, so schedule it daily or weekly to get only the links gained and lost since the previous run.

## `maxRowsPerDomain` (type: `integer`):

Backlinks or referring domains to return per domain (backlinks and referring domains modes). The strongest links come first by default.

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

Order of the rows. Default: strongest linking domains first.

## `dofollowOnly` (type: `boolean`):

Skip nofollow links (backlinks list and backlink monitor).

## `onePerDomain` (type: `boolean`):

Backlinks mode: return only the strongest link from each referring domain.

## `minSourceRank` (type: `integer`):

Only links from domains with at least this rank. 0 = no filter.

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

Count links pointing to subdomains (blog.example.com) as links to the domain.

## `includeSummaryRows` (type: `boolean`):

Adds one row per domain with domain rank, total backlinks, referring domains, spam score and first seen date.

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

'Domain' turns https://www.example.com/page into example.com. 'Exactly as entered' keeps subdomains and checks page URLs.

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

Report changes per backlink or per linking domain.

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

Keeps separate memories for separate monitors (e.g. one per client). Letters, digits, '-', '\_' and '.'.

## `firstRunLookbackDays` (type: `integer`):

On a domain's first monitor run, report links gained/lost in the last N days. 0 = just save a baseline.

## `maxChangesPerDomain` (type: `integer`):

Upper limit on new + lost links reported per domain per run (strongest linking domains first).

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

Name of the key-value store in your account that holds the monitor memory. Default: backlink-explorer-monitor.

## Actor input object example

```json
{
  "domains": [
    "backlinko.com",
    "dataforseo.com"
  ],
  "mode": "backlinks",
  "maxRowsPerDomain": 100,
  "sortBy": "sourceRank",
  "dofollowOnly": false,
  "onePerDomain": false,
  "minSourceRank": 0,
  "includeSubdomains": true,
  "includeSummaryRows": true,
  "analyzeAs": "domain",
  "monitorLevel": "backlinks",
  "monitorId": "default",
  "firstRunLookbackDays": 7,
  "maxChangesPerDomain": 200
}
```

# Actor output Schema

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

No description

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

No description

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

No description

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

No description

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

Totals, provider cost and charges.

# 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": [
        "backlinko.com",
        "dataforseo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steady-scrape/backlink-explorer").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": [
        "backlinko.com",
        "dataforseo.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("steady-scrape/backlink-explorer").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": [
    "backlinko.com",
    "dataforseo.com"
  ]
}' |
apify call steady-scrape/backlink-explorer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steady-scrape/backlink-explorer"
        }
    }
}
```

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/AsM5yTWrbtAzn1nW1/builds/45ZOp6bnSQgyoaYtF/openapi.json