# Bulk Domain Authority Checker: DA Score for 10,000 Domains (`alexmorain/bulk-domain-authority-checker`) Actor

Check the authority of up to 10,000 domains in one run. Each domain gets a 0-100 rank from the DataForSEO backlink index, with optional spam score and referring domains. $1 per 1,000 domains. Not Moz DA: a comparable index-based score.

- **URL**: https://apify.com/alexmorain/bulk-domain-authority-checker.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** SEO tools, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 domains

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

### What does Bulk Domain Authority Checker do?

Bulk Domain Authority Checker rates up to 10,000 domains in one run and returns one row per domain with a 0-100 authority score. On request it adds the spam score and the number of referring domains, and it can track how each score moves from one run to the next. The data comes from the [DataForSEO](https://dataforseo.com) Backlinks API. No browser, no login, no API key to buy.

> Read this first. The score is DataForSEO's domain rank on a 0-100 scale. It is not Moz's Domain Authority (DA), not Ahrefs' Domain Rating and not Semrush's Authority Score, and it will not match them number for number. It plays the same role: a 0-100 measure of a domain's link strength, consistent across domains and over time. This Actor is an independent project, not affiliated with Moz, Ahrefs or Semrush. The field is called `domainAuthority` because that is what people search for, and every row also says what it really is in `metric`.

### Why use it?

- $1.05 for 1,000 domains, $0.55 on the Gold plan. Domains go to the provider in calls of 1,000, so a big list costs about the same per domain as a small one.
- The right target, even when you paste the wrong one. The provider rates exactly what it receives. Measured on 9 November 2026: `apify.com` is 79, `www.apify.com` 56 and `blog.apify.com` 45. A list pasted from a spreadsheet, with `www.` and full URLs, gives scores that are 20 to 35 points too low without any warning. By default the Actor reduces every line to its registered domain (`https://www.apify.com/store` becomes `apify.com`, `blog.example.co.uk` becomes `example.co.uk`) and writes both what you pasted (`input`) and what was rated (`domain`). Need one subdomain? Switch to Exact mode.
- Honest zeros. The provider returns 0 without any error for a domain it does not know. Ask for referring domains and `hasLinkData` tells "unknown to the provider" from a real low score.
- Score history. Turn on tracking and schedule it: each row gets the previous score and the change, at no extra cost.
- Nothing lost on a bad line. A line that is not a domain comes back as `invalid_input` and is free. A domain the provider rejects comes back as an `error` row and is free, and the other 999 domains of the call still get their score.
- On the Apify platform: schedule it, call it by API, send the result to Google Sheets, Make, Zapier, n8n or a webhook.

Use it to sort a list of link-building prospects, qualify leads by site strength, clean a guest-post list, or follow the authority of your clients' sites month by month.

### What data does it return?

One row per distinct domain. Every field is always present, `null` when it does not apply.

| Field | Example | Description |
|---|---|---|
| `input`, `domain`, `targetMode` | `www.apify.com`, `apify.com`, `domain` | What you pasted, what was rated, and the mode |
| `domainAuthority` | `79` | DataForSEO domain rank, 0-100 |
| `metric` | `DataForSEO domain rank 0-100, not Moz DA` | What the score is |
| `spamScore` | `16` | Backlink spam score, 0-100 (option). `null` when the provider has no score |
| `referringDomains`, `referringDomainsNofollow`, `referringMainDomains` | `13061`, `5698`, `10477` | Referring domains, those linking only with nofollow, and main domains (option) |
| `hasLinkData` | `true` | `false`: the provider knows nothing about the domain. `null`: a 0 that cannot be read without referring domains |
| `previousDomainAuthority`, `domainAuthorityChange`, `previousCheckedAt` | `77`, `2` | Tracking only |
| `status`, `error`, `note` | `ok` | `ok`, `error` or `invalid_input`. Only `ok` rows are charged. `note` explains a metric left empty |
| `checkedAt`, `dataSource` | `2026-11-09T12:00:00Z`, `DataForSEO` | When, and from where |

### How to check domain authority in bulk

1. Click Try for free.
2. Paste your domains or URLs, one per line.
3. Keep Registered domain (default), or pick Exact to rate a subdomain.
4. Optionally tick Spam score, Referring domains and Track changes.
5. Press Start, then download the dataset as JSON, CSV or Excel.

### How much does it cost?

You pay a start fee of $0.002, a flat fee per call to the provider, and a price per domain row. The row price falls with your Apify plan: Free and Bronze pay the first price, Silver the middle one, Gold and above the last one.

| Event | Free / Bronze | Silver | Gold+ | When |
|---|---|---|---|---|
| Metric batch call | $0.05 | same | same | Each successful call, up to 1,000 domains per call and per metric |
| Domain row | $0.001 | $0.00075 | $0.0005 | Each `ok` row |

A chunk of up to 1,000 domains makes one call for the rank, plus one for the spam score and one for the referring domains if you ask for them. Examples on Free or Bronze, Gold in brackets, start fee included:

- 10 domains, rank only: $0.002 + $0.05 + 10 × $0.001 = $0.062 ($0.057).
- 1,000 domains, rank only: $0.002 + $0.05 + 1,000 × $0.001 = $1.052 ($0.552).
- 1,000 domains with spam score and referring domains: $1.152 ($0.652).
- 10,000 domains, rank only: $10.502 ($5.502).

When the provider rejects one domain of a call, the whole call fails. The Actor then splits the list in halves until it finds the bad domain, so the others still get their score. Each successful half is one more batch call fee. Failed calls are free. One rejected domain in a list of 1,000 adds 8 or 9 calls, about $0.40 to $0.45; in a list of 50, 4 or 5 calls, about $0.20 to $0.25. This is rare: lines that cannot be a domain are already removed before any call. Past 3 rejected domains in the same chunk, the Actor stops searching to protect the provider account: the domains it could not score come back as `error` rows, not charged, and you can run them again alone. A domain scored but rejected for the spam score or the referring domains keeps its score, with that metric empty and a `note`.

The spending limit you set on a run is never exceeded. The Actor checks that a call and its rows fit before sending it. Data it already paid for is always delivered: if the limit stops it between two metrics, the rows come with the score and the missing metric empty, with a `note`.

The provider's Backlinks API only has live calls (no cheaper queued mode), so there is no slower and cheaper option to offer here.

Free Apify plan: up to 0.15 USD of DataForSEO data per day; paid plans unlimited.

### Input

| Field | What it does |
|---|---|
| `domains` | Domains or URLs, one per line, up to 10,000 distinct targets |
| `targetMode` | `domain` (default): the whole site. `exact`: the host or URL as written |
| `includeSpamScore` | Adds `spamScore`, one more call per chunk |
| `includeReferringDomains` | Adds referring domain counts and makes `hasLinkData` exact, one more call per chunk |
| `trackChanges`, `monitorName` | Previous score and change, name of the memory |
| `webhookUrl` | Receives a JSON summary when the run ends |
| `cacheMaxAgeHours` | Reuse identical requests for this many hours, 72 by default, `0` for always fresh |

### Output

```json
{
  "rowType": "domain",
  "input": "https://www.apify.com/store",
  "domain": "apify.com",
  "targetMode": "domain",
  "domainAuthority": 79,
  "metric": "DataForSEO domain rank 0-100, not Moz DA",
  "spamScore": null,
  "referringDomains": null,
  "hasLinkData": true,
  "previousDomainAuthority": null,
  "domainAuthorityChange": null,
  "status": "ok",
  "error": null,
  "note": null,
  "checkedAt": "2026-11-09T12:00:00Z",
  "dataSource": "DataForSEO"
}
```

A SUMMARY record in the key-value store gives counters: valid and invalid targets, duplicates removed, domain rows, error rows, domains not processed, the events charged, the stop reason and, with tracking, how many domains had a previous score and how many changed. The list of domains whose score moved most is only in the webhook payload.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/bulk-domain-authority-checker").call(run_input={
    "domains": ["apify.com", "https://www.example.co.uk/blog", "moz.com"],
    "includeReferringDomains": True,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["domainAuthority"], row["hasLinkData"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~bulk-domain-authority-checker/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["apify.com", "crawlee.dev"]}'
```

### Track score changes

Turn on Track changes and schedule the Actor, monthly or weekly. Each row then carries the previous score, the change and the date of the previous check. The memory is a named key-value store, `domain-authority-monitor`, in your account. Without a name it depends only on the target mode, so adding or removing a domain keeps the history of the others. A name lets you keep several separate histories. The webhook summary lists the 100 domains whose score moved most.

### Rerun without waiting

A request identical to one already made from your account in the last 72 hours is answered from a cache kept in your account (named key-value store `domain-authority-cache`), instantly and with the same figures. The cache is yours: nothing is shared between accounts. It is not used when Track changes is on. Set **Reuse identical requests for (hours)** to `0` to always fetch fresh data.

### FAQ

#### Is this Moz Domain Authority?

No. Moz DA is computed by Moz from Moz's index. This score is computed by DataForSEO from its own backlink index, on the same 0-100 scale. Expect differences of several points, sometimes more. Use it to compare, sort and follow domains. If a client contract names Moz DA, use Moz.

#### Why does `www.example.com` score lower than `example.com`?

Because the provider rates exactly the host it receives, and most links point to the bare domain. That is why the Actor rates the registered domain by default.

#### Why is a domain at 0?

Either it has almost no links, or the provider does not know it: it returns 0 in both cases, without error. Tick Referring domains and read `hasLinkData`: `false` means unknown.

#### How many domains can I send?

Up to 10,000 distinct domains per run, in calls of 1,000. Duplicates are removed before counting.

#### Is it legal?

The data comes from a licensed commercial API, not from scraping websites or search engines. It covers links between public websites, not personal data.

#### Something is missing or broken

Open an issue on the Issues tab with the run link.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Bulk Domain Authority Checker page](https://alexis.morain.fr/en/scrapers/bulk-domain-authority-checker/) of my site. The [SEO and search engines family page](https://alexis.morain.fr/en/scrapers/families/seo/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

One domain or URL per line, 1 to 10,000 distinct targets. In the default target mode <code>www.apify.com</code>, <code>blog.apify.com</code> and <code>https://apify.com/store</code> are all read as <code>apify.com</code>, so every row rates the whole site. Duplicates are removed. A line that is not a valid domain comes back as an <code>invalid_input</code> row and is not charged.<br><br>The score is DataForSEO's domain rank, <b>not the Moz Domain Authority</b>: do not expect the same numbers as Moz.

## `targetMode` (type: `string`):

<b>Registered domain</b> (default): the whole site, subdomains included, whatever form you paste. <code>www.apify.com</code> is sent as <code>apify.com</code>.<br><br><b>Exact</b>: the host or URL exactly as written, to rate one subdomain or one page. The provider rates exactly what it is sent: <code>apify.com</code> is 79, <code>www.apify.com</code> 56 and <code>blog.apify.com</code> 45 (measured on 9 November 2026).

## `includeSpamScore` (type: `boolean`):

Adds the DataForSEO backlink spam score of each domain (0-100, in <code>spamScore</code>). Billed as one more batch call fee per chunk of up to 1,000 domains. Empty (<code>null</code>) when the provider has no score for the domain.

## `includeReferringDomains` (type: `boolean`):

Adds the number of referring domains, those that link only with nofollow, and the referring main domains (<code>referringDomains</code>, <code>referringDomainsNofollow</code>, <code>referringMainDomains</code>). It also lets <code>hasLinkData</code> tell an unknown domain (<code>false</code>) from a rank of 0 you cannot interpret (<code>null</code>). Billed as one more batch call fee per chunk of up to 1,000 domains.

## `trackChanges` (type: `boolean`):

Keeps the last rank of each domain in a named store of your account, <code>domain-authority-monitor</code>, and fills <code>previousDomainAuthority</code>, <code>domainAuthorityChange</code> (new rank minus previous rank, <code>null</code> on the first run) and <code>previousCheckedAt</code>. Schedule the Actor to follow a list over time. No extra charge and no extra provider call.<br><br>A rank of 0 does not prove the provider has no data for a domain: it returns 0 without any error for domains it does not know.

## `monitorName` (type: `string`):

Name of the memory, 100 characters at most. Leave empty and the memory depends only on the target mode: adding or removing a domain keeps the history of the others. A name lets you keep several separate histories.

## `webhookUrl` (type: `string`):

Optional. The run summary is sent there by POST when the run ends (Slack, Discord, Zapier...), with the up to 100 domains whose rank moved most when tracking is on (<code>changes</code>). The URL is never written to a log.

## `cacheMaxAgeHours` (type: `integer`):

Backlink metrics are refreshed by the provider about once a day, and a domain's rank moves slowly. A request identical to one already made <b>from your account</b> within this many hours is answered from a cache stored in your account (named key-value store <code>domain-authority-cache</code>), with the same data. Not used when tracking is on. Set to <code>0</code> to always fetch fresh data.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "targetMode": "domain",
  "includeSpamScore": false,
  "includeReferringDomains": false,
  "trackChanges": false,
  "monitorName": "",
  "cacheMaxAgeHours": 72
}
```

# Actor output Schema

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

All rows in the default dataset.

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

Targets received, valid and invalid; rows delivered; events charged; tracking counters.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/bulk-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"] }

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/bulk-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"
  ]
}' |
apify call alexmorain/bulk-domain-authority-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/bulk-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/5mHFKdwiBrlUIMhtf/builds/zaD1SnUGh0OVhLfmo/openapi.json
