# Domain Authority Checker – Open-Data Rank, No API Key (`gazidev/domain-authority-checker`) Actor

Bulk domain authority and popularity check from open data: Majestic Million rank, referring subnets and IPs, Chrome UX Report (CrUX) top-list bucket, domain age (RDAP/WHOIS) and a documented 0-100 Open Authority Score. No API key. Not Moz DA.

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

## Pricing

from $0.20 / 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

## Domain Authority Checker – Open-Data Rank, No API Key

**Bulk domain authority checker** for SEO, link building and lead qualification. Paste a list of domains (or URLs and emails) and get one row per domain with:

- the **Majestic Million rank**
- **referring subnets and referring IPs**
- the **Chrome UX Report (CrUX) popularity bucket** (top 1k … top 1M)
- **domain age**
- a documented **0–100 Open Authority Score**

It uses open data only, so there is no API key, no login and no scraping of paid SEO tools. It costs **$0.20 per 1,000 domains**.

> **Honest note:** this is **not Moz DA, Ahrefs DR or Semrush AS**, and it does **not** estimate traffic. Those are proprietary metrics. The data here comes from public open-data lists that cover the **top ~1 million domains**. A small site that is not in those lists gets a score of 0 and is **not charged**.

### What you get per domain

| Field | Source | Meaning |
|---|---|---|
| `openAuthorityScore` (0–100), `authorityTier` | computed | Blend of the signals below (formula below) |
| `majesticRank`, `majesticTldRank` | Majestic Million (daily) | Global and per-TLD rank by number of referring subnets |
| `refSubnets`, `refIps` | Majestic Million | Distinct class-C subnets and IPs linking to the domain, a robust backlink-diversity signal |
| `majesticRankChange`, `refSubnetsChange` | Majestic Million | Change since the previous daily list (positive rank change = moved up) |
| `cruxRank`, `cruxBucket`, `cruxOrigin` | Chrome UX Report top list (monthly) | Real Chrome-user popularity bucket of the best origin under the domain (`top 1k`, `top 5k`, `top 10k`, `top 50k`, `top 100k`, `top 500k`, `top 1M`) |
| `domainCreatedAt`, `domainAgeDays`, `domainAgeYears`, `registrar` | RDAP (IANA bootstrap), WHOIS fallback | Domain age, a common trust signal |
| `inMajesticMillion`, `inCruxTopList`, `registered` | – | Quick filters |

#### Open Authority Score formula

```
rankScore   = 100 × (1 − log10(majesticRank) / 6)              # rank 1 → 100, rank 1,000,000 → 0
subnetScore = 100 × log10(1 + refSubnets) / log10(1 + 500,000)  # capped at 100
cruxScore   = 100 − 15 × log10(cruxBucket / 1000)              # top 1k → 100, 10k → 85, 100k → 70, 1M → 55
score       = round(0.35 × rankScore + 0.35 × subnetScore + 0.30 × cruxScore)
```

A list the domain is missing from counts as 0. If you switch a source off, the weights are renormalized.

| Score | Tier |
|---|---|
| ≥ 80 | very high |
| 60–79 | high |
| 40–59 | medium |
| 20–39 | low |
| 1–19 | very low |
| 0 | not ranked |

Domain age is returned but is not part of the score.

### Use cases

- **Link building and guest-post outreach:** sort a prospect list by `refSubnets` / score and skip low-authority sites.
- **Lead qualification:** filter company domains by web popularity (`cruxBucket`, `majesticRank`) before sales outreach.
- **Domain investing:** check rank, backlink diversity and age of expiring or for-sale domains in bulk.
- **SEO reporting:** track `majesticRankChange` / `refSubnetsChange` for your and competitors' domains with a scheduled run.
- **AI agents:** a cheap, deterministic "how big/trusted is this site?" tool.

### Input

```json
{
  "domains": ["apify.com", "github.com", "bbc.co.uk"],
  "useMajestic": true,
  "useCrux": true,
  "includeDomainAge": true
}
```

- **`domains`** accepts bare domains, URLs (`https://www.example.com/page`) and emails (`jane@example.com`). Each one is reduced to the registrable domain using the Public Suffix List (`blog.example.co.uk` becomes `example.co.uk`), and duplicates are removed.
- **`bulkText`**: paste lines, comma-separated text or a whole CSV.
- **`sourceFileUrl`**: a public TXT/CSV file, such as a published Google Sheet.
- **Advanced:** `maxDomains`, `maxConcurrency` (domain-age lookups, default 5) and `timeoutSecs`.

### Output example

Real run, 2026-10-26 (more rows in `SAMPLE_OUTPUT.json`):

| domain | score | tier | Majestic rank | ref. subnets | CrUX | age (y) |
|---|---|---|---|---|---|---|
| google.com | 100 | very high | 1 | 505,750 | top 1k | 29.1 |
| github.com | 92 | very high | 10 | 250,076 | top 1k | 19.0 |
| bbc.co.uk | 82 | very high | 109 | 60,783 | top 1k | 31.9 |
| example.com | 75 | high | 117 | 59,193 | top 50k | 31.2 |
| nhs.uk | 73 | high | 473 (www.nhs.uk) | 24,182 | top 5k | – |
| trendyol.com | 64 | high | 7,624 | 3,828 | top 1k | 17.1 |
| apify.com | 52 | medium | 15,688 | 2,457 | top 100k | 17.4 |
| small-bakery-blog-12345.net | 0 | not ranked | – | – | – | – (free) |

```json
{
  "input": "GitHub.com",
  "domain": "github.com",
  "openAuthorityScore": 92,
  "authorityTier": "very high",
  "inMajesticMillion": true,
  "majesticEntry": "github.com",
  "majesticRank": 10,
  "majesticTldRank": 10,
  "majesticRankChange": 0,
  "refSubnets": 250076,
  "refIps": 620700,
  "refSubnetsChange": 98,
  "inCruxTopList": true,
  "cruxRank": 1000,
  "cruxBucket": "top 1k",
  "cruxOrigin": "https://github.com",
  "registered": true,
  "domainCreatedAt": "2007-10-09T18:20:50Z",
  "domainAgeDays": 6957,
  "domainAgeYears": 19.0,
  "registrar": "MarkMonitor Inc.",
  "ageSource": "rdap",
  "attribution": "Majestic Million by Majestic (CC BY 3.0, ...); Chrome UX Report top lists by Google via github.com/zakird/crux-top-lists (CC BY-SA 4.0)",
  "checkedAt": "2026-10-26T11:54:00+00:00"
}
```

The **Overview** tab shows these columns as a table. The key-value record `SOURCES` stores the list dates and attribution for each run.

### Pricing

Pay per event, only for domains that return data:

| Event | Price |
|---|---|
| Domain checked (found in a list, or a creation date was found) | **$0.0002** ($0.20 / 1,000) |
| Actor start | $0.005 per run (covers downloading the two open-data lists, ~36 MB; batch domains into one run) |
| Invalid input, or a domain with no data | free |

How it compares (Apify Store, Oct 2026):

| Actor | Price per domain | Data |
|---|---|---|
| Moz-scraper type actors | $0.001–$0.009 | Moz DA (scraped) |
| **This Actor** | **$0.0002** | Majestic rank + referring subnets + CrUX + age |

You can set a maximum total charge per run. The Actor stops cleanly when it is reached.

### Limits and how it works

- **Coverage:** top ~1M domains in each list. Below that, the score is 0.
- **Domain-level:** subdomains are folded into the registrable domain. The Majestic entry for `www.<domain>` is used when the bare domain is not listed. Sites on shared hosts (e.g. `*.blogspot.com`) get the host platform's rank.
- **Freshness:** Majestic is updated daily. The CrUX list is monthly.
- **Domain age:** some registries publish no creation date (e.g. `.de`, some `.uk` names), so age may be empty there.
- **Speed:** the Actor streams both lists once per run and stops early when every domain is found.
  - A full pass reads about 36 MB and takes about 20 s.
  - It then takes about 0.5–2 s per domain for age lookups (parallel).
  - Thousands of domains per run are fine. Batch them into one run instead of many small runs.

### Data sources and licences

- **Majestic Million**, © Majestic-12 Ltd, licensed under [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/) – https://majestic.com/reports/majestic-million
- **Chrome UX Report top lists**, Google CrUX public data, compiled at https://github.com/zakird/crux-top-lists, licensed [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). Output derived from it carries the same licence (ShareAlike). Keep the `attribution` field when you redistribute.
- **RDAP / WHOIS:** public registry protocols.

The Actor downloads the published files only, at most once per run, with an identifying User-Agent. It does not crawl majestic.com or any SEO tool.

### FAQ

**Is this Moz Domain Authority?** No. Moz DA is proprietary. This is an open, reproducible score from Majestic and Google CrUX data. It correlates with DA for large sites but is not the same number.

**Why does my domain get 0?** It is not in the top ~1M of either list. Most small business sites are not. You are not charged for those rows unless a creation date was found.

**Can I use it with AI agents / Apify MCP?** Yes. Add it to the Apify MCP server (`mcp.apify.com`) and an agent can call it with `{"domains": [...]}` to get a compact authority row per domain.

**Can I schedule it?** Yes. Use an Apify schedule and compare `majesticRankChange` / `refSubnetsChange` over time.

# Actor input Schema

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

Domains to check, e.g. `example.com`. URLs (`https://www.example.com/page`) and email addresses (`jane@example.com`) are accepted; the registrable domain is used (`blog.example.co.uk` becomes `example.co.uk`).

## `bulkText` (type: `string`):

Paste a long list: one domain per line, comma/semicolon separated, or a whole CSV export (the first cell that looks like a domain, URL or email in each row is used).

## `sourceFileUrl` (type: `string`):

Public URL of a .txt or .csv file with domains (e.g. a Google Sheets 'Publish to web' CSV link).

## `useMajestic` (type: `boolean`):

Look up each domain in today's Majestic Million (top 1M domains by referring subnets, updated daily, CC BY 3.0).

## `useCrux` (type: `boolean`):

Look up the domain's best origin in Google's Chrome UX Report top-1M list (monthly; buckets top 1k / 5k / 10k / 50k / 100k / 500k / 1M; CC BY-SA 4.0).

## `includeDomainAge` (type: `boolean`):

Creation date, age in days/years and registrar from the official RDAP protocol (port-43 WHOIS fallback for ccTLDs without RDAP). Adds about 0.5-2 s per domain.

## `maxDomains` (type: `integer`):

Stop after this many domains (0 = no limit).

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

Parallel RDAP/WHOIS lookups. Each registry server is additionally limited to a few requests at a time.

## `timeoutSecs` (type: `integer`):

Timeout for each RDAP/WHOIS request and for reading the list downloads.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "github.com",
    "bbc.co.uk"
  ],
  "useMajestic": true,
  "useCrux": true,
  "includeDomainAge": true,
  "maxDomains": 0,
  "maxConcurrency": 5,
  "timeoutSecs": 15
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

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

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

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

```

## MCP server setup

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