# Domain Authority Checker - Backlinks & Traffic Rank, Bulk (`tidytools/domain-authority`) Actor

Bulk domain authority from open web data: 0-100 authority score, referring domains, web graph rank, Majestic referring subnets and Chrome traffic rank for any domain. No Ahrefs or Moz login. $3 per 1,000 domains.

- **URL**: https://apify.com/tidytools/domain-authority.md
- **Developed by:** [Yukai Lin](https://apify.com/tidytools) (community)
- **Categories:** SEO tools, Lead generation, Developer tools
- **Stats:** 5 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 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.
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 Domain Authority Checker do?

**Paste a list of domains, get an authority score (0-100), referring domains and a traffic rank for each one, at $3 per 1,000 domains with data.** Domains that nothing links to, duplicates and invalid lines are free.

Give it a list of domains (or URLs, or e-mail addresses). For each one it returns, in bulk:

- an **authority score from 0 to 100**,
- **referring domains**: how many other websites link to it,
- its **web graph rank** (harmonic centrality) and **PageRank position** among 133 million domains,
- **Majestic Million** rank, referring subnets and referring IPs (for the top 1 million sites),
- a **traffic rank** from Chrome's real-user data: "Top 1K / 5K / 10K / 50K / 100K / 500K / 1M websites",
- the number of subdomains seen.

It works for **any domain on the web**, not just big sites: the current data covers **120 million domains** that at least one other domain links to.

**Open data, no scraping of SEO tools.** The numbers come from public datasets, not from logging in to Ahrefs, Moz, Semrush or Similarweb:

| Data | Source | Licence |
|---|---|---|
| Web graph rank, PageRank, referring domains, subdomains | [Common Crawl web graph](https://commoncrawl.org/web-graphs), domain level, July-September 2026 (2.1 billion links between 133 million domains) | Common Crawl Terms of Use |
| Majestic rank, referring subnets and IPs | [Majestic Million](https://majestic.com/reports/majestic-million) | CC BY 3.0 |
| Traffic rank buckets | Chrome UX Report top origins ([crux-top-lists](https://github.com/zakird/crux-top-lists)) | public CrUX data |

The data is refreshed when Common Crawl publishes a new quarterly web graph; every row says which release it came from (`dataRelease`).

#### Real results (3 October 2026)

| Domain | Authority | Referring domains | Web graph rank | Traffic rank (Chrome) |
|---|---|---|---|---|
| google.com | 98 | 15,604,344 | 3 | Top 1K |
| wikipedia.org | 91 | 2,198,837 | 14 | Top 1K |
| bbc.co.uk | 81 | 249,224 | 90 | Top 1K |
| zapier.com | 72 | 48,072 | 586 | Top 50K |
| apify.com | 60 | 3,556 | 5,287 | Top 100K |
| scrapingbee.com | 46 | 956 | 436,782 | Top 1M |
| a local plumber's site | 16 | 4 | 31,773,792 | - |

### Use cases

- **Link building and outreach**: score a list of prospect sites and keep the ones worth contacting.
- **Lead scoring**: rank a list of company websites (from Google Maps, a CRM or a trade-show list) by web presence.
- **Expired and for-sale domains**: check how many sites still link to a domain before you buy it.
- **Competitor and market maps**: compare the authority and popularity of every site in a niche.
- **Data enrichment**: run it on the `website` field of another Actor's dataset (Dataset ID input).

### How much does it cost?

| Event | Price | When |
|---|---|---|
| Domain checked | **$3.00 / 1,000 domains** | a domain returned with its authority data |

**Free:** domains that no other domain links to in the web graph (authority 0, `found: false`), duplicates (checked once) and invalid lines. **No start fee.** Larger Apify plans get the usual volume discount (Silver 10%, Gold and above 20%).

**Example:** 10,000 prospect domains = **$30** at most, typically less because unknown domains are free. Speed: well-known domains are answered in seconds; 500 domains that mostly are not in the data take about two minutes.

For comparison (Apify Store, checked 3 October 2026): Actors that read these metrics from Ahrefs, Semrush or Moz charge $0.01-$0.015 per domain or row (the most used one, 1,048 users in 30 days, charges $0.015); Similarweb traffic Actors charge $0.002-$0.013 per site. Those return the commercial tools' own metrics (Ahrefs DR, Moz DA, estimated visits), which this Actor does not have.

#### Control your cost

- **Before it starts**, the run logs its worst-case cost (domains x price) and compares it with your **maximum charge per run**. The run never goes past the maximum: it checks as many domains as still fit (counting every domain as if it had data), then stops. `SUMMARY.status` is `LIMIT_REACHED` and `SUMMARY.notProcessed` lists the domains that were not checked, so the actual charge can be a little below the maximum.
- Every row has `charged: true` or `false`; failed rows have an `error` that ends with "(not charged)".

### How to use it

1. Paste domains, URLs or e-mail addresses into **Domains**, one per line, or pick a **Dataset ID** (and **Dataset field**) from another run.
2. Click **Start**. The **Domains (overview)** tab shows authority, referring domains and ranks; **Domains (all fields)** has everything.

Subdomains are checked as their registrable domain: `blog.example.co.uk` becomes `example.co.uk`, `someone.github.io` becomes `github.io` (the web graph counts links per registrable domain). The original line stays in `input`.

#### Input example

This is the input the form is prefilled with; a run with it takes a few seconds and costs only cents:

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

#### Output example

Real result (3 October 2026):

```json
{
    "input": "apify.com",
    "inputs": ["apify.com", "https://apify.com/store"],
    "domain": "apify.com",
    "found": true,
    "authorityScore": 60,
    "authorityPercentile": 99.99,
    "referringDomains": 3556,
    "webGraphRank": 5287,
    "pageRankPosition": 19402,
    "subdomains": 29,
    "majesticRank": 16288,
    "majesticReferringSubnets": 2586,
    "majesticReferringIPs": 5911,
    "chromeTrafficBucket": 100000,
    "trafficRank": "Top 100K websites (Chrome)",
    "dataRelease": "cc-main-2026-jul-aug-sep",
    "charged": true
}
```

#### How the authority score is calculated

The score is the average of two parts, each from 0 to 100:

- **rank part**: `100 x (1 - log10(webGraphRank) / log10(133,241,980))^0.6`, where the web graph rank is the domain's harmonic centrality position (how close it is to every other domain through links);
- **link part**: `100 x log10(1 + referringDomains) / 7`, so 10 million referring domains = 100.

It is our own transparent metric, **not** Moz Domain Authority or Ahrefs Domain Rating, and it will not match them exactly. It is consistent across all 120 million domains, so it is good for ranking and filtering lists.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/tidytools~domain-authority/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains":["apify.com","zapier.com","example.org"]}'
```

**With AI agents (MCP):** connect Apify's MCP server (`https://mcp.apify.com?tools=tidytools/domain-authority`) to Claude, Cursor or any MCP client and ask, for example, "Which of these 50 sites has the most referring domains?". Minimal input: `{"domains": ["apify.com"]}`. Domains without data are not charged and say so in `note`; invalid lines carry an `errorType`.

### Limitations

- **Referring domains come from Common Crawl's crawl**, which sees a large share of the public web but not all of it. Counts are lower than Ahrefs' or Semrush's (which crawl more), and the same for every domain, so comparisons between domains are fair.
- The data is a **quarterly snapshot** (currently July-September 2026), not live. A link added last week is not in it yet.
- **No list of individual backlinks** (which pages link, anchor text): this Actor returns counts and ranks per domain.
- Majestic data exists only for the top 1 million domains and Chrome traffic buckets for the top 1 million origins; other domains show `null` there.
- The traffic rank is a popularity bucket, not a number of visits.

### FAQ

**Does the Actor collect usage data?** The Actor sends one anonymous usage counter per run (input type, item count range, outcome) to improve the tool; no URLs, content or account data.

**What if I paste something that is not a domain, or nothing at all?** Each bad line (including a domain ending that does not exist, such as `example.c`) becomes a row with `errorType: "invalid_input"` and `charged: false`; if no line is usable the run still finishes normally (no failed run) with that error row and a status message, and costs nothing. A wrong Dataset ID or field gives the same kind of row.

**Does a URL, e-mail address or subdomain work?** Yes. `https://www.nytimes.com/section/world`, `info@hubspot.com` and `blog.example.co.uk` are all reduced to their registrable domain (`nytimes.com`, `hubspot.com`, `example.co.uk`) and checked once; the original text stays in `input`. Upper case, a trailing dot, a port and pasted quotes, brackets or a trailing `;` are ignored, and internationalised names such as `bücher.de` are looked up in punycode (`xn--bcher-kva.de`; `domain` shows the punycode form). Names with a label over 63 characters or a label starting or ending with a hyphen are invalid lines. A public suffix that is itself a website (`gov.uk`, `co.uk`) is looked up as it is and charged if the web graph has data for it. Hosting domains such as `github.io` are scored as one site, so a small `someone.github.io` page shows the score of `github.io`.

**Why is my site "not found"?** No other domain links to it in the July-September 2026 web graph (or the crawl did not reach it). It is reported with authority 0 and not charged.

**Why is the score different from Ahrefs DR or Moz DA?** Different data and a different formula. Use one metric consistently when comparing sites.

**Can I use the results commercially?** Yes. Common Crawl data is free to use under its terms of use; Majestic Million is CC BY 3.0 (credit: "Majestic Million, majestic.com").

### Support

Open an issue in the **Issues** tab with the domains and the run link. Issues are checked regularly.

# Actor input Schema

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

Domains, website addresses or e-mail addresses, one per line (example.com, https://www.example.com/page, info@example.com). Subdomains are checked as their registrable domain (blog.example.co.uk -> example.co.uk). Up to 100,000 per run; duplicates are merged. Invalid lines become a result row with errorType "invalid_input" (not charged).

## `datasetId` (type: `string`):

Check the domains in another Actor run's dataset, e.g. the website field of a lead list, Google Maps or backlink export.

## `datasetField` (type: `string`):

Field with the domain, URL or e-mail address, e.g. "website", "domain" or "email" (dot paths work). Empty = the first URL field found (url, website, link, domain...).

## `maxConcurrency` (type: `integer`):

Batches of 50 domains looked up at the same time.

## Actor input object example

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

# Actor output Schema

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

No description

## `full` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("tidytools/domain-authority").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",
        "tools.yukai.uk",
        "github.com",
        "bbc.co.uk",
    ] }

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

```

## MCP server setup

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

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/d2qqhs32rIPvhdnbh/builds/L6xGGJln8mBnSAKZ3/openapi.json