MOZ Scraper

MOZ Scraper — Domain Authority, Page Authority and Spam Score

MOZ Scraper reads Moz's free Domain Analysis page and returns it as structured JSON: Domain Authority, Page Authority, Spam Score, linking root domains, top pages by links, top linking domains, RDAP-derived domain age and a monthly Domain Authority history. One dataset row per domain, written live as each domain finishes, with every modeled figure kept behind an explicit estimated_ prefix so measured and derived numbers never blur together. Paste your domains and press Start.

⚠️ Read the "which numbers are real" section below before you use any backlink figure. Moz's free page publishes DA, PA, Spam Score and linking root domains — it does not publish backlink totals or a follow/nofollow split. Those come back as estimated_* fields calculated from DA and linking root domains, and they are models, not Moz measurements.

What is MOZ Scraper?

MOZ Scraper is an Apify Actor that fetches Moz's public moz.com/domain-analysis page for each domain you supply, parses the metric cards, tables and inline chart data, and shapes the result into one flat record per domain. It adds two lookups Moz does not provide: registration age from RDAP, and archived Domain Authority values recovered from the Wayback Machine.

No Moz account, login, cookie, API key or Moz Pro subscription is required, and no captcha-solver key or other third-party credential is needed either — the only credential involved is your Apify token. Requests are anonymous.

It is built for SEO consultants qualifying domains in bulk, agencies reporting authority movement across a client list, link builders screening prospects, and developers piping authority metrics into their own dashboards or agent tools.

What Moz domain data is publicly available to scrape?

Moz's free Domain Analysis page renders four headline metric cards and a handful of capped preview tables to any logged-out visitor. Everything per-keyword, and every complete list, sits behind a Moz Pro session or a paid Moz product.

Data Category	Free Domain Analysis page	Moz Pro / Moz Links API
Domain Authority (DA)	✅ Public	Full metric detail and history
Page Authority (PA) for top pages by links	✅ Public — capped preview table	PA for any URL on demand
Spam Score	✅ Public	Full spam-flag breakdown
Linking root domains total	✅ Public	Complete referring-domain list
Top Pages by Links, Top Linking Domains	✅ Public — capped preview tables	Complete lists and exports
Discovered / lost linking domains chart	✅ Public — read from inline chart data	Full series
Measured backlink totals and dofollow/nofollow split	❌ Not published on the free page	Paid Moz product
Ranking keywords, branded keywords, top questions, top competitors	❌ Gated — needs a Moz Pro session	Moz Pro
Historical Domain Authority series	❌ Not published on the free page	Moz Pro

MOZ Scraper only returns publicly visible data — what any logged-out visitor sees on Moz's free Domain Analysis page. Nothing behind a login wall or a paid plan.

⚠️ Which numbers are real Moz data, and which are estimates

This is the single most important thing to understand about the output, so it gets its own section rather than a footnote.

Measured, scraped live from Moz's free page: authority_score (Domain Authority), page_authority_score (Page Authority), spam_score, total_linking_root_domains, top_pages, top_linking_domains, and backlinks_discovered_lost_history.

Measured, but not from Moz: domain_age_years comes from an RDAP registry lookup at rdap.org, not from Moz.

Modeled — deterministic formulas of DA and linking root domains, which Moz's free page does not publish: estimated_total_backlinks, estimated_quality_backlinks, estimated_quality_backlinks_percentage, estimated_do_follow_backlinks_percentage, estimated_no_follow_backlinks_percentage, estimated_trust_score and estimated_offpage_seo_score_percentage. Every one of them carries the estimated_ prefix, every record where they appear also carries is_estimated: true, and estimation_note spells out the split in the row itself so a downstream consumer sees it without reading this page.

Partly modeled: in authority_score_history, each monthly point carries its own source — measured for the newest month (the DA scraped just now), wayback for a value recovered from a real archived snapshot of the Moz page, and estimated for a modeled walk used where no archive point exists. The estimated walk is deterministic per domain and clamped to a narrow band around the current DA, so treat estimated points as a placeholder shape rather than a trend you can report on. Filter on source == "wayback" or source == "measured" when you need only real values.

Gated, and usually empty: top_ranking_keywords, top_branded_keywords, top_questions, top_competitors and keywords_ranking_distribution require an authenticated Moz Pro session. On a logged-out run they typically come back as empty arrays, and the Actor logs a line telling you exactly that rather than leaving you guessing.

What data can I extract with MOZ Scraper?

Every record carries four identity fields, then the authority block and the history block depending on which toggles you leave on. Twenty-nine keys in total on a full result row — the default dataset view shows seventeen of them, so twelve keys, including all seven nested arrays, are in the JSON but not in that table view.

Field Name	Description
data_captured_at	ISO 8601 timestamp for when the record was built
type	domain_authority on a result row, error on a failure row
last_updated	Same capture moment, as an ISO 8601 timestamp
domain	Bare host, normalised — scheme, credentials, port and trailing slash stripped, lowercased
authority_score	Moz Domain Authority, read from the headline card
page_authority_score	Page Authority of the first row of Moz's Top Pages by Links table; null when that table is empty
spam_score	Moz Spam Score, read from the headline card
total_linking_root_domains	Moz Linking Root Domains count, read from the headline card
domain_age_years	Years since registration, from an RDAP lookup; fractional, null if the lookup fails
authority_score_last_month	Domain Authority at the second-newest point of the history series
authority_score_month_over_month_change	Current DA minus authority_score_last_month
authority_score_history	Monthly series: date, domain_authority, source (measured / wayback / estimated)
backlinks_discovered_lost_history	Daily series from Moz's inline chart: date, discovered, lost
top_pages	Array of page_url, page_authority
top_linking_domains	Array of domain, domain_authority
keywords_ranking_distribution	Array of domain, position, ranking_keywords — Moz Pro gated
top_ranking_keywords	Array of keyword, rank — Moz Pro gated
top_branded_keywords	Array of keyword, volume — Moz Pro gated
top_questions	Array of question, relevance — Moz Pro gated
top_competitors	Array of domain, visibility — Moz Pro gated
is_estimated	true on any record that contains estimated_* fields
estimation_note	In-record explanation of which fields are measured and which are modeled
estimated_trust_score	Modeled 0–10 trust figure derived from DA
estimated_offpage_seo_score_percentage	Modeled off-page score derived from DA and PA
estimated_total_backlinks	Modeled backlink total derived from linking root domains, rounded to two significant figures
estimated_quality_backlinks	Modeled quality-backlink count derived from that total and DA, rounded down to a thousand
estimated_quality_backlinks_percentage	Modeled quality share of the estimated total
estimated_do_follow_backlinks_percentage	Modeled dofollow share derived from DA
estimated_no_follow_backlinks_percentage	One minus the modeled dofollow share
error	Present only on type: "error" rows — the exception message for that domain

Four field names end in _percentage but carry a 0–1 ratio, not a 0–100 number: estimated_offpage_seo_score_percentage, estimated_quality_backlinks_percentage, estimated_do_follow_backlinks_percentage and estimated_no_follow_backlinks_percentage. The names are kept as they are so existing field mappings keep working, but multiply by 100 before displaying them as a percentage. estimated_trust_score is on a 0–10 scale, not 0–100.

Authority and spam fields

authority_score, page_authority_score, spam_score and total_linking_root_domains are the four real Moz numbers, taken straight from the headline metric cards and the top-pages table. These are what you sort and threshold on. domain_age_years sits alongside them as an independent trust signal from the domain registry rather than from Moz.

One caveat worth knowing: if Moz's Domain Authority card cannot be parsed, authority_score falls back to 0. A zero therefore means "no DA figure recovered" as often as it means a genuinely unranked domain — check top_pages and total_linking_root_domains on the same row before treating it as a real score.

History and trend fields

authority_score_history is a 33-point monthly series ending at the current month, with a per-point source tag. authority_score_last_month and authority_score_month_over_month_change are derived from the last two points of that series, so they inherit the source of the second-newest point — a month-over-month change built on an estimated point is a modeled figure, not a measured one. backlinks_discovered_lost_history is separate and fully real: it is read out of the discovered/lost chart Moz embeds in the page, with years resolved by walking backwards from the most recent label.

Nested table and array fields

top_pages and top_linking_domains are real capped previews of Moz's own tables. keywords_ranking_distribution, top_ranking_keywords, top_branded_keywords, top_questions and top_competitors are parsed whenever Moz renders them, and come back as empty arrays on a logged-out run because Moz gates them behind Moz Pro. Each of these arrays gets its own pre-configured dataset view in the Apify Console, so you can look at one section at a time instead of one very wide table.

🤖 Add-on: Need additional SEO data?

Ahrefs Scraper answers the same authority question from a second vendor, which is what you want when a single score is too thin a basis for a decision — Domain Rating, referring domains and traffic estimates next to Moz's DA. For the demand side rather than the authority side, Google Search Autocomplete Scraper surfaces real query variants and Quora Search Scraper surfaces the question intent that keyword tools tend to miss.

How does MOZ Scraper differ from the official Moz API?

Moz publishes a Links API, and it is a paid product — you need a Moz plan and API credentials to call it. If you have that, use it: it is the supported route, it returns Moz's own link index rather than what the free page happens to render, and it comes with commercial terms you can rely on. MOZ Scraper exists for the case where you do not.

Feature	Moz Links API	MOZ Scraper
Paid Moz plan and API credentials required	✅	❌ — runs on Apify with your Apify token
Data scope	Moz's own link index, as documented by Moz	Only what Moz's free Domain Analysis page renders
Domain Authority, Page Authority, Spam Score	✅ Documented metrics	✅ Scraped from the free page
Measured backlink totals and follow split	✅	❌ — modeled estimated_* fields only
Commercial terms and support	Contractual, from Moz	Unofficial, no guarantees
Setup	Moz account, plan, API credentials	Paste domains, press Start

Check Moz's current published API documentation for plan requirements, endpoint coverage and quotas before choosing between the two — those terms change and are deliberately not reproduced here.

Use the Moz Links API for production workloads, contractual guarantees and full-index depth. Use MOZ Scraper for ad-hoc research, prospect screening and pulling free-page authority metrics across many domains without a subscription.

How to use MOZ Scraper

MOZ Scraper runs on Apify. Start it from the Apify Console or call it through the Apify API.

1. Open MOZ Scraper on Apify and click Try for free
2. Add one or more domains or URLs to URL(s) or Domain(s) (urls) — this is the only required input. Bare hosts like zapier.com and full URLs like https://moz.com/products both work; the Actor normalises them to a bare host. A run with urls empty logs "No URLs/domains provided — nothing to do", exits without pushing a single row, and charges nothing
3. Leave Include Domain Overview (include_authority) on for the authority block, and Include Domain Authority History (include_history) on for the monthly series. Both default to on. Turning one off omits its keys from the record entirely rather than returning them as null
4. Leave Max Concurrency (maxConcurrency) at 1 unless you have reliable proxies — Moz's free page returns HTTP 403 under parallel load, so raising it mostly makes the Actor block itself
5. Click Start, then export the dataset as JSON, CSV or Excel, or read it through the Apify API

Rows are pushed as each domain completes, so the dataset fills while the run is still going and a crash part-way through never loses what has already been collected.

How to scale to bulk domain analysis

urls is a list, so bulk is the normal mode: add entries one by one, or paste a whole list at once with the Bulk edit button in the Console. The Actor is tolerant about what it accepts — a plain list of strings, a single bare string, and objects shaped like {"url": "..."} or {"domain": "..."} all work, so a list produced by another tool can usually be fed in unchanged. Blank entries are dropped.

The schema sets no ceiling on how many domains you can queue. What paces a large run is maxConcurrency, capped at 10 and defaulting to 1, plus include_history, which adds an archive-index lookup and up to eight archived snapshot fetches per domain.

What can you do with Moz domain data?

• 🔍 An SEO consultant qualifying inbound leads pastes a prospect list into urls and sorts the dataset by authority_score and spam_score to decide which domains are worth a proposal before spending a minute on manual review.
• 🔗 A link builder screening guest-post targets filters on authority_score above a threshold and spam_score below one, then works top_linking_domains on the surviving rows to find who already links to sites like theirs.
• 📈 An agency analyst reporting monthly progress reads authority_score_history filtered to source values of wayback and measured, so the client chart only ever contains points that were actually observed.
• 🧾 A domain buyer doing due diligence pairs domain_age_years from the registry with total_linking_root_domains and spam_score to separate an aged domain with a real link profile from an expired one with a rebuilt shell.
• 📄 A content strategist auditing internal linking reads top_pages to see which URLs Moz already treats as the strongest on the site, then points new internal links at the pages that are underweighted.
• 🤖 An AI engineer building an SEO assistant indexes domain, authority_score, total_linking_root_domains and top_linking_domains into a vector store so an agent can answer "is this domain worth a link, and who links to it already" from live data instead of a stale spreadsheet.

Every one of these is callable from an agent framework over the Apify API, since the Actor is a standard HTTP-triggered run.

How does MOZ Scraper handle rate limits and blocking?

Moz's free Domain Analysis page enforces a per-IP usage limit, and when you cross it the page still returns HTTP 200 — just with a limit notice instead of results. The Actor treats that as a block: a response only counts as good if it is a 200 and contains Moz's own results marker. A 200 with no results is retried, not parsed into a hollow row.

Blocking is handled with an escalation ladder that starts at the cheapest rung. Every run begins on a direct connection with no proxy at all. Only when Moz blocks a request does the Actor climb: direct, then an Apify datacenter proxy, then an Apify residential proxy — which is sticky, so once a run reaches residential every remaining request stays there. Each switch is logged with a warning line. Direct and datacenter get two attempts each; residential gets three. Attempts rotate across four browser TLS impersonation profiles and back off a few seconds between tries. There is no captcha solving anywhere in this Actor, because Moz's free page does not put a challenge in front of these requests.

If a domain still cannot be fetched after the ladder is exhausted, the run does not stop. That domain gets an error row instead — see the failure-mode question in the FAQ below.

⬇️ Input

Five parameters, all read straight from the input schema. Only urls is required.

Parameter	Required	Type	Description	Example Value
urls	Yes	array	One or more domains or URLs to analyze on Moz. Add them one by one or paste a bulk list with Bulk edit. Bare hosts and full URLs both work.	["zapier.com", "https://moz.com"]
include_authority	No	boolean	Collects the full domain overview: Domain Authority, Page Authority, Spam Score, backlink figures, top pages, linking domains, ranking and branded keywords, top questions and competitors. Default true.	true
include_history	No	boolean	Builds the monthly Domain Authority history timeline, each point tagged with a source of measured, wayback or estimated. The schema notes it adds roughly 15–45 seconds per domain. Default true.	true
maxConcurrency	No	integer	How many domains to analyze in parallel. Minimum 1, maximum 10, default 1. Moz's free page returns HTTP 403 under concurrency, so the default is serial; raise it only with reliable proxies.	1
proxyConfiguration	No	object	Proxy strategy. Shapes the datacenter rung of the fallback ladder. Default {"useApifyProxy": true}.	{"useApifyProxy": true}

Two things about these are easy to get wrong.

proxyConfiguration does not control the whole ladder. The first rung is always a direct connection with no proxy regardless of what you set here, and the residential rung always uses Apify's residential group. Your setting shapes the middle rung. Selecting Residential in this field therefore does not make the first request residential — the Actor gets there by escalating, not by configuration.

maxConcurrency is clamped in code to the same 1–10 range the schema declares, so an out-of-range value is silently pulled back into range rather than rejected.

Example input

{
  "urls": ["zapier.com", "make.com", "https://n8n.io"],
  "include_authority": true,
  "include_history": true,
  "maxConcurrency": 1,
  "proxyConfiguration": { "useApifyProxy": true }
}

⬆️ Output

One dataset row per domain, typed and normalized, with the same key names on every run. Keys are omitted rather than nulled when you switch a block off, so a record from a run with include_history disabled simply has no history keys — read them with a .get() rather than assuming presence. Rows are written live as each domain finishes. Export as JSON, CSV or Excel, or read the dataset through the Apify API. Ten pre-configured dataset views split the record into Overview, Authority History, Backlinks Discovered/Lost, Keyword Ranking Distribution, Top Pages, Top Linking Domains, Top Ranking Keywords, Branded Keywords, Top Questions and Top Competitors.

Charging is per saved result row: one row_result event per type: "domain_authority" record. Error rows are pushed uncharged — a domain that failed still lands in your dataset as a diagnostic, but no event is charged for it. Filter clean records with rec["type"] == "domain_authority", or exclude failures with rec["type"] != "error".

Example output

A full result row with both toggles on. The five Moz Pro gated arrays are shown empty, which is what a logged-out run actually returns; the long series are truncated here for readability.

{
  "data_captured_at": "2026-07-25T09:14:02.481230",
  "type": "domain_authority",
  "last_updated": "2026-07-25T09:14:02.481199",
  "domain": "zapier.com",
  "domain_age_years": 14.873972602739726,
  "authority_score": 91,
  "page_authority_score": 74,
  "spam_score": 1,
  "estimated_trust_score": 9,
  "estimated_offpage_seo_score_percentage": 0.74,
  "authority_score_last_month": 90,
  "authority_score_month_over_month_change": 1,
  "authority_score_history": [
    { "date": "2023-11-01T00:00:00", "domain_authority": 89, "source": "wayback" },
    { "date": "2023-12-01T00:00:00", "domain_authority": 89, "source": "estimated" },
    { "date": "2026-06-01T00:00:00", "domain_authority": 90, "source": "estimated" },
    { "date": "2026-07-01T00:00:00", "domain_authority": 91, "source": "measured" }
  ],
  "total_linking_root_domains": 118000,
  "estimated_total_backlinks": 2100000,
  "estimated_quality_backlinks": 410000,
  "estimated_quality_backlinks_percentage": 0.2,
  "estimated_do_follow_backlinks_percentage": 0.85,
  "estimated_no_follow_backlinks_percentage": 0.15,
  "is_estimated": true,
  "estimation_note": "Real MOZ-measured fields: authority_score (DA), page_authority_score (PA), spam_score, total_linking_root_domains, top_pages, top_linking_domains; domain_age_years is from RDAP. All estimated_* fields (total/quality backlinks, do/no-follow split, trust & off-page scores) are deterministic MODELS derived from DA and linking-root-domains — MOZ's free page does not publish them.",
  "backlinks_discovered_lost_history": [
    { "date": "2026-07-23T00:00:00", "discovered": 412, "lost": -118 },
    { "date": "2026-07-24T00:00:00", "discovered": 388, "lost": -104 },
    { "date": "2026-07-25T00:00:00", "discovered": 401, "lost": -96 }
  ],
  "keywords_ranking_distribution": [],
  "top_pages": [
    { "page_url": "zapier.com/", "page_authority": 74 },
    { "page_url": "zapier.com/apps", "page_authority": 66 },
    { "page_url": "zapier.com/blog", "page_authority": 63 }
  ],
  "top_linking_domains": [
    { "domain": "wordpress.org", "domain_authority": 99 },
    { "domain": "github.com", "domain_authority": 96 },
    { "domain": "shopify.com", "domain_authority": 95 }
  ],
  "top_ranking_keywords": [],
  "top_branded_keywords": [],
  "top_questions": [],
  "top_competitors": []
}

An uncharged error row for a domain that could not be fetched:

{
  "data_captured_at": "2026-07-25T09:15:40.117204",
  "type": "error",
  "domain": "example-that-failed.com",
  "error": "MOZ returned no results after exhausting the proxy ladder (last error: rate-limited / no results). The target may be temporarily unavailable or the domain is invalid."
}

How does it work?

For each domain you supply, MOZ Scraper normalises it to a bare host and requests moz.com/domain-analysis for it with browser-accurate TLS impersonation rather than a default HTTP client signature. The first attempt goes out on a direct connection with no proxy; only if Moz blocks it does the Actor escalate to a datacenter proxy and then to a sticky residential one. A response counts as good only when it is a 200 that actually contains results, so Moz's per-IP limit page is caught rather than parsed.

The page is then read three ways: the headline metric cards give DA, PA, Spam Score and linking root domains; the preview tables give top pages, linking domains and — when Moz renders them — the keyword, question and competitor rows; and the inline chart data gives the discovered/lost link series and the ranking distribution. Two extra lookups run alongside: RDAP for registration age, and the Wayback Machine's snapshot index for archived Domain Authority values, capped at eight snapshots per domain and fetched concurrently.

Only publicly visible free-page data is collected. No Moz account, cookie or session is used, and the output key names stay the same whatever Moz does to its layout.

Integrations

MOZ Scraper is an Apify Actor, so it works with anything that can call the Apify API or consume a dataset.

Calling MOZ Scraper from Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<YOUR_USERNAME>/moz-scraper").call(run_input={
    "urls": ["zapier.com", "make.com", "n8n.io"],
    "include_authority": True,
    "include_history": True,
    "maxConcurrency": 1,
})

for rec in client.dataset(run["defaultDatasetId"]).iterate_items():
    if rec["type"] == "domain_authority":
        print(rec["domain"], "DA", rec["authority_score"],
              "PA", rec.get("page_authority_score"),
              "spam", rec.get("spam_score"),
              "linking domains", rec.get("total_linking_root_domains"))

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request. Branch on type so error rows never reach your reporting code.

No-code tools (n8n, Make, Zapier)

In n8n, use the Apify node — or an HTTP Request node pointed at the Apify run endpoint with your token — and pass the same JSON input shown above; an IF node on type keeps error rows out of the branch that writes to your sheet. In Make, the Apify module supports run-and-wait, so a monthly authority sweep can feed a Google Sheets or Airtable step directly. Both platforms handle scheduling, so a recurring DA snapshot across a client list needs no code.

Is it legal to scrape Moz domain metrics?

Scraping publicly accessible tool output is broadly treated as permissible where no authentication is bypassed, and MOZ Scraper reads only Moz's free Domain Analysis page — no account, no cookie, no Moz Pro session.

The output is aggregate SEO metrics about websites: authority scores, spam scores, link counts, page-level authority. These are business and technical records about domains, not personal data, so GDPR and equivalent personal-data regimes do not attach to this output the way they would to a profile scraper. What applies instead is contractual and database-related: Moz's terms of service, and database or unfair-competition rules covering systematic reuse of a compiled dataset.

One factor worth raising with counsel specifically: Moz's free page enforces a per-IP usage limit, and this Actor escalates through datacenter and residential proxies when it hits that limit. That is a deliberate access control rather than an incidental one, which changes the analysis.

Consult legal counsel before reselling extracted Moz metrics as a standalone product or republishing them as a competing dataset.

❓ Frequently asked questions

What Moz fields does MOZ Scraper return?

The five most used are authority_score (Domain Authority), page_authority_score (Page Authority), spam_score, total_linking_root_domains and top_linking_domains. A full result row carries 29 keys including seven nested arrays. See the data fields table above for all of them.

Does MOZ Scraper require a Moz account, login or API key?

No. No Moz account, no login, no cookie, no Moz Pro subscription and no Moz API key. It also needs no captcha-solver key or any other third-party credential — the only credential in play is your Apify token. Requests go out anonymously against the same free page any visitor can open.

Which fields are real Moz measurements and which are modeled estimates?

Real and scraped live: authority_score, page_authority_score, spam_score, total_linking_root_domains, top_pages, top_linking_domains and backlinks_discovered_lost_history. Real but from the domain registry rather than Moz: domain_age_years. Everything prefixed estimated_ is a deterministic formula of DA and linking root domains — Moz's free page does not publish backlink totals or a follow split, so those numbers are models. Every record containing them also carries is_estimated: true and an estimation_note that restates the split inline.

Separately, top_ranking_keywords, top_branded_keywords, top_questions, top_competitors and keywords_ranking_distribution are gated behind Moz Pro. On a logged-out run they come back as empty arrays, and the Actor logs a line saying so. That is Moz's gate, not a parsing failure.

What happens if Moz has no data for a domain, or a lookup fails?

You get a row either way. If Moz's page loads but the Domain Authority card cannot be parsed, authority_score falls back to 0 — so cross-check total_linking_root_domains and top_pages on the same row before treating a zero as a real score. If the page cannot be fetched at all after the proxy ladder is exhausted, the Actor writes a row with type: "error", the normalised domain, a data_captured_at stamp and the exception message in error, then carries on with the remaining domains. Those error rows are not charged — filter them out with rec["type"] == "domain_authority". The two optional lookups degrade quietly rather than failing the row: a failed RDAP lookup gives domain_age_years: null, and a failed archive lookup just means the history series has no wayback points.

Can I analyse multiple domains in one run?

Yes — bulk is the normal mode. urls is a list with no ceiling in the schema; add entries one by one or paste a whole list with Bulk edit. Plain strings, a single bare string, and {"url": "..."} or {"domain": "..."} objects are all accepted, and blank entries are dropped. Throughput is governed by maxConcurrency (1–10, default 1) rather than by a row cap, because Moz's free page returns HTTP 403 under parallel load.

Does MOZ Scraper work with Claude, ChatGPT and other AI agent tools?

Yes. It is callable as a standard HTTP endpoint through the Apify API, so LangChain, CrewAI, n8n or a hand-written tool definition can invoke it and receive typed JSON with no parsing step. Have the agent read type first so an error row is handled as a failure rather than summarised as data.

How does MOZ Scraper compare to other Moz scrapers?

Checked on the Apify Store on 25 July 2026: scrap3r/moz-da-pa-metrics is the most used and documents a compact output — Domain Authority, Page Authority, URL, Spam Score, linking root domains and ranking keywords. jdtpnjtp/moz-domain-authority-checker documents four core metrics plus nine detailed arrays, a structured error-code table, and a stated one-to-ten-domain input range on its listing. radeance/moz-scraper documents a very similar record shape to this Actor's — the same data_captured_at / type / domain identity fields and the same nested arrays — along with subscription-tiered run limits on its listing.

What this Actor documents that the others do not: an explicit estimated_ prefix on every modeled figure plus a record-level is_estimated flag and estimation_note, a per-point source tag on the authority history so measured, archived and modeled months stay distinguishable, and a plain statement that the keyword, question and competitor tables are Moz Pro gated and usually empty. Those are documentation and labelling differences, observable in the field list — not performance claims.

Does MOZ Scraper return data in a format LLMs can use directly?

Yes. Every record is typed, normalized JSON with consistent field names across runs — no HTML parsing, no selectors, no cleanup pass. Pass a row directly into an LLM context window, index it into a vector store, or hand it to an agent tool. The estimation_note field travels with the record, which means a model reading a row also reads which of its numbers are modeled.

What happens when Moz changes its layout or anti-bot system?

The scraper is maintained, and the output key names stay stable on your end regardless of what Moz changes. Because the metrics come from Moz's rendered page and its inline chart data, a layout change is the real exposure here — parsing is anchored on headings and metric cards rather than brittle deep selectors, so a section that moves degrades to an empty array or a null for that field rather than failing the whole row. Anti-bot changes are absorbed by the proxy ladder and the TLS impersonation profiles.

Can I use MOZ Scraper without managing proxies?

Yes, and that is the default. The ladder is automatic — direct, then Apify datacenter, then Apify residential with up to three retries and sticky reuse once it gets there. You never create a proxy account, rotate an IP or pick a session. proxyConfiguration only shapes the middle rung, so leaving it at its default is the normal choice.

Which Moz fields work best for AI training data and RAG indexing?

For RAG indexing: top_linking_domains, top_pages and domain carry the most identifiable text per record and chunk cleanly by domain, and estimation_note is worth indexing alongside them so a retrieved chunk carries its own caveat. For training or modelling: authority_score, page_authority_score, spam_score, total_linking_root_domains and domain_age_years are the structurally consistent numeric fields across records — and they are the measured ones, which is what you want in a feature set. Filter authority_score_history to source values of measured or wayback before using it as a time series. All values return as typed primitives, arrays or plain nested objects, so no normalization pass is needed before indexing.

🔗 Related scrapers

Scraper Name	What it extracts
Ahrefs Scraper	Domain Rating, traffic estimates, backlinks and keyword metrics from a second SEO source
Google Search Autocomplete Scraper	Autocomplete suggestions for keyword and query research
Google News Scraper by Publisher Site Filter	News coverage filtered to a specific publisher or domain
Quora Search Scraper	Question-intent results for content and keyword research
Youtube Search Scraper	Video search results for a keyword
Twitter Trends Scraper	Trending topics for timely content planning

💬 Your feedback

Found a bug, or need a field that is on Moz's free page but not yet in the output? Open an issue on the Actor's Issues tab. Reports that include the exact input JSON and the domain you ran are the fastest to reproduce and fix — and if a field you need turns out to be Moz Pro gated, the issue is the quickest way to get that confirmed in writing.