# Domain Authority Checker, No Login (`conserving_celerytop/domain-authority-checker`) Actor

$3.00 per 1,000 domains on Starter ($7.50 on Free), less on Scale and Business. Check domain authority for up to 10,000 domains from open data: Majestic Million rank, referring subnets and IPs, Chrome UX Report bucket, plus domain age from RDAP. A 0 to 100 score per domain. No login.

- **URL**: https://apify.com/conserving\_celerytop/domain-authority-checker.md
- **Developed by:** [Don Mangu](https://apify.com/conserving_celerytop) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Domain Authority Checker: Open Data Rank, No Login

Check domain authority and popularity for up to 10,000 domains in one run. For each domain you get its **Majestic Million rank**, **referring subnets** and **referring IPs**, its **Chrome UX Report rank bucket** (top 1,000 up to top 1,000,000), and, if you turn it on, its **domain age, registrar and expiry date** from RDAP. Every row also has a simple **popularityScore** from 0 to 100 with the formula written out below.

All data comes from sources published under open licences or from the registries themselves. No login, no API key, and no scraping of paid SEO tools.

### What does this domain authority checker do?

- Looks up each domain in the latest Majestic Million (the million root domains with the most referring subnets) and returns its rank, TLD rank, referring subnets and referring IPs.
- Looks up each domain in the latest monthly Chrome UX Report global top sites list and returns the best bucket across all its origins (www, m. and other subdomains).
- Optionally asks each domain's registry RDAP server for the creation date, expiry date and registrar. Contact fields (registrant, admin, tech, abuse) are dropped and never stored.
- Returns one row per domain with the fields below and a `sources` list that credits every source used for that row.

### How to check domain authority in bulk

1. Paste your domains into **Domains**, one per line. URLs work too: `https://www.example.co.uk/page` becomes `example.co.uk`.
2. Pick the **Signals** you want: `majestic`, `crux`, `rdap`. The first two are on by default; turn on `rdap` for domain age and registrar.
3. Click **Start**. A few domains finish in seconds. A list of 10,000 domains without RDAP takes one to two minutes.
4. Download the results as JSON, CSV or Excel, or read them through the Apify API.

### How much does it cost?

You pay per domain checked: **$3.00 per 1,000 domains** ($0.003 each) on Apify's Starter plan, $2.75 per 1,000 on Scale, $2.50 per 1,000 on Business and $7.50 per 1,000 on the Free plan. Entries that are not valid domains are returned as free rows marked `invalid_input`. If no requested source answered for a domain, the row is marked `failed` and is not charged.

Worked example: 5,000 domains with all three signals cost 5,000 x $0.003 = $15.00 on the Starter plan ($12.50 on Business). Set a maximum charge for the run and the Actor stops cleanly when it is reached.

### Input example

```json
{
    "domains": ["apify.com", "wikipedia.org", "github.com"],
    "signals": ["majestic", "crux", "rdap"]
}
```

### Output example

```json
{
    "domain": "example.com",
    "input": "https://www.example.com/",
    "popularityScore": 66,
    "majesticRank": 108,
    "majesticTldRank": 74,
    "majesticRefSubnets": 61374,
    "majesticRefIPs": 164838,
    "cruxRankBucket": 50000,
    "cruxOrigin": "https://example.com",
    "domainCreated": "1995-08-14T04:00:00.000Z",
    "domainAgeYears": 31.1,
    "registrar": "RESERVED-Internet Assigned Numbers Authority",
    "expires": "2027-08-13T04:00:00.000Z",
    "rdapStatus": "ok",
    "sources": [
        "Majestic Million by Majestic-12 Ltd, https://majestic.com/reports/majestic-million, licensed under CC BY 3.0 https://creativecommons.org/licenses/by/3.0/",
        "Chrome UX Report top sites 202608 by Google, https://developer.chrome.com/docs/crux, licensed under CC BY 4.0 https://creativecommons.org/licenses/by/4.0/",
        "RDAP registry data, rdap.verisign.com"
    ],
    "status": "ok",
    "error": null,
    "checkedAt": "2026-09-26T17:00:00.000Z"
}
```

All values above were read on 26 Sep 2026: Majestic Million list of that day, Chrome UX Report list for August 2026, and the .com registry RDAP record.

| Field | Meaning |
| --- | --- |
| `domain` | Registrable domain that was checked |
| `majesticRank` | Position in the Majestic Million, 1 is highest; null if not listed |
| `majesticRefSubnets` | Distinct class C subnets linking to the domain |
| `majesticRefIPs` | Distinct IP addresses linking to the domain |
| `cruxRankBucket` | Chrome UX Report bucket: 1000, 5000, 10000, 50000, 100000, 500000 or 1000000 |
| `domainCreated`, `domainAgeYears`, `registrar`, `expires` | From the registry's RDAP server |
| `popularityScore` | 0 to 100, formula below |
| `sources` | Credit line with author, source link and licence link for each source that returned data |
| `checkedAt` | When the row was built |

### How the popularityScore is calculated

- Majestic part = (7 - log10(majesticRank)) / 7. Rank 1 gives 1.00, rank 1,000 gives 0.57, rank 1,000,000 gives 0.14.
- Chrome UX Report part = (7 - log10(cruxRankBucket)) / 4. Top 1,000 gives 1.00, top 10,000 gives 0.75, top 100,000 gives 0.50, top 1,000,000 gives 0.25.
- A domain that is not in a list gets 0 for that part.
- With both signals: score = round(100 x (0.6 x Majestic part + 0.4 x Chrome UX Report part)). With one signal: score = round(100 x that part).

The score is a popularity and link-reach signal built from open data. It is not Moz Domain Authority, Ahrefs Domain Rating or a Semrush Authority Score, and it will not match them.

### Data sources and licences

- **Majestic Million** by Majestic-12 Ltd, licensed under the Creative Commons Attribution 3.0 Unported licence. Rows are limited to the domains you asked for and values are passed through unchanged. The popularityScore is our own calculation, not a Majestic metric.
- **Chrome UX Report** by Google, licensed under the Creative Commons Attribution 4.0 International licence. Origins are grouped by domain and the best bucket is kept.
- **RDAP**: registration data from each domain's registry RDAP server. Contact fields are dropped.

Each row's `sources` field carries the full source and licence links.

### FAQ

**Is this legal to use?** The Majestic Million and the Chrome UX Report are published under Creative Commons Attribution licences that allow commercial reuse with credit. Each row carries that credit in `sources`. RDAP is the official registration data service for generic top-level domains. No personal data is collected. RDAP contact fields are dropped before anything is saved.

**Why is my domain missing from a list?** Both lists cover about one million sites. Smaller sites are often not in them, so `majesticRank` or `cruxRankBucket` is null and the score is low. That is an answer, not an error.

**How fresh is the data?** The Majestic Million is regenerated daily. The Chrome UX Report list is monthly; the month is in `sources`. RDAP is read live.

**Why is RDAP slow?** The Actor asks each registry at most 2 times per second by default, to stay polite. 10,000 .com domains take about 85 minutes with RDAP on, and one to two minutes without it.

**Which TLDs does RDAP cover?** Every TLD that has an RDAP server registered with IANA. Others get `rdapStatus: rdap_unsupported_tld`.

**Related Actors.** Pair this with a website technology detector or a bulk WHOIS or RDAP Actor from the Apify Store for a fuller picture of a domain list.

This Actor is not affiliated with, endorsed or sponsored by Majestic-12 Ltd, Google, Semrush, Ahrefs or Moz. Their names are used only to describe the data sources and the metrics people compare against.

# Actor input Schema

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

Enter the domains to check, one per line. Full URLs work too; the Actor keeps the registrable domain (www.example.co.uk becomes example.co.uk). Up to 10,000 domains per run.

## `signals` (type: `array`):

Choose which open sources to read. majestic: Majestic Million rank, referring subnets and referring IPs. crux: Chrome UX Report popularity bucket (top 1,000 to top 1,000,000). rdap: domain creation date, age, expiry and registrar from the registry's RDAP server.

## `rdapRequestsPerSecond` (type: `number`):

Set how fast the Actor asks each registry RDAP server. Lower values are gentler on registries; 10,000 .com domains take about 85 minutes at 2 per second.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "wikipedia.org",
    "github.com"
  ],
  "signals": [
    "majestic",
    "crux"
  ],
  "rdapRequestsPerSecond": 2
}
```

# Actor output Schema

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

domain, popularityScore, majesticRank, majesticRefSubnets, majesticRefIPs, cruxRankBucket, domainAgeYears, registrar, expires, status and the sources credit lines.

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

Every field, including cruxOrigin, domainCreated, rdapStatus, sources and checkedAt. Majestic Million data by Majestic-12 Ltd under CC BY 3.0; Chrome UX Report data by Google under CC BY 4.0.

## `stats` (type: `string`):

JSON with domains requested and checked, charges, requests, retries, list sizes and the Chrome UX Report month.

# 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",
        "github.com"
    ],
    "signals": [
        "majestic",
        "crux"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/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",
        "github.com",
    ],
    "signals": [
        "majestic",
        "crux",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("conserving_celerytop/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",
    "github.com"
  ],
  "signals": [
    "majestic",
    "crux"
  ]
}' |
apify call conserving_celerytop/domain-authority-checker --silent --output-dataset

```

## MCP server setup

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