# Moz Scraper \[$6+💰] Domain Authority, Spam Score & Keywords (`memo23/moz-scraper`) Actor

Get Moz Domain Authority at scale — no Moz Pro subscription. DA, PA, spam score, linking root domains, ranking keywords, top linking domains, top pages & 60-day link history. One report per domain, empty lookups never charged. Export JSON, CSV, or Excel.

- **URL**: https://apify.com/memo23/moz-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** SEO tools, AI, Agents
- **Features:** Limited permissions
- **Stats:** 359 total users, 62 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.00 / 1,000 results

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

## Moz Scraper — Domain Authority, Spam Score, Backlinks & Keywords (No Login)

Scrape **Moz's free domain-analysis SEO metrics** for any list of domains — **no Moz account, no Moz Pro subscription, no login**. Give it domains or URLs and get back **Domain Authority (DA)**, **Spam Score**, **linking root domains**, **ranking keywords**, **top linking domains**, **top pages**, and a **60-day link-acquisition history** — one clean structured record per domain. You only pay for domains that return data.

![How Moz Scraper Works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-moz.png)

### Why use this Moz Scraper?

- **No Moz account required.** Skip the sign-up, the seat limits, and the Moz Pro paywall — paste domains and pull metrics.
- **Bulk by design.** Feed one domain or thousands; each is de-duplicated and processed in parallel.
- **You never pay for empty lookups.** Domains that return no data are skipped and never billed.
- **Clean, export-ready output.** Structured JSON, CSV, or Excel — ready for dashboards, BI tools, and prospecting sheets.
- **Handles the hard part for you.** Anti-bot protection is handled internally — no captchas, no proxies to configure.

### What it does

For every domain you submit, this Actor pulls the public Moz domain-analysis report and returns:

- **Domain Authority (DA)** — Moz's 0–100 score predicting ranking strength.
- **Spam Score** — the percentage risk signal.
- **Linking Root Domains** — count of unique referring domains.
- **Ranking Keywords** — total keywords the domain ranks for.
- **Top Linking Domains** — the strongest referring domains, each with its own DA.
- **Top Pages** — the domain's strongest pages, each with a Page Authority (PA).
- **60-Day Link History** — discovered vs. lost linking domains over the last ~60 days.

### Supported inputs

| Input | Example | Notes |
|---|---|---|
| Bare domain | `apify.com` | Simplest form |
| Full URL | `https://www.stripe.com/pricing` | Scheme + path are stripped to the host |
| Subdomain | `blog.example.com` | Kept as its own target |
| Bulk list | `["a.com","b.com", …]` | De-duplicated; billed once per unique host |

### Use cases

- **Link-building & outreach** — bulk-qualify prospect domains by DA and Spam Score before you pitch.
- **SEO audits** — snapshot DA, linking root domains, and ranking-keyword counts across a portfolio or client list.
- **Lead scoring & enrichment** — append authority signals to a CRM or prospect matrix.
- **Competitive research** — compare authority and top-linking-domain profiles across competitors.
- **Content & PR planning** — spot the strongest pages and referring domains worth targeting.

### How it works

1. **You submit domains** — any mix of hosts, URLs, or a bulk list.
2. **The Actor fetches Moz's free domain-analysis page** for each (Cloudflare protection is handled automatically — no login, no captcha on your side).
3. **Metrics are parsed into one clean record per domain** and streamed to the dataset as they complete.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | array | — | Domains or URLs to analyze (required). |
| `fastMode` | boolean | `false` | Bulk DA-only mode — whole list in seconds. See below. |
| `includeTopLinkingDomains` | boolean | `true` | Include the top linking domains list (with per-domain DA). |
| `includeTopPages` | boolean | `true` | Include the top pages list (with per-page PA). |
| `includeLinkHistory` | boolean | `true` | Include the 60-day discovered/lost link history. |
| `maxItems` | integer | `10000` | Cap on domains processed (and billable results). |
| `maxConcurrency` | integer | `5` | Parallel domain lookups. |
| `requestTimeoutMs` | integer | `90000` | Per-request timeout before a retry. |
| `maxRequestRetries` | integer | `3` | Retries per domain before it's skipped (never billed). |
| `proxy` | object | off | Optional — usually unnecessary. |

### Plan limits

Accounts on Apify's **free plan** get:

- **25 domains per run** (paid plans: no cap)
- **A 3-row preview** of `topLinkingDomains` and `topPages` (paid plans: the full lists). Rows affected carry `previewLimited: true`.
- **Every score in full** — Domain Authority, Page Authority, Spam Score, linking root domains, ranking keywords, and both history arrays are complete on every plan.

Duplicate entries that resolve to the same host are collapsed before the cap is applied, so repeats never eat your allowance.

### Two modes

| | Default (full report) | `fastMode: true` |
|---|---|---|
| Speed | a few seconds per domain, run in parallel | whole list in **seconds** |
| Domain Authority | ✅ live | ✅ index snapshot |
| Spam Score | ✅ | ✅ |
| Linking root domains | ✅ site-scoped | ⚠️ subdomain-scoped (different, usually lower, figure) |
| Ranking keywords | ✅ | ❌ |
| Top linking domains / Top pages | ✅ | ❌ |
| 60-day discovered/lost history | ✅ | ❌ (returns a DA-over-time series instead) |
| `source` field on each row | `moz` | `bulk-index` |

**Use `fastMode` when** you're qualifying a big list and only need DA + spam score — e.g. filtering
thousands of link prospects before pulling full reports on the survivors.

**Accuracy note:** `fastMode` reads an index snapshot that can trail the live Moz report by a few
points (e.g. a domain showing DA 59 live may read 49 here), and its referring-domain count is
subdomain-scoped. Every fast-mode row is stamped `source: "bulk-index"` and
`dataFreshness: "lagging snapshot…"` so you never mix the two silently. For exact, current figures,
leave `fastMode` off.

### Output sample

```json
{
  "input": "apify.com",
  "domain": "apify.com",
  "domainAuthority": 60,
  "pageAuthority": 58,
  "spamScore": 3,
  "linkingRootDomains": 9900,
  "rankingKeywords": 30900,
  "topLinkingDomains": [
    { "domain": "youtube.com", "da": 100 },
    { "domain": "wordpress.org", "da": 98 }
  ],
  "topPages": [
    { "url": "apify.com/", "pa": 57 },
    { "url": "www.apify.com/", "pa": 52 }
  ],
  "linkHistory": [
    { "date": "05/12", "discovered": 15, "lost": -3 },
    { "date": "05/13", "discovered": 38, "lost": -5 }
  ],
  "domainAuthorityHistory": [38, 40, 43, 46, 48, 49],
  "checkedAt": "2026-07-13T00:00:00.000Z",
  "source": "moz"
}
```

### Key output fields

| Field | Description |
|---|---|
| `domainAuthority` | Moz Domain Authority, 0–100. |
| `spamScore` | Moz Spam Score (percentage risk signal). |
| `linkingRootDomains` | Count of unique referring domains. |
| `rankingKeywords` | Count of ranking keywords. |
| `topLinkingDomains[]` | Strongest referring domains, each with `da`. |
| `topPages[]` | Strongest pages, each with `pa`. |
| `linkHistory[]` | 60-day `discovered` / `lost` linking-domain trend. |
| `domainAuthorityHistory[]` | Domain Authority over time, oldest to newest (undated). Null for domains the index doesn't cover. |
| `checkedAt` | ISO timestamp of the lookup. |
| `previewLimited` | Present and `true` only on free-plan rows whose top lists were trimmed to the 3-row preview. |

### FAQ

**Do I need a Moz account or API key?** No. This Actor reads Moz's public free domain-analysis tool — no account, key, or subscription.

**Is `pageAuthority` always filled?** Top-level `pageAuthority` is the Page Authority of the domain's own homepage, taken from the Top Pages table. Moz sorts that table by PA descending rather than homepage-first, so when the homepage isn't among the listed top pages the field stays `null` instead of reporting some other page's score. Every entry in `topPages[]` always carries its own `pa`.

**What happens for a domain Moz has no data on?** You get a low/empty result, and if Moz returns nothing usable the domain is skipped and **not billed**.

**How fast is it?** Roughly a few seconds per domain, run in parallel up to your `maxConcurrency`.

**Can I get competitors and full keyword lists?** Moz gates those behind a login on its own site, so this Actor returns the rich free-view field set (DA, Spam, linking domains, ranking-keyword counts, top linking domains, top pages, link history).

### Support

Found a bug or need a field added? Open an issue on the Actor's **Issues** tab and we'll take a look.

### Explore more scrapers

- **[Keyword Metrics](https://apify.com/memo23/keyword-metrics)** — Google + Bing search volume, CPC, competition, top-of-page bids, keyword difficulty, search intent, and ~93 months of history. 1,000 keywords per run at one flat price, or expand 20 seeds into up to 20,000 keyword ideas across 111 countries and 46 languages.
- **[Ahrefs Scraper](https://apify.com/memo23/ahrefs-scraper)** — Domain Rating, backlinks, keyword ideas, and AI visibility — a second authority read to sanity-check DA.
- **[Semrush Scraper](https://apify.com/memo23/semrush-scraper)** — traffic, authority, backlinks, and top websites for the domains you just scored.
- **[SEO Intelligence Suite](https://apify.com/memo23/seo-intelligence-suite)** — DR, traffic, AI visibility, and Google presence in one call.

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/moz-scraper`).

**Purpose:** Pull Moz's free domain-analysis SEO metrics (Domain Authority, Spam Score, linking root domains, ranking keywords, top linking domains, top pages, 60-day link history) for a list of domains with no Moz account.

**Minimal input:**

```json
{
  "domains": ["apify.com"],
  "maxItems": 10
}
```

**Output:** one row per unique host — input, domain, domainAuthority, pageAuthority, spamScore, linkingRootDomains, rankingKeywords, topLinkingDomains\[] {domain, da}, topPages\[] {url, pa}, linkHistory\[] {date, discovered, lost}, checkedAt, source.

**Behaviors an agent should know:**

- `maxItems` (default 10000) caps both domains processed and billable results — set it to bound cost.
- `domains` accepts bare hosts, full URLs, or subdomains; each is normalized to its host and deduplicated, so a repeated host is looked up and billed once.
- `includeTopLinkingDomains`, `includeTopPages`, `includeLinkHistory` (all default true) add the larger nested lists; turn them off for a lean core-metrics row.
- Domains Moz has no usable data for are skipped and never billed; Cloudflare handling is internal, so `proxy` is usually unnecessary.
- Login-gated Moz data (competitor lists, full keyword lists) is out of scope — only the free-view field set is returned; top-level `pageAuthority` is often null while each `topPages[]` entry carries its own `pa`.
- Pay-per-event billing — see the Pricing tab on the actor page.

### ⚠️ Disclaimer

This Actor collects **publicly available** information from Moz's free domain-analysis tool. It does not log in, bypass authentication, or access any private, paid, or account-gated Moz data. "Moz", "Domain Authority", "Page Authority", and "Spam Score" are trademarks of Moz, Inc.; this Actor is independent and not affiliated with, endorsed by, or sponsored by Moz. Metrics are Moz's estimates. Use the data in compliance with Moz's terms and all applicable laws; you are responsible for how you use it.

### SEO Keywords

Moz scraper, Moz API alternative, Domain Authority checker, bulk DA checker, Moz DA PA scraper, spam score checker, linking root domains, ranking keywords scraper, Moz domain analysis, free SEO metrics, backlink authority checker, bulk domain authority, Moz Link Explorer scraper, SEO data extraction, domain authority API, page authority checker.

# Actor input Schema

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

One or more domains or URLs to analyze on Moz. Any format works — 'apify.com', 'https://www.apify.com/blog', or 'sub.example.com' — each is normalized to its host. Duplicates that resolve to the same host are looked up (and billed) once. Note: accounts on Apify's FREE plan are limited to 25 domains per run; paid plans have no such cap. Free-plan runs also return the top-linking-domains and top-pages lists as a 3-row preview — all scores (DA, PA, spam score, linking root domains, ranking keywords) are complete on every plan.

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

Bulk-lookup mode: returns Domain Authority, spam score, a referring-domain count and a DA history series for your whole list in seconds. Trade-offs: the figures come from an index snapshot that can trail the live Moz report by a few points, the referring-domain count is subdomain-scoped, and top pages / top linking domains / 60-day link history are NOT included. Every row is marked `source: "bulk-index"`. If the index has no figures for your list, the run falls back to the full live lookup on its own rather than returning blanks — so it takes as long as a normal run, but the numbers are real. Leave off for full, live reports.

## `includeTopLinkingDomains` (type: `boolean`):

Include the list of top linking domains, each with its own Domain Authority. Accounts on Apify's FREE plan receive a 3-row preview of this list; paid plans receive the full list.

## `includeTopPages` (type: `boolean`):

Include the top pages of the domain, each with its Page Authority. Accounts on Apify's FREE plan receive a 3-row preview of this list; paid plans receive the full list.

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

Include the 60-day discovered vs lost linking-domains history, plus a Domain-Authority-over-time series (oldest to newest, undated). The DA series comes from a bulk index that does not cover every domain — obscure hosts return null for it.

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

Maximum number of domains to process (also caps billable results). Accounts on Apify's FREE plan are capped at 25 domains per run regardless of this value.

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

How many domain lookups to run in parallel.

## `requestTimeoutMs` (type: `integer`):

Per-request timeout in milliseconds before a lookup is retried.

## `maxRequestRetries` (type: `integer`):

How many times to retry a single domain on a network or unlocker failure before skipping it (skipped domains are never billed).

## `proxy` (type: `object`):

Optional. Usually unnecessary — egress and the Cloudflare challenge are handled internally.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "stripe.com"
  ],
  "fastMode": false,
  "includeTopLinkingDomains": true,
  "includeTopPages": true,
  "includeLinkHistory": true,
  "maxItems": 10000,
  "maxConcurrency": 5,
  "requestTimeoutMs": 90000,
  "maxRequestRetries": 3,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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",
        "stripe.com"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/moz-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",
        "stripe.com",
    ],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/moz-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",
    "stripe.com"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call memo23/moz-scraper --silent --output-dataset

```

## MCP server setup

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