# Moz Domain Authority Checker - Bulk DA, PA & Spam Score (`topapi/moz-domain-authority-scraper`) Actor

Check Moz Domain Authority in bulk: DA, home-page PA, Spam Score, linking root domains, ranking keywords, top pages, top linking domains and 60-day link history per domain. Filters and change tracking. $0.90 per 1,000 domains.

- **URL**: https://apify.com/topapi/moz-domain-authority-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** SEO tools, Developer tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.90 / 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

## Moz Domain Authority Checker - Bulk DA, PA & Spam Score

Check **Moz Domain Authority** for a whole list of domains in one run. Each domain returns its DA, home-page Page
Authority, Spam Score, linking root domains and ranking keywords, plus Moz's top pages, top linking domains and the
60-day history of linking domains gained and lost. No Moz account, no API key.

### What you get per domain

| Field | What it is |
|---|---|
| `domain` | The domain Moz reports on (`www.` is folded in; subdomains such as `blog.hubspot.com` are kept) |
| `domainAuthority` | Moz Domain Authority, 1-100 |
| `homePageAuthority` | Moz Page Authority of the home page, when Moz lists it among the domain's top pages |
| `spamScore` | Moz Spam Score in percent (`null` when Moz shows `--`) |
| `linkingRootDomains` | Linking root domains. Moz shows this rounded (`14.9k`), so it is 14900; the exact text is in `linkingRootDomainsText` |
| `rankingKeywords` | Keywords the domain ranks for (rounded the same way; text in `rankingKeywordsText`) |
| `qualityTier` | `high` (DA 50+ and Spam Score 10% or less), `low` (DA under 20 or Spam Score 30%+), else `medium` |
| `hasLinkData` | `false` when Moz knows no linking root domains for the domain (Moz then shows DA 1) |
| `topPages` | Moz's 7 strongest pages of the domain: `url`, `pageAuthority` |
| `topLinkingDomains` | Moz's 7 strongest linking domains: `domain`, `domainAuthority` |
| `topPage1Url`, `topPage1Authority`, `topLinkingDomain1`, `topLinkingDomain1Authority` | The first of each list as flat columns, for spreadsheets |
| `linkHistory` | About 60 days of `date`, `discovered`, `lost` linking domains, as Moz charts them |
| `linksDiscovered60d`, `linksLost60d`, `linksNet60d` | Totals of that history |
| `linkTrend` | `growing` or `shrinking` when one side leads by 10%+ over the last 30 days, else `stable` |
| `changeType`, `previous...`, `domainAuthorityChange`, `linkingRootDomainsChange` | Change tracking (with a monitor name) |
| `reportUrl` | Moz's own Domain Analysis page for the domain |
| `input`, `inputDomain`, `checkedAt` | Your entry, the cleaned domain, and when the row was read |

A real row (apify.com, read 2026-11-16, lists shortened):

```json
{
  "domain": "apify.com",
  "input": "https://www.apify.com/store",
  "url": "https://apify.com",
  "domainAuthority": 60,
  "homePageAuthority": 60,
  "spamScore": 3,
  "linkingRootDomains": 14900,
  "rankingKeywords": 34700,
  "qualityTier": "high",
  "hasLinkData": true,
  "linkingRootDomainsText": "14.9k",
  "rankingKeywordsText": "34.7k",
  "spamScoreText": "3%",
  "topPage1Url": "apify.com/",
  "topPage1Authority": 60,
  "topLinkingDomain1": "youtube.com",
  "topLinkingDomain1Authority": 100,
  "topPages": [{ "url": "apify.com/", "pageAuthority": 60 }, { "url": "apify.com/pricing", "pageAuthority": 54 }],
  "topLinkingDomains": [{ "domain": "youtube.com", "domainAuthority": 100 }, { "domain": "wordpress.org", "domainAuthority": 99 }],
  "linksDiscovered60d": 3924,
  "linksLost60d": 672,
  "linksNet60d": 3252,
  "linkTrend": "growing",
  "linkHistory": [{ "date": "2026-09-14", "discovered": 30, "lost": 4 }, { "date": "2026-09-15", "discovered": 7, "lost": 2 }],
  "reportUrl": "https://moz.com/domain-analysis/apify.com",
  "checkedAt": "2026-11-16T11:12:45.593Z",
  "inputDomain": "apify.com"
}
```

### How to use it

1. Paste your domains (or any links) into **Domains or website links**, one per line. `https://www.apify.com/store`,
   `www.apify.com` and `apify.com` are the same domain and are checked once.
2. Optional: **Maximum domains**, the two **filters**, **Headline numbers only** for small rows.
3. Run it. Rows arrive as each domain is read; the **Overview** tab shows the headline numbers.

Input example:

```json
{
  "domains": ["apify.com", "moz.com", "https://www.stripe.com/pricing"],
  "minDomainAuthority": 30,
  "maxSpamScore": 10
}
```

#### Input options

| Option | What it does |
|---|---|
| `domains` | Domains, subdomains or links. Also read from `urls`, `startUrls`, `targets`, `websites` (other Moz actors' names) |
| `maxItems` | Stop after this many domain rows |
| `includeBacklinks` | Top pages and top linking domains (default on, same price) |
| `includeLinkHistory` | 60-day link history, totals and trend (default on, same price) |
| `fastMode` | Headline numbers only (turns the two above off) |
| `minDomainAuthority` | Only return domains at or above this DA. Domains below it are not charged |
| `maxSpamScore` | Only return domains at or below this Spam Score. Domains above it, or with no Spam Score, are not charged |

Moz shows DA only on each domain's own page, so the filters are applied after reading. When the filters drop nearly
everything (more than 16 dropped domains for every domain returned, plus 10), the run stops early and says how many
domains were not checked: loosen the filters or split the list.
| `monitorName` | Change tracking: compare each run with the previous run of the same name |
| `skipCheckedWithinHours` | With a monitor: skip domains the monitor checked more recently than this (default 20 h; 0 re-checks all) |
| `resetMonitor` | Forget the monitor's memory |

An empty input checks a 3-domain sample (apify.com, moz.com, stripe.com).

#### Change tracking

Set `monitorName` (for example `my-clients`) and schedule the run weekly or monthly. Every row then carries
`changeType`: `NEW` (first time this monitor sees it), `DA_UP`, `DA_DOWN`, `SPAM_CHANGE` or `UNCHANGED`, with
`previousDomainAuthority`, `domainAuthorityChange`, `previousSpamScore`, `previousLinkingRootDomains`,
`linkingRootDomainsChange`, `previousRankingKeywords` and `previousCheckedAt`. A domain the same monitor checked in
the last `skipCheckedWithinHours` hours is skipped and not charged, so an accidental second run costs nothing.

### Pricing

**$0.0009 per domain row** ($0.90 per 1,000 domains). You pay only for rows delivered. Never charged: duplicates,
entries that are not domains, domains below your filters, domains a monitor skips, and domains Moz could not be
reached for (they are listed in the run's status message and in `RUN_SUMMARY`).

### Limits

- Moz shows linking root domains and ranking keywords rounded (`12.5m`); the numbers are converted from that.
- `homePageAuthority` is filled only when Moz lists the home page among the domain's top 7 pages.
- Speed: about 60-100 domains a minute (1,200 domains took 11-20 minutes in our tests; 60 domains take 5-80 seconds).
  Moz serves each connection about 5 domains a minute, so very large lists need a longer run timeout (the default is
  1 hour, about 3,500-6,000 domains); domains not reached in time are listed in the status message and not charged.
- Domains Moz has no data for come back with DA 1, 0 linking root domains and `hasLinkData: false`.

### FAQ

**Do I need a Moz account or API key?** No.

**Does it check subdomains?** Yes: `blog.hubspot.com` is checked as itself. `www.` is folded into the domain.

**What if Moz cannot be reached for a domain?** It is retried on other connections. If it still fails, it is listed
in the run's status message as not reached, and not charged.

# Actor input Schema

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

One per line: a domain (apify.com), a subdomain (blog.hubspot.com) or any link (https://www.apify.com/store?x=1). Links, www, paths and duplicates are cleaned up for you. Lists of thousands are fine.

## `maxItems` (type: `integer`):

Stop after this many domain rows. Leave empty to check the whole list.

## `includeBacklinks` (type: `boolean`):

Add Moz's 7 strongest pages of each domain (with Page Authority) and its 7 strongest linking domains (with Domain Authority). Same price either way.

## `includeLinkHistory` (type: `boolean`):

Add the daily count of linking domains Moz discovered and lost over about 60 days, the 60-day totals and a growing / stable / shrinking trend. Same price either way.

## `fastMode` (type: `boolean`):

Only Domain Authority, home-page Page Authority, Spam Score, linking root domains and ranking keywords (turns the two options above off for smaller rows).

## `minDomainAuthority` (type: `integer`):

Only return domains at or above this Domain Authority. Domains below it are not charged. Leave empty to return every domain.

## `maxSpamScore` (type: `integer`):

Only return domains whose Spam Score is at or below this percentage. Domains above it (or with no Spam Score) are not charged. Leave empty to return every domain.

## `monitorName` (type: `string`):

Give your list a name (for example my-clients) to compare each run with the previous run of the same name. Every row then carries changeType (NEW, DA_UP, DA_DOWN, SPAM_CHANGE or UNCHANGED) and the previous Domain Authority, Spam Score, linking root domains and ranking keywords. Leave empty to turn tracking off.

## `skipCheckedWithinHours` (type: `integer`):

With a monitor name: domains the same monitor checked more recently than this are skipped (not read, not charged), so a repeated run costs nothing. Set 0 to re-check every domain on every run.

## `resetMonitor` (type: `boolean`):

Forget what this monitor remembered: every domain comes back as NEW.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "moz.com",
    "stripe.com"
  ],
  "includeBacklinks": true,
  "includeLinkHistory": true,
  "fastMode": false,
  "skipCheckedWithinHours": 20,
  "resetMonitor": false
}
```

# Actor output Schema

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

One row per domain: DA, PA, Spam Score, links, keywords.

## `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",
        "moz.com",
        "stripe.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/moz-domain-authority-scraper").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",
        "moz.com",
        "stripe.com",
    ] }

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

```

## MCP server setup

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

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/efVyPef0aHvFWPFpx/builds/PhCrabGtH0Z8QfP3y/openapi.json
