# Domain Authority Checker: Bulk Backlink & Link Rank Data (`albecas100/domain-authority-checker`) Actor

Check authority score, referring domains and global link rank for thousands of domains in seconds. Built on the open Common Crawl web graph of 135M domains, not on scraping SEO tools. $2 per 1,000 domains.

- **URL**: https://apify.com/albecas100/domain-authority-checker.md
- **Developed by:** [Alex Castella](https://apify.com/albecas100) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## Domain Authority Checker: Bulk Backlink & Link Rank Data

Check how well-linked any domain is, for thousands of domains at once, in seconds. For every domain you get an authority score from 0 to 100, the number of other domains that link to it, and its rank among 135 million domains on the web.

The data comes from the open **Common Crawl web graph**: a map of which websites link to which, built by the non-profit Common Crawl from billions of crawled pages. This Actor does not scrape Ahrefs, Semrush, Moz or any other SEO tool. It doesn't log in anywhere, and it doesn't break when those sites change.

- **Fast and bulk:** 100,000 domains finish in about two minutes.
- **Cheap:** $2 per 1,000 domains. Domains without data are free.
- **Stable:** no scraping, no captchas, no proxies, no API keys.
- **Transparent:** every number comes from a public dataset, and every row names the release it came from.

### Who it's for

- **Link builders and SEO agencies:** sort an outreach list by authority before you send a single email.
- **Domain investors:** screen long lists of expiring or for-sale domains for real backlink strength.
- **PR and affiliate teams:** rank publications and partner sites by reach.
- **Lead generation:** add a "how big is this company online" signal to a list of company websites.
- **Researchers:** measure the link popularity of large sets of sites.

### How to use it

1. Paste domains into **Domains**, one per line. `stripe.com`, `https://www.stripe.com/pricing` and `sales@stripe.com` all work.
2. Run it.
3. Sort the **Scores** view by authority, or export to CSV, Excel or JSON.

#### Example input

```json
{
  "domains": ["apify.com", "wikipedia.org", "crawlee.dev"]
}
```

### What you get

| Field | Description |
|---|---|
| `domain` | The main domain that was checked (`shop.example.co.uk` is checked as `example.co.uk`) |
| `authorityScore` | 0 to 100. How central the domain is in the web's link graph, on a log scale |
| `referringDomains` | How many different domains link to it |
| `linkRank` | Its position among all domains in the graph by harmonic centrality. 1 is the best-linked |
| `topPercent` | The same position as a percentage. 0.5 means the top 0.5% of the web |
| `pageRankRank`, `pageRankScore` | The domain's position and 0 to 100 score by PageRank, a second link measure |
| `subdomainsSeen` | How many different hosts of the domain the crawl found |
| `found` | Whether the domain is in the index |
| `note` | Why there is no data, when `found` is false |
| `dataRelease` | The web graph release the numbers come from |

#### Example row

```json
{
  "domain": "apify.com",
  "found": true,
  "authorityScore": 56,
  "referringDomains": 3929,
  "linkRank": 5020,
  "topPercent": 0.0037,
  "pageRankScore": 60,
  "subdomainsSeen": 30,
  "dataRelease": "cc-main-2026-aug-sep-oct"
}
```

### Pricing

| Item | Price |
|---|---|
| Domain scored | $0.002 ($2 per 1,000 domains) |
| Domain not in the index | Free |
| Invalid or repeated entry | Free |

Set a spending limit on the run to cap your cost. The Actor stops cleanly when the limit is reached.

### How the score works

Common Crawl publishes a domain-level web graph every few months: each domain is a node, and a link from any page of one domain to another domain is an edge. This release covers 135 million domains and 1.8 billion links between them.

The authority score combines three link measures, all on a log scale:

- **50%: referring domains.** How many different domains link to this one.
- **30%: PageRank.** Whether those links come from domains that are well linked themselves.
- **20%: harmonic centrality.** How close the domain is to the rest of the web through links.

Some reference points from the current release: google.com 98, wikipedia.org 88, stripe.com 82, apify.com 56, a small business site with a few dozen referring domains around 20 to 30.

It is its own measure. It is not Moz Domain Authority or Ahrefs Domain Rating, and its numbers won't match theirs, but it answers the same question: how well-linked is this domain compared with the rest of the web?

### Limitations

- **Coverage:** the index holds the 12.7 million domains that at least 10 other domains link to. Domains with fewer links, and new domains, are returned with `found: false` and a score of 0, free of charge.
- **Freshness:** the data is from the latest Common Crawl web graph release named in `dataRelease`. New releases come every few months, and the Actor is updated after each one.
- **Domain level only:** scores are per domain, not per page. All links count equally, including nofollow links.
- **Crawl sample:** Common Crawl doesn't visit every page on the web, so counts are lower than the real totals. They are useful for comparing domains with each other.

### Run report

Each run saves a **Run report** with the number of domains checked, with and without data, and details of the web graph release used.

### Removal requests

Site owners who want their domain left out can open an issue on this Actor's **Issues** tab.

### Data source

Web graph data: [Common Crawl](https://commoncrawl.org/web-graphs), used under the [Common Crawl Terms of Use](https://commoncrawl.org/terms-of-use). This Actor is not affiliated with Common Crawl, Moz, Ahrefs or Semrush.

# Actor input Schema

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

One per line. Domains (stripe.com), full addresses (https://www.stripe.com/pricing) and emails (sales@stripe.com) all work; each is checked as its main domain. Repeats are skipped and never charged. Up to 1,000,000 per run.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "wikipedia.org",
    "crawlee.dev"
  ]
}
```

# Actor output Schema

## `domains` (type: `string`):

One row per domain, including domains without data (free).

## `runReport` (type: `string`):

Domains checked, domains with and without data, and the web graph release used.

# 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",
        "wikipedia.org",
        "crawlee.dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("albecas100/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",
        "wikipedia.org",
        "crawlee.dev",
    ] }

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

```

## MCP server setup

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