# Moz Scraper \[Only $5💰/1K] | Domain Authority | Backlinks (`ahmed_jasarevic/moz-scraper`) Actor

Check Moz Domain Authority, Spam Score, backlinks and ranking keywords for any list of domains - no Moz account needed. Bulk DA checks for link building and SEO competitor analysis.

- **URL**: https://apify.com/ahmed\_jasarevic/moz-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.97 / 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 Checker, Spam Score & Backlink Data

Scrape **Moz's free domain-analysis SEO metrics** for any list of domains — **no Moz account, no Moz Pro subscription, no login, and no browser**. Feed 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, ready for JSON, CSV or Excel export.

### Use Cases: SEO Competitor Analysis, Link Building Prospecting & Outreach Lists

- **SEO competitor analysis** — compare Domain Authority, backlinks and ranking keywords across your competitive set in one table.
- **Link building prospecting** — find high-DA linking domains and top pages to target for guest posts and digital PR.
- **Bulk DA qualification** — check 1,000+ domains at once and filter for `DA >= 40` to build outreach lists.
- **Spam score screening** — flag low-quality domains before you buy links, rent mentions or partner with sites.
- **Domain authority tracking** — schedule weekly runs to watch DA, spam score and link-history trends for your own domains.

### Bulk Domain Authority Check — No Moz Account, No Browser

This is the **budget/Cheerio edition** of the classic Moz scrapers: it reads the exact same public Moz reports but with **plain HTTP + Cheerio instead of a headless browser**, so it runs on tiny memory (256 MB) and a fraction of the compute of browser-based alternatives. Bulk DA qualification at 1,000s of domains for pennies.

- **Cheap by design.** Pure HTTP + `CheerioCrawler` — no browser instances, low memory, low compute.
- **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 usable data are skipped and never charged.
- **Clean, export-ready output.** Structured JSON, CSV, or Excel — ready for dashboards, BI, and prospecting sheets.
- **Handles the hard part.** Cloudflare challenges and Moz's per-IP free limit are handled via configurable proxy rotation — enable residential proxies for big lists (recommended default).

#### What it returns

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

- **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.

### Moz API Alternative — How to Get Moz Data Without an API Key

Moz's official API requires a Moz Pro subscription and an API key. This actor reads Moz's **free public domain-analysis tool** instead — no account, no key, no subscription — which makes it a practical Moz API alternative for bulk DA and backlink checks without the Moz Pro paywall.

#### Fast mode (bulk DA + spam-score qualification)

Turn on **`fastMode`** for pure bulk **DA + spam-score qualification**: it returns just the four headline metrics (Domain Authority, spam score, linking root domains, ranking keywords) with a tiny regex-based parse — no full DOM build, no tables, no link-history/chart extraction. Every row is marked `fast: true`. The values are still read from the **live Moz report**. Leave `fastMode` off for the complete report.

### How to Use Moz Scraper

1. Open the Actor in Apify Console (or call it via the API).
2. In the **Input** tab, paste your domains/URLs into `domains`.
3. Enable **Proxy configuration** (`RESIDENTIAL` group is the recommended default) — Moz only allows ~3 free reports per IP per day, so a proxy pool makes bulk runs possible.
4. Click **Start** and download the dataset as JSON, CSV, HTML, or Excel.

##### Example call (API / MCP)

```json
{
  "domains": ["apify.com", "stripe.com"],
  "fastMode": false,
  "includeTopPages": true,
  "includeTopLinkingDomains": true,
  "includeLinkHistory": true,
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

For a fast DA-only qualification run:

```json
{
  "domains": ["apify.com", "stripe.com"],
  "fastMode": true
}
```

#### 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; looked up once per unique host |

### Input Configuration

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `domains` | array | **yes** | — | Domains or URLs to analyze. |
| `fastMode` | boolean | no | `false` | Fast bulk mode — headline metrics only (DA, spam, linking root domains, ranking keywords); rows marked `fast: true`. |
| `includeTopLinkingDomains` | boolean | no | `true` | Include the top linking domains list (with per-domain DA). |
| `includeTopPages` | boolean | no | `true` | Include the top pages list (with per-page PA). |
| `includeLinkHistory` | boolean | no | `true` | Include the 60-day discovered/lost link history. |
| `maxItems` | integer | no | `1000` | Cap on domains processed (and billable results). |
| `maxConcurrency` | integer | no | `3` | Parallel domain lookups (keep low 1–5 for residential rotation). |
| `requestTimeoutMs` | integer | no | `60000` | Per-request timeout before a retry. |
| `maxRequestRetries` | integer | no | `3` | Retries per domain on challenge/limit before skipping (never billed). |
| `proxyConfiguration` | object | no | residential | Proxy pool — **enable for any list bigger than a few domains**. |

### Output: Domain Authority, Backlinks & Link History

```json
{
  "input": "apify.com",
  "domain": "apify.com",
  "domainAuthority": 60,
  "linkingRootDomains": 11500,
  "rankingKeywords": 32700,
  "spamScore": 3,
  "topLinkingDomains": [
    { "domain": "youtube.com", "da": 100 },
    { "domain": "wordpress.org", "da": 98 }
  ],
  "topPages": [
    { "url": "apify.com/", "pa": 58 },
    { "url": "www.apify.com/", "pa": 52 }
  ],
  "linkHistory": [
    { "date": "07/11", "discovered": 31, "lost": -7 },
    { "date": "07/12", "discovered": 22, "lost": -10 }
  ],
  "checkedAt": "2026-09-12T21:16:27.188Z",
  "source": "moz"
}
```

#### Data table

| Field | Description |
|---|---|
| `input` | The supplied domain, normalized to its host. |
| `domain` | The host as shown on the Moz report. |
| `domainAuthority` | Moz Domain Authority, 0–100. |
| `linkingRootDomains` | Count of unique linking root domains. |
| `rankingKeywords` | Count of ranking keywords. |
| `spamScore` | Moz Spam Score (percentage risk signal). |
| `topLinkingDomains[]` | Strongest referring domains, each with `da`. |
| `topPages[]` | Strongest pages, each with `pa`. |
| `linkHistory[]` | ~60-day `discovered` / `lost` linking-domain trend. |
| `checkedAt` | ISO timestamp of the lookup. |
| `source` | Data source marker (always `moz`). |
| `fast` | `true` when the row was produced in fast mode (headline metrics only). |

### Cost Estimation: How Much Does It Cost to Scrape Moz Domain Metrics?

Pure HTTP + Cheerio — no browser rendering, no per-page GPU/CPU overhead. Each report is a single lightweight GET (~50–100 KB), so memory stays at 256 MB and compute per 1,000 domains is tiny. On top of platform usage you only pay for what the Actor consumes:

- **~3 free Moz queries per IP per day** — Moz's own limit, not ours. With Apify **RESIDENTIAL** proxies the pool provides a fresh IP per session, so thousands of domains per run are achievable.
- **Direct egress (no proxy)** — free, but you'll hit Moz's IP limit after ~3 domains per run.
- Empty lookups are never charged: domains with no Moz data are skipped before billing.

To keep runs affordable, set `maxItems` to what you actually need and use residential proxies only for real bulk work.

### Tips & Advanced Options

- **Proxy is the unlock.** The default input enables `RESIDENTIAL` — keep it for anything beyond a handful of domains.
- **Low concurrency for residential** (1–5) rotates IPs cleanly; raise concurrency if you run on your own proxy pool.
- **Trim output** by disabling `includeTopPages`, `includeTopLinkingDomains`, or `includeLinkHistory` to keep rows lean.
- **Fast mode for bulk DA qualification.** For thousands of domains where all you need is DA + spam score, flip `fastMode` on — leaner rows, lighter parsing, same live data.
- **Cap cost** with `maxItems`.

### Related Actors

- [Moz Domain Authority Checker (seo-scraper)](https://apify.com/seo-scraper/moz-domain-authority-checker) — the largest Moz metrics actor in the cluster
- [Moz Scraper (maximedupre)](https://apify.com/maximedupre/moz-scraper) — browser-based Moz metrics alternative
- [Ahrefs Scraper (scrapesage)](https://apify.com/scrapesage/ahrefs-scraper) — Ahrefs Domain Rating, traffic value & backlinks (DR-side comparison)

### 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. That's what makes it a workable Moz API alternative.

**Why do I need proxies?** Moz allows ~3 free reports per IP per day and Cloudflare fronts the page ready to hand out `403`s to datacenter IPs. The Actor already sends a fully consistent browser fingerprint (rotating Chrome `User-Agent` + matching `Sec-CH-UA`/`Sec-Fetch-*` headers + `Referer`) and rotates sessions, which clears many blocks — but for reliable bulk runs, fresh residential IPs per request are the safe path.

**What is a good Domain Authority score?** DA is a 0–100 relative ranking score — 40+ is generally considered strong, 60+ very strong. Use `fastMode` to bulk-qualify prospects against your own threshold (e.g. `DA >= 40`).

**How to check Domain Authority for free at scale?** Run this actor with `fastMode: true` and a residential proxy pool — it returns live DA, spam score, linking root domains and ranking keywords for thousands of domains at pennies per thousand.

**Moz vs Ahrefs Domain Rating — which should I use?** Both are competitive link-based metrics; DA is widely quoted in outreach and guest-posting circles, while Ahrefs DR is common in SEO tooling circles. Pair the [Ahrefs Scraper](https://apify.com/scrapesage/ahrefs-scraper) with this actor to cover both metrics.

**What happens for a domain Moz has no data on?** The domain is skipped and never billed.

**Is this legal?** This Actor collects **publicly available** information from Moz's free domain-analysis tool. It does not log in, bypass authentication, or access 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.

**Compatibility note:** Moz's free tool is a live product and may change its layout over time. If reports stop parsing, open an issue on the Actor's **Issues** tab and it'll be fixed quickly.

**Need help?** Open an issue on the Actor's Issues tab, or reach out for a custom scraper built to your needs.

### SEO Keywords

domain authority checker, bulk domain authority check, moz da checker, moz api alternative, moz api free alternative, backlink analysis tool, spam score checker, linking root domains check, seo competitor analysis, link building prospecting, domain authority tracking, page authority checker, seo audit tool, outreach list generator, da 40+ domains list, moz domain metrics bulk, competitor backlink analysis, link profile analysis, seo lead generation, domain rating alternative, check da, free da checker

### For AI Agents & LLM Apps

One dataset record per domain: Moz Domain Authority, Spam Score, linking root domains, ranking keywords, top linking domains (with DA), top pages (with PA) and 60-day link history — wired for the Apify MCP server and the Apify API.

Minimal working input (fast DA check):

```json
{
  "domains": ["apify.com", "stripe.com"],
  "fastMode": true
}
```

Variant — full report:

```json
{
  "domains": ["apify.com"],
  "fastMode": false,
  "includeTopLinkingDomains": true,
  "includeTopPages": true,
  "includeLinkHistory": true
}
```

Output field list: `input, domain, domainAuthority, linkingRootDomains, rankingKeywords, spamScore, topLinkingDomains[{domain,da}], topPages[{url,pa}], linkHistory[{date,discovered,lost}], checkedAt, source, fast`.

Behaviors an agent should know:

- `domains` is the only required field; each unique host is looked up once (de-duplicated).
- In `fastMode`, `topLinkingDomains`, `topPages` and `linkHistory` are always omitted and rows are flagged `fast: true`.
- Domains with no Moz data are skipped and **not billed** — do not treat missing rows as errors.
- Without a proxy pool you'll typically get ~3 free reports per IP per day before Moz limits; enable `RESIDENTIAL` proxies for anything beyond a few domains.
- `maxItems` caps billable results — set it to your actual list size.
- Metrics are Moz's estimates, not guarantees.

Billing model: pay-per-event (compute + proxy traffic actually consumed); pricing from **$5 per 1,000 results**.

### Legal & Compliance Disclaimer

This actor is **independent** and is not affiliated with, endorsed by, or sponsored by Moz, Inc. It collects **publicly available** information from Moz's free domain-analysis tool; it does not log in, bypass authentication, or access account-gated Moz data. "Moz", "Domain Authority", "Page Authority", and "Spam Score" are trademarks of Moz, Inc., and the metrics returned are Moz's estimates. Users are responsible for complying with Moz's terms and all applicable laws in how they collect and use the data.

# Actor input Schema

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

One or more domains or URLs to analyze. Anything works — 'apify.com', 'https://www.apify.com/blog', 'blog.example.com' — each is normalized to its host and deduplicated (each unique host is looked up once).

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

Bulk-lookup mode: returns just the headline metrics — Domain Authority, spam score, linking root domains and ranking keywords — for the whole list, with a tiny parse footprint. Top pages, top linking domains and the 60-day link history are NOT included, and every row is marked `fast: true`. Leave off for the full, live Moz report.

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

Include the list of top linking domains with each domain's Domain Authority.

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

Include the list of top pages with each page's Page Authority.

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

Include the 60-day discovered vs. lost linking-domains history.

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

Maximum number of domains to process (caps requests and cost).

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

How many domain lookups to run in parallel. Stay low (1–5) on residential proxies to avoid fast IP rotation; raise it for datacenter traffic.

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

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

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

How many times to retry a domain on a Cloudflare challenge or the free-metrics daily-limit redirect before skipping it (skipped domains are never billed).

## `proxyConfiguration` (type: `object`):

Moz allows only ~3 free reports per IP per day. Use a proxy pool (e.g. Apify residential) so each domain gets a fresh IP quota — recommended for any list larger than a handful of domains.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "stripe.com"
  ],
  "fastMode": false,
  "includeTopLinkingDomains": true,
  "includeTopPages": true,
  "includeLinkHistory": true,
  "maxItems": 1000,
  "maxConcurrency": 3,
  "requestTimeoutMs": 60000,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Structured Moz metrics, one row per unique domain.

## `log` (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",
        "stripe.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call ahmed_jasarevic/moz-scraper --silent --output-dataset

```

## MCP server setup

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