# Bulk Domain Authority Checker: Backlinks & Referring Domains (`s-r/domain-authority-checker`) Actor

Check many domains in one run. Each row carries the domain authority score, total backlinks, referring domains, the dofollow/nofollow split and the gov/edu count. Optionally add the authority spread of the referring domains and a new/lost referring-domain series.

- **URL**: https://apify.com/s-r/domain-authority-checker.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 domain checkeds

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/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

## Bulk Domain Authority Checker: Backlinks & Referring Domains

Check a whole list of domains in one run. Every row carries the domain
authority score, total backlinks, referring domains, the dofollow/nofollow
split and the gov/edu count. No subscription, no seat licence, no API key to
obtain. Pay only for the rows you get back.

### What it is for

This Actor is built for **breadth**: many domains, one row each, no per-link
detail. That is the shape you want when the question is comparative rather
than forensic.

- score a prospect list or an outreach list before you spend time on it
- rank the domains already linking to a competitor by how much authority they
  carry
- watch a set of competitors' authority drift over months on a schedule
- vet a marketplace of guest-post or directory offers in one pass
- add an authority column to any spreadsheet of companies you already have

If you need the **actual links** for one domain, with anchor text and the
linking page, use the **Backlinks Checker** Actor instead. It reads a different
index and returns one row per backlink. The two answer different questions,
and the per-link list on this Actor's source is gated behind a crawl task that
anonymous callers cannot reach, so this Actor does not pretend to offer it.

### What every row carries

| Field | What it means |
|---|---|
| `domain` | Normalized host, no scheme, no `www.` |
| `domain_authority` | Authority score, 0-100 |
| `backlinks` | Total backlinks in the index |
| `referring_domains` | Distinct domains linking in |
| `dofollow_backlinks` / `nofollow_backlinks` | The follow split |
| `dofollow_percent` | Dofollow share of all backlinks |
| `referring_domains_gov_edu` | Referring domains on .gov or .edu |
| `has_link_profile` | False when the source found no links at all |
| `found` | False when the source did not answer |

Optional: **referring-domain authority spread** adds
`referring_domain_authority_distribution`, ten buckets from 0-10 to 90-100.
**New and lost referring domains** adds a daily series plus
`referring_domains_gained` and `referring_domains_lost`.

### Read this before you trust a number

**`referring_domains` is the number that matters, not `backlinks`.** One site
linking to you 10,000 times is still one relationship. Sitewide footer links
inflate `backlinks` enormously and change `referring_domains` by exactly one.

**The authority score is logarithmic.** Moving from 40 to 50 is a far bigger
jump than 10 to 20. Treat it as a ranking device for comparing domains against
each other, not as a linear quantity you can average.

**Two backlink totals are reported and they will disagree, sometimes wildly.**
`backlinks` comes from the source's authority endpoint; `counts_backlinks`
comes from its bulk endpoint. On bol.com those read 56,823,549 and 188,552 on
the same day. They are two different aggregations over the same index, not a
second opinion, and this Actor reports both rather than quietly picking one.
Use `backlinks` as the headline, because it is the figure the authority score
is computed against, and treat a large gap as a sign to look closer rather
than as an error.

**This is not an independent third opinion.** Its referring-domain counts track
the second index used by the Backlinks Checker Actor closely, within a couple
of percent on the same domain the same day. If you want genuinely independent
corroboration, run a different source, not this one twice.

### What a zero means, and what it does not

The source **never reports an unknown domain**. A host that does not exist
comes back with `domain_authority: 1` and every count at `0`, which is exactly
how it answers a real domain that nobody links to. Because those two are
indistinguishable upstream, this Actor sets `has_link_profile: false` on both
and says so rather than implying a verdict it cannot support. If the difference
matters to you, check whether the domain resolves separately.

`found: false` is a different thing: it means the source did not answer for
that domain at all. Every metric is then `null`, never `0`.

If the source does not answer at all, the run still succeeds but writes **zero
rows** and sets `upstreamReachable: false` in the run's OUTPUT record. Nothing
is billed.

### Speed

Link counts are fetched ten domains per request. The authority score comes from
a per-domain call, which is the pace-setter: 100 domains is roughly 110
requests and finishes in well under a minute at the default concurrency. Each
optional extra costs one further request per domain.

### Input

```json
{
  "domains": ["apify.com", "zapier.com", "make.com"],
  "include_da_distribution": false,
  "include_new_lost": false
}
```

Full URLs are accepted and reduced to the host. A leading `www.` is stripped,
because the source treats `www.` as a separate and near-empty profile and
leaving it on would hand back an empty result for a domain that has one.

### Free plan

On the Apify free plan a run returns at most 10 rows and stops there, and the
run's OUTPUT record says so. The Actor stops fetching once it has enough for
that limit rather than working through your whole list and discarding most of
it. Any paid Apify plan removes the cap.

# Actor input Schema

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

The domains to check, one per line. Full URLs are fine, they get reduced to the host. A leading www. is removed because the source treats it as a separate and near-empty profile.

## `include_da_distribution` (type: `boolean`):

Adds ten buckets counting how many referring domains sit in each authority band, 0-10 through 90-100. Tells you whether the links come from strong sites or from a long tail of weak ones. Costs one extra request per domain.

## `include_new_lost` (type: `boolean`):

Adds a daily series of referring domains gained and lost, plus the totals. Costs one extra request per domain.

## `max_domains` (type: `integer`):

Stop after this many domains. Leave empty to process the whole list.

## `concurrency` (type: `integer`):

Parallel requests to the metrics source. Lower it if you see failed batches.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "https://www.competitor.com/pricing"
  ],
  "include_da_distribution": false,
  "include_new_lost": false,
  "concurrency": 8
}
```

# Actor output Schema

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

One item per domain you supplied, in the order you supplied it.

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

OUTPUT record: how many domains were asked for, how many came back, and whether the source answered at all.

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

Failures with a code and a redacted message. Absent when the run had none.

# 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": [
        "apify.com",
        "zapier.com",
        "make.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/domain-authority-checker").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": [
        "apify.com",
        "zapier.com",
        "make.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/domain-authority-checker").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": [
    "apify.com",
    "zapier.com",
    "make.com"
  ]
}' |
apify call s-r/domain-authority-checker --silent --output-dataset

```

## MCP server setup

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

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/KAkzoHBIYBdJUDFDz/builds/akqjXIQKAZjp4TNYq/openapi.json