# Domain Authority Checker - Bulk DA Score, Moz DA Alternative (`kantolabs/domain-authority-checker`) Actor

Bulk domain authority 0-100 from the open Common Crawl web graph of 133M domains: rank, top-% percentile and monthly trend. No Moz, Ahrefs or Semrush account, no scraping. $1 per 1,000 domains.

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

## Pricing

from $1.00 / 1,000 domain scoreds

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

## Domain Authority Checker - Bulk DA Scores from Open Web Data

Check the **authority of thousands of domains in seconds** without a Moz, Ahrefs or Semrush
account. Every domain gets a **0-100 authority score**, its **rank among 133 million domains**,
a **top-% percentile**, the number of subdomains seen on the web, and a **month-over-month trend**
(rising, falling or stable).

The scores are computed from the **Common Crawl web graph** - the open hyperlink map of the whole
public web that Common Crawl publishes about every month (each graph covers three months of crawling). Nothing is scraped from SEO tools, so there
are no logins, no captchas, no "credits" and no broken runs when a third-party site changes.

**$1 per 1,000 domains.** Domains that are not in the ranked list are free.

### What does Domain Authority Checker do?

Domain Authority Checker looks each domain up in the latest Common Crawl web graph (133 million domains) and returns a 0-100 authority score, the domain's rank by harmonic centrality and by PageRank, its top-% percentile, how many of its subdomains were seen, and the change since the previous graph. The whole graph ships inside the Actor, so no website and no SEO tool is contacted during a run.

### Use cases

- **Link building and outreach** - sort a prospect list of 10,000 blogs by authority and contact the strongest first.
- **Guest-post and PR vetting** - drop low-authority or falling sites before you pay for a placement.
- **Expired-domain and domain-investing research** - score an auction list in one run.
- **Lead scoring** - add "how established is this company online?" to a CRM export (pairs well with [Domain Lookup](https://apify.com/kantolabs/domain-whois-dns-ssl-lookup) and [Website Tech Stack Detector](https://apify.com/kantolabs/website-tech-stack-detector)).
- **Competitor tracking** - schedule a monthly run over your competitors and watch the trend column.
- **AI agents** - one tool call through the Apify MCP server answers "how authoritative is this site?".

### Who is it for?

- **Link builders and outreach teams** sorting prospect lists by authority.
- **PR and guest-post buyers** vetting sites before paying for a placement.
- **Domain investors** scoring auction and expired-domain lists.
- **Sales and RevOps teams** adding "how established is this company online?" to lead scoring.
- **SEO agencies** tracking competitors month over month.

### What you get per domain

| Field | Meaning |
|---|---|
| `authorityScore` | 0-100. Built from the domain's harmonic-centrality rank (how close it is to every other site through links) and its PageRank rank, on a log scale calibrated so the top 10 sites of the web score 96-100, a top-10,000 site about 72 and a top-1,000,000 site about 39. |
| `authorityTier` | `very high` (80+), `high` (60+), `medium` (40+), `low` (20+), `very low` |
| `harmonicCentralityRank` | Position among all ranked domains (1 = most central on the web) |
| `pageRankRank` | Position by PageRank |
| `topPercent` | The domain sits in the top X % of the web |
| `hostsInCrawl` | How many subdomains (hosts) of this domain were seen |
| `previousRank`, `rankChange`, `trend` | Rank in the previous graph (about a month earlier) and the direction: `up`, `down`, `stable` (within 5 %) or `new` |
| `ranked` | `false` when the domain is not in the top 12 million: it is new, parked or almost nobody links to it. Then `authorityScoreMax` gives the ceiling (20). These rows are **free**. |
| `dataRelease` | Which Common Crawl graph the numbers come from |

### How to use it

1. Click **Try for free**.
2. Paste domains, URLs or email addresses into **Domains**, one per line (10,000+ is fine).
3. Click **Start** - thousands of domains finish in seconds.
4. Sort the results table by `authorityScore`, or export to CSV, Excel or Google Sheets.

### Input

| Field | What it does | Default |
|---|---|---|
| `domains` | Domains, URLs or email addresses. `https://www.nytimes.com/section/world` and `ceo@shopify.com` are reduced to the registrable domain; duplicates are removed. | `apify.com`, `github.com`, `bbc.co.uk`, `wikipedia.org` |

```json
{
    "domains": ["stripe.com", "https://www.nytimes.com/section/world", "ceo@shopify.com", "books.toscrape.com"]
}
```

### Output

Real output from a cloud run (10 inputs in 3.5 seconds):

```json
[
    {
        "input": "https://www.nytimes.com/section/world",
        "domain": "nytimes.com",
        "ranked": true,
        "authorityScore": 91,
        "authorityTier": "very high",
        "harmonicCentralityRank": 62,
        "pageRankRank": 175,
        "topPercent": 0.000047,
        "hostsInCrawl": 544,
        "previousRank": 56,
        "rankChange": -6,
        "trend": "stable",
        "previousRelease": "cc-main-2026-jun-jul-aug",
        "dataRelease": "cc-main-2026-jul-aug-sep",
        "totalRankedDomains": 133241980
    },
    {
        "input": "ahrefs.com",
        "domain": "ahrefs.com",
        "ranked": true,
        "authorityScore": 86,
        "authorityTier": "very high",
        "harmonicCentralityRank": 717,
        "pageRankRank": 433,
        "topPercent": 0.000538,
        "hostsInCrawl": 37,
        "previousRank": 456,
        "rankChange": -261,
        "trend": "down"
    },
    {
        "input": "books.toscrape.com",
        "domain": "toscrape.com",
        "ranked": true,
        "authorityScore": 41,
        "authorityTier": "medium",
        "harmonicCentralityRank": 1905516,
        "pageRankRank": 113263,
        "topPercent": 1.430117,
        "hostsInCrawl": 5,
        "previousRank": 1919358,
        "rankChange": 13842,
        "trend": "stable"
    },
    {
        "input": "kantolabs-brand-new-domain-2026.com",
        "domain": "kantolabs-brand-new-domain-2026.com",
        "ranked": false,
        "authorityScore": null,
        "authorityScoreMax": 20,
        "authorityTier": "very low",
        "note": "Not in the top 12,000,000 of 133,241,980 domains in the Common Crawl web graph: very few other sites link to it (score below 20). New, parked or unlinked domains land here."
    }
]
```

The Console shows the results as a sortable table; export to CSV, Excel, JSON or Google Sheets, or
read them through the API.

### How much does it cost to check domain authority?

Pay per event: **$0.001 per domain scored** (plus a $0.00005 start fee).

| Domains checked | You pay |
|---|---|
| 100 | $0.10 |
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

Unranked domains and invalid inputs are pushed to the dataset but **not charged**. Set "Maximum
cost per run" and the run stops cleanly when it is reached. A 10,000-domain list finishes in
well under a minute because the whole web graph ships inside the Actor - no request per domain.

### How it compares

| | This Actor | Moz / Ahrefs / Semrush scraper Actors |
|---|---|---|
| Data source | Common Crawl web graph (open data, 133M domains) | Scraped from the vendor's website |
| Account or cookies needed | No | Often a paid vendor account or session |
| Breaks when the vendor changes its site | No | Yes |
| Speed | Thousands of domains per second | One page load per domain |
| Price | $1 per 1,000 domains | Typically $9-15 per 1,000 |
| Same number as Moz DA / Ahrefs DR | **No** - it is its own open metric | Yes |

**Be clear about what it is:** `authorityScore` is not Moz Domain Authority or Ahrefs Domain Rating.
Those are proprietary. It measures the same idea - how well linked a domain is across the web - from
a public, reproducible source, so the ranking of domains against each other is what to rely on.

### Integrations and API

Run it from your own code with the official `apify-client` package (Python shown; JavaScript works the same way):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("kantolabs/domain-authority-checker").call(run_input={
    "domains": [
        "stripe.com",
        "nytimes.com",
        "books.toscrape.com"
    ]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Or get the results in a single HTTP call:

```bash
curl -X POST "https://api.apify.com/v2/acts/kantolabs~domain-authority-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["stripe.com", "nytimes.com", "books.toscrape.com"]}'
```

- **AI agents (MCP)**: add the Apify MCP server to Claude, ChatGPT, Cursor or any MCP client and the agent can call this Actor as a tool.
- **No-code**: Make, Zapier, n8n, Google Sheets, webhooks and Apify Schedules work out of the box.

### Limits

- **Not Moz DA or Ahrefs DR.** It is its own open metric for the same idea; rely on how domains rank against each other.
- Only the top 12 million domains are ranked. Others come back `ranked: false` (score below 20) and are free.
- Scores are per registrable domain - no page-level or subdomain scores, and no list of backlinks.
- The data changes when Common Crawl publishes a new web graph, about monthly; `dataRelease` names the one used.

### FAQ

**How fresh is the data?** Common Crawl publishes a new domain-level web graph about every
month, each built from three months of crawling. This Actor uses the latest one (`dataRelease`
says which) and compares it to the previous one for the trend.

**Why is my domain not ranked?** It is not in the top 12 million of 133 million domains, which
means very few other sites link to it yet. That is itself a useful answer and it is free.

**Subdomains?** Scores are per registrable domain: `blog.example.com` is scored as `example.com`.
`hostsInCrawl` tells you how many subdomains exist.

**Does it return backlinks?** No. It returns authority and rank, not individual links.

**Is this allowed?** Yes. The web graph is open data published by the Common Crawl Foundation for
anyone to use. No website is visited during a run.

### Related Actors by Kanto Labs

- [Domain Lookup - WHOIS/RDAP, DNS, SSL & Email Security](https://apify.com/kantolabs/domain-whois-dns-ssl-lookup)
- [Website Tech Stack Detector](https://apify.com/kantolabs/website-tech-stack-detector)
- [Website SEO Audit](https://apify.com/kantolabs/website-seo-audit)
- [Company Enrichment - Logo, Socials, Industry & Size](https://apify.com/kantolabs/company-enrichment)

# Actor input Schema

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

Domains, website URLs or email addresses, one per line (thousands per run are fine). `https://blog.shop.example.co.uk/page` and `jane@example.com` are reduced to the registrable domain automatically; duplicates are removed.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "github.com",
    "bbc.co.uk",
    "wikipedia.org"
  ]
}
```

# Actor output Schema

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

No description

# 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",
        "github.com",
        "bbc.co.uk",
        "wikipedia.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kantolabs/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",
        "github.com",
        "bbc.co.uk",
        "wikipedia.org",
    ] }

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

```

## MCP server setup

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