# Moz Scraper (`mlg14/moz-scraper`) Actor

Export Moz's public Top 500 domains or check listed hosts for Domain Authority, linking root domain counts, and rank. Supports bulk domain matching and CSV or JSON output.

- **URL**: https://apify.com/mlg14/moz-scraper.md
- **Developed by:** [MLG Data](https://apify.com/mlg14) (community)
- **Categories:** SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.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.

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

Scrape Moz's public Top 500 list to export Domain Authority, linking root domain counts, and list rank as JSON or CSV. Use a bulk list of domains or URLs to check which hosts appear in the published list, or leave the list empty to export all available entries. This Moz data export is useful when you need a repeatable authority snapshot for prominent domains without a login.

The source covers **500 listed hosts**, not the full web. It does not provide Spam Score, Page Authority, ranking keywords, top pages, referring-domain details, or link history. Those fields are present as `null` so downstream tables can use a consistent set of columns without mistaking unavailable data for zero.

### What data can you extract from Moz?

| Field | Description | Example |
|---|---|---|
| `input` | The submitted domain or URL. When exporting the whole list, this is the listed host. | `europa.eu` |
| `domain` | Submitted hostname, lowercased and with a leading `www.` removed. | `europa.eu` |
| `mozDomain` | Host spelling in the downloaded list; this can retain `www.`. | `europa.eu` |
| `top500Rank` | Position in the published Top 500 list. | `24` |
| `domainAuthority` | Domain Authority score shown in the list. | `97` |
| `pageAuthority` | Reserved for the page-level metric; unavailable from this source. | `null` |
| `spamScore` | Reserved for the spam metric; unavailable from this source. | `null` |
| `linkingRootDomains` | Number of linking root domains shown beside the listed host. | `3232712` |
| `rankingKeywords` | Reserved for the keyword count; unavailable from this source. | `null` |
| `topLinkingDomains` | Reserved for the list of referring domains; unavailable from this source. | `null` |
| `topPages` | Reserved for the list of pages; unavailable from this source. | `null` |
| `linkHistory` | Reserved for discovered and lost links; unavailable from this source. | `null` |
| `domainAuthorityHistory` | Reserved for historical scores; unavailable from this source. | `null` |
| `checkedAt` | UTC time when the list was downloaded for the run. | `2026-09-26T15:09:27Z` |
| `source` | Identifies the data source used for the record. | `moz-top-500` |
| `sourceUrl` | Direct URL of the published CSV. | `https://moz.com/top-500/download/?table=top500Domains` |

The numeric authority and linking fields come from the same downloaded row. `checkedAt` records retrieval time, not the date on which the underlying index was calculated. Rank and metrics can change between runs as the published CSV changes. A host outside the list has no row; its absence does not imply Domain Authority zero or no backlinks.

### How to scrape Moz

1. Open the actor and enter domains or URLs in **Domains or URLs**. Use full URLs if you already have them; the path and query are removed before matching.
2. Set **Max results** to the most rows you want. The default is 100, and the source contains at most 500. To export the list itself, clear the domains field.
3. Run the actor. It downloads the public CSV once, validates its columns, and matches the normalized hosts locally within the run.
4. Open the dataset to inspect the authority scores and linking counts. Download JSON or CSV for a spreadsheet, report, or other workflow.
5. Review the run log if you entered a bulk list. The log reports how many inputs were absent from the Top 500 snapshot.

A bulk request does not issue one network request per domain. The list is fetched once and then used for all requested hosts in the run. Repeated inputs that resolve to the same host produce one output record. For matching, a leading `www.` is treated as equivalent, while other subdomains remain separate.

### Input

| Name | Type | Default | Description |
|---|---|---|---|
| `domains` | String array | Empty | Optional list of hosts or URLs to find in the Top 500 CSV. Empty means export the list in rank order. |
| `maxItems` | Integer | `100` | Maximum records to emit. Valid values are 1 through 500. It does not expand the source beyond 500 hosts. |
| `proxyConfiguration` | Object | Standard proxy | Optional network setting for the single CSV download. The usual setting works with the current source. |

Example input for a list export:

```json
{
  "domains": [],
  "maxItems": 100
}
```

Example input for checking selected hosts:

```json
{
  "domains": ["europa.eu", "https://www.europa.eu/", "example.org"],
  "maxItems": 10
}
```

In the second example, the two forms of `europa.eu` resolve to one host and yield one record if that host is listed. `example.org` is only a format example; a host not in the Top 500 yields no record. The actor does not invent a score for it. If the entire input list is absent, the dataset is empty and the run log contains the unmatched count.

Input order controls result order when `domains` is supplied. An empty list follows the published rank order instead. Scheme, path, port, and query do not affect a hostname match. A meaningful subdomain remains part of the key: `support.example.org` and `example.org` are different hosts. The normalizer removes only a leading `www.`.

### Output example

This item came from a successful run on 26 September 2026. The values are a snapshot and may differ on later runs.

```json
{
  "input": "europa.eu",
  "domain": "europa.eu",
  "mozDomain": "europa.eu",
  "top500Rank": 24,
  "domainAuthority": 97,
  "pageAuthority": null,
  "spamScore": null,
  "linkingRootDomains": 3232712,
  "rankingKeywords": null,
  "topLinkingDomains": null,
  "topPages": null,
  "linkHistory": null,
  "domainAuthorityHistory": null,
  "checkedAt": "2026-09-26T15:09:27Z",
  "source": "moz-top-500",
  "sourceUrl": "https://moz.com/top-500/download/?table=top500Domains"
}
```

The dataset has one record for each listed host returned by the chosen mode. `domainAuthority` and `linkingRootDomains` are numbers, not formatted strings, so sorting and arithmetic work directly in a spreadsheet. The CSV export will leave unavailable metric cells blank. In JSON, those same fields are explicitly `null`. Keep the `source` column when combining this dataset with reports from other sources: its values describe a Top 500 snapshot, not a live analysis of every submitted domain.

### Use cases

- **Authority benchmarking for prominent sites:** Compare Domain Authority and linking-root-domain counts for hosts that appear in the published list. Keep the rank column to see where each host stands in that particular snapshot.
- **Bulk list qualification:** Feed a list of well-known domains and return only members of the Top 500. The output can act as a high-authority segment for a larger review process.
- **Recurring snapshots:** Schedule an export and compare the same hosts over time. Store `checkedAt` with each run so changes can be tied to collection dates. The timestamp is a retrieval marker, not a statement about when Moz recalculated a metric.
- **Data enrichment:** Join the records to an existing table using `domain` or `mozDomain`. The `www.` normalization helps with ordinary homepage URLs; preserve original input values for auditing joins.
- **Editorial research:** Inspect which major domains occupy the list and compare their linking-domain counts. Use the figures as context, not as a complete measure of site quality or search performance.
- **Dashboard input:** Show authority, linking counts, and rank for listed hosts without parsing a web page by hand. Missing metric columns remain explicit, which makes source limitations visible to readers.

These examples depend on Top 500 membership. For a niche site, a new domain, or a domain outside the published list, this actor has no score to return. A missing result should be kept separate from a measured low score in any enrichment or segmentation workflow.

### How much does it cost to scrape Moz?

The current result price is **$1.00 per 1,000 dataset records**, or **$0.001 per returned record**. The actor charges for records it emits. A domain that does not match the published list produces no result record. Your maximum result count is bounded by both `maxItems` and the 500 hosts in the source.

| Returned records | Result charge | Typical request |
|---:|---:|---|
| 50 | $0.05 | Export the first 50 listed hosts. |
| 100 | $0.10 | Use the default `maxItems` with an empty domain list. |
| 500 | $0.50 | Export the complete published list. |

For example, asking for 100 listed hosts and 20 absent hosts yields 100 records and a $0.10 result charge. Repeating a hostname does not create another row. If `maxItems` is 50, the actor stops after 50 emitted records even when more requested hosts are present. Set a small limit when testing a workflow, then increase it when you need the full segment.

The price examples describe result charges at the current rate. They do not claim that every input domain will return data. Check the dataset item count after a run to know how many records were actually delivered. The source itself is finite, so a request for thousands of domains cannot produce thousands of results from this actor.

### Tips for best results

Start by deciding whether you need the whole list or only selected hosts. For the whole list, clear `domains` and set `maxItems` to 500. For a selected group, supply the hosts in your preferred output order. Either bare domains or full URLs are accepted. The actor lowercases hostnames and strips URL paths before lookup.

Keep subdomains when they matter. The Top 500 contains some subdomains as independent entries, and the actor matches them independently. A homepage host and a specialized subdomain can have different list membership. Only `www.` is treated as a simple alias during matching; other prefixes are not collapsed to their parent domain.

Use `mozDomain` when you need the exact spelling of the published entry. Use `domain` when you need a normalized join key. If a result is absent, check the spelling and whether the site is actually present in the public list. Running the actor again will not uncover report-only metrics for an unlisted host. If the list source changes format, the run fails instead of returning misleading records.

Avoid treating the ranking as a global web traffic ranking. It is the position supplied by Moz's Top 500 publication, alongside Domain Authority and linking root domains. A score of 97 and a rank of 24 are different measures. A higher linking-domain count does not necessarily mean a higher rank or the same authority score.

### Limits

The accessible source is a CSV containing 500 hosts and four columns: rank, root domain, linking root domains, and Domain Authority. This determines the actor's coverage and available metrics. The regular domain-analysis report was inaccessible to anonymous automated requests during development, so this actor does not claim to reproduce its larger field set.

The output keeps report-style column names for compatibility, but `pageAuthority`, `spamScore`, `rankingKeywords`, `topLinkingDomains`, `topPages`, `linkHistory`, and `domainAuthorityHistory` are always `null` with this source. Do not use those columns as evidence that a domain has no spam risk, no ranking keywords, or no historical changes. They are unmeasured.

A domain lookup is an exact host match after lowercasing and optional `www.` removal. It is not a registrable-domain lookup or a crawl of a site's pages. An unlisted input is skipped, and the count is logged. The actor has no fallback score for domains outside the list and cannot return more than 500 distinct source rows. The list can change after a later CSV update, so a previously listed host may disappear.

If the CSV becomes unavailable, is blocked, or no longer has the expected columns, the run fails clearly. The actor does not silently substitute old data. The latest successful dataset can still be used for historical analysis, but its `checkedAt` timestamp should be considered when judging how current it is.

### Use with AI agents (MCP)

An agent can supply structured input and read structured records. The important constraint to pass along is Top 500 coverage: the actor is suitable for list export and membership checks, not unrestricted Domain Authority lookups.

Example prompt: “Export the first 100 hosts in Moz's public Top 500 list. Return each host's rank, Domain Authority, and linking root domains as a table. Keep the collection timestamp.”

Example prompt: “Check my domain list against Moz's public Top 500. Show matched hosts and their Domain Authority. Put inputs with no returned row in a separate unmatched list; do not assign them zero scores.”

When using the output in an automated decision, test `source == "moz-top-500"` and use only measured numeric fields. Treat the `null` columns as unavailable. If an agent needs Spam Score, Page Authority, or details for an arbitrary domain, that request requires another source; this dataset cannot answer it.

### FAQ

#### Is this public data legal to use?

The actor reads a publicly available CSV. You are responsible for following the source site's terms and applicable laws when storing, combining, or redistributing the data. The dataset contains domain-level metrics rather than personal profiles; still review how your larger workflow handles personal data if you combine sources.

#### Do I need a login or an API key?

No login or key is needed for the public Top 500 CSV. This does not grant access to account-only reports or a full metrics API. The actor does not sign in or retrieve restricted data.

#### Do I need to configure a proxy?

The default network configuration worked for the verified CSV source. The optional proxy field is available if your run environment needs a different route. A proxy does not expand the Top 500 list or add missing metric columns.

#### How fast is a run?

The actor downloads one CSV and processes it in memory, so the work does not grow with one network request per input host. In the verified 36-record run, the total remote run completed in about 19 seconds. Build time, queueing, network conditions, and dataset writes can change the elapsed time on later runs.

#### Can I schedule runs or monitor changes?

Yes. Schedule repeated runs and save each dataset with its `checkedAt` value. Compare matching hosts across snapshots to detect movements in rank, Domain Authority, or linking count. Because the CSV publication cadence is controlled by the source, frequent runs may return identical figures.

#### Can I export to a spreadsheet?

Yes. Download the dataset as CSV or JSON. Numeric fields are emitted as numbers. Blank cells for the unavailable fields should remain blank rather than being converted to zero when importing the CSV.

#### Why did a domain return no row?

The input host was not in the published Top 500 snapshot, had an invalid hostname, or exceeded `maxItems` after earlier matches. Check the run log for an unmatched count. Try the exact listed subdomain if you know it; otherwise an absent result means only that this source has no row for it.

### Integrations

Use the dataset through an API, a webhook, a schedule, or an automation service. Export JSON for programmatic joins and CSV for a spreadsheet. Keep `domain`, `mozDomain`, and `checkedAt` when passing records to another system, so recipients can see how the host was matched and when the source was retrieved. If the consumer needs a full-domain audit, combine this limited list with a separate source that covers arbitrary hosts and labels its own provenance.

### Support

Open an issue on the Issues tab; we reply within 24h and add fields on request. Include the input host, the run identifier, and the behavior you expected. A field can only be populated when a reachable public source actually supplies it; requests for unavailable report metrics cannot be resolved by inferring values from the Top 500 list.

# Actor input Schema

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

Optional domains or URLs to match against Moz's public Top 500 snapshot. Only listed hosts return records; leave empty to export the list. Repeated hosts are returned once.

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

Maximum number of matching domains to return, up to the 500 hosts in the source list.

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

Optional network configuration for downloading Moz's public list.

## Actor input object example

```json
{
  "domains": [
    "github.com",
    "wordpress.org",
    "cloudflare.com"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Matching domain authority records in the default dataset.

# 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": [
        "github.com",
        "wordpress.org",
        "cloudflare.com"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("mlg14/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": [
    "github.com",
    "wordpress.org",
    "cloudflare.com"
  ]
}' |
apify call mlg14/moz-scraper --silent --output-dataset

```

## MCP server setup

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