# Bulk Domain Authority Checker (`blueskyscraper/bulk-domain-authority-checker`) Actor

\[from $4.50/1K domains] Check domain authority for thousands of domains in one run: domain rank 0–100, backlinks, dofollow/nofollow, referring domains and IPs, spam score, first seen, 30-day new/lost links, organic traffic. Empty domains free. No run fee.

- **URL**: https://apify.com/blueskyscraper/bulk-domain-authority-checker.md
- **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community)
- **Categories:** SEO tools, Marketing, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 domains

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

**Bulk Domain Authority Checker** checks the **domain authority of up to 10,000 domains in one run**. Paste a list of domains or URLs and get **one row per domain** with a **domain rank on a 0–100 scale** (and the raw 0–1000 value), **backlinks**, **dofollow and nofollow backlinks**, **referring domains**, referring main domains, **referring IPs** and subnets, **broken backlinks**, an average **spam score** and the date the first link was seen. Two optional add-ons put **30-day new and lost referring domains and backlinks** and an **organic traffic estimate** on the same row.

The metrics come from a licensed, continuously crawled backlink index, read through bulk requests of up to 100 domains each — that is why a list of thousands of domains costs cents of infrastructure and finishes in seconds. **$0.0045 per domain with data on the Starter plan ($0.005 on the Apify Free plan). Domains the index knows nothing about are free. No fee per run, no login, no API key of your own.**

### What is Bulk Domain Authority Checker?

It is a **bulk DA checker** and **domain rating checker** for SEO, link building and lead qualification. Tools like Moz Domain Authority, Ahrefs Domain Rating and Semrush Authority Score answer the same question — *how strong is this website's backlink profile?* — but checking a few hundred domains there means a paid seat and a lot of copy-and-paste. This Actor takes the whole list at once, cleans it (protocols, `www.`, ports and paths are removed; duplicates are checked once), and returns a flat table you can sort, filter and export.

What it is **not**: `domainRank` is **not** Moz DA or Ahrefs DR. It is a PageRank-style rank computed by the backlink index this Actor reads, shown on the same familiar 0–100 scale. It ranks domains in the same order of magnitude — in our test `wikipedia.org` scored 81.6, `github.com` 88.3, `ahrefs.com` 60.7, `apify.com` 53.6 — but the exact numbers differ from Moz or Ahrefs, as those also differ from each other. Use one metric consistently across your list.

### What data can Bulk Domain Authority Checker extract?

One row per unique domain. Real values from a test run on `apify.com`:

| Field | Example | Meaning |
|---|---|---|
| `domain` | `apify.com` | Normalised domain that was checked |
| `domainRank` | `53.6` | Domain rank, 0–100 scale (raw rank ÷ 10) |
| `domainRank1000` | `536` | Raw domain rank, 0–1000 scale |
| `mainDomainRank` | `53.6` | Rank of the main domain — differs from `domainRank` only for subdomains |
| `authorityTier` | `high` | `very-high` (70+), `high` (50–69.9), `medium` (30–49.9), `low` (10–29.9), `very-low` (under 10), `none` (no data) |
| `backlinks` | `1668679` | Live backlinks to the domain |
| `dofollowBacklinks` | `766562` | Backlinks without the `nofollow` attribute |
| `nofollowBacklinks` | `902117` | Backlinks with `nofollow` |
| `dofollowRatio` | `45.9` | Share of dofollow backlinks, % |
| `referringDomains` | `11590` | Domains linking to it |
| `referringDomainsNofollow` | `5201` | Referring domains with at least one nofollow link |
| `referringMainDomains` | `9085` | Registrable main domains linking to it |
| `referringIps` | `7120` | Distinct IP addresses linking to it |
| `referringSubnets` | `3411` | Distinct subnets linking to it |
| `referringPages` | `1520590` | Pages linking to it |
| `brokenBacklinks` | `26793` | Backlinks pointing at pages that answer 4xx/5xx |
| `brokenPages` | `30830` | Pages of the domain with backlinks that answer 4xx/5xx |
| `spamScore` | `18` | Average spam score (0–100) of the backlinks; higher is spammier |
| `linksPerReferringDomain` | `144` | Backlinks ÷ referring domains — high values hint at sitewide links |
| `firstSeen` | `2019-01-17T06:42:44.000Z` | When the index first saw a link to the domain |
| `lostDate` | `null` | When the last backlink was lost, if all were lost |
| `hasData` | `true` | `false` = the index has no data for this domain (free row) |
| `input` | `https://www.apify.com/store` | The entry as you typed it |
| `checkedAt` | `2026-10-01T13:41:38.667Z` | When the row was made |

#### 📈 30-day changes add-on

| Field | Example (`moz.com`) | Meaning |
|---|---|---|
| `newReferringDomains30d` | `4269` | New referring domains in the last 30 days |
| `lostReferringDomains30d` | `1389` | Lost referring domains in the last 30 days |
| `netReferringDomains30d` | `2880` | New minus lost |
| `newReferringMainDomains30d`, `lostReferringMainDomains30d` | `2028`, … | The same for main domains |
| `newBacklinks30d` | `112383` | New backlinks in the last 30 days |
| `lostBacklinks30d` | `18937` | Lost backlinks in the last 30 days |
| `changesSince` | `2026-09-01` | Start of the 30-day window |

#### 🔎 Organic traffic add-on

| Field | Example (`moz.com`) | Meaning |
|---|---|---|
| `organicTraffic` | `425651` | Estimated monthly visits from Google organic search, all countries |
| `organicKeywords` | `48585` | Number of Google organic results the domain ranks in |
| `paidTraffic` | `6` | Estimated monthly visits from Google Ads |
| `paidKeywords` | … | Number of Google paid results the domain appears in |

Traffic is an **estimate** — search volume × click-through rate summed over the keywords the domain ranks for — not analytics data. It is good for comparing domains and spotting real sites among parked ones, not for reporting exact visits.

### How much does it cost to check domain authority in bulk?

| Event | Free plan | Starter (Bronze) | Scale (Silver) | Business (Gold) |
|---|---|---|---|---|
| 💰 Domain with backlink data (one row) | $0.005 | **$0.0045** | $0.004 | $0.0035 |
| 📈 Add-on: 30-day new and lost links, per domain with data | $0.004 | **$0.0036** | $0.0032 | $0.0028 |
| 🔎 Add-on: organic traffic estimate, per domain with data | $0.003 | **$0.0027** | $0.0024 | $0.0021 |
| Domains with no backlink data, domains below your minimum rank, invalid entries, duplicates | $0 | $0 | $0 | $0 |
| Run start | $0 — no start fee | $0 | $0 | $0 |

On the Starter plan that is **$4.50 per 1,000 domains**, about **222 domains per $1** — or $10.80 per 1,000 with both add-ons. On the Apify Free plan it is $5 per 1,000 domains ($12 with both add-ons), so the $5 of monthly free credit covers about 1,000 domain checks. Platinum and Diamond plans pay the Business price.

For comparison, the most-used backlink checker in Apify Store charges $0.015 per domain checked (Store price on 10 October 2026): the Free plan here is 67% cheaper, Starter 70%. Other bulk DA checkers charged $0.009–$0.015 per domain when we measured on 10 October 2026 (one checker charges $0.0005 but returns only 3 fields), and the paid SEO suites sell this data by monthly seat. **You pay only for domains that actually have data**: a typo, a parked domain or a brand-new site with no links comes back as a free row with `hasData = false`.

The default run (3 domains) costs about $0.014 on the Starter plan ($0.015 on the Free plan) and finished in 4 seconds in our test. A run of 15 domains with both add-ons took 21 seconds.

#### Why small runs may skip an add-on

Each add-on is one extra data request for the whole list — the same price for 3 domains or 1,000. To keep a tiny run from costing more than it earns, the Actor checks before every extra request and **skips an add-on that a very small run cannot cover** — the skipped add-on is not charged, and the run log and status message say so. In practice: with fewer than about **10 domains with data**, the 30-day add-on returns the referring-domain changes but may skip the backlink counts, and asking for both add-ons on 2–3 domains may skip the traffic estimate. Put your domains into one run instead of many single-domain runs and every add-on is delivered. The same rule stops a run early if the first few hundred domains in a list return almost no data (for example a list of typos) — unchecked domains get a free error row.

### How to check domain authority with Bulk Domain Authority Checker

1. Open the Actor and paste your **domains or URLs**, one per line — `example.com`, `https://www.example.com/page` and `example.com:443` are all read as `example.com`.
2. Optional: switch on **30-day new and lost links ($)** and/or **Organic traffic estimate ($)**.
3. Optional: set **Minimum domain rank (0–100)** to keep only strong domains — for example 30 for link-building prospects.
4. Press **Start**. In seconds you get one row per domain; download the table as CSV, Excel or JSON, or read it through the API.

### ⬇️ Input

The prefilled input — three well-known domains, no add-ons:

```json
{
  "domains": ["apify.com", "ahrefs.com", "wikipedia.org"]
}
```

| Field | Default | What it does |
|---|---|---|
| `domains` | 3 demo domains | Domains or URLs, one per line, up to 10,000. Commas, semicolons and line breaks separate entries |
| `include30DayChanges` | `false` | Add new and lost referring domains and backlinks for the last 30 days ($) |
| `includeOrganicTraffic` | `false` | Add organic and paid traffic estimates and keyword counts ($) |
| `minDomainRank` | empty | Keep only domains with `domainRank` (0–100) at least this value; the rest are free |
| `includeEmptyDomains` | `true` | Keep free rows for domains with no data; switch off to drop them |
| `includeSubdomains` | `true` | Count links to all subdomains in the domain's totals; switch off for the exact host only |
| `maxDomains` | `1000` | Most unique domains checked in one run (up to 10,000) |

#### Link-building prospects: strong domains only

```json
{
  "domains": ["site-one.com", "site-two.org", "https://www.site-three.net/blog"],
  "minDomainRank": 30
}
```

Domains below rank 30 are dropped before billing, so you pay only for the prospects you keep.

#### Competitor monitoring: weekly 30-day changes

```json
{
  "domains": ["moz.com", "semrush.com", "similarweb.com", "majestic.com", "ahrefs.com"],
  "include30DayChanges": true,
  "includeOrganicTraffic": true
}
```

Schedule this weekly and compare `netReferringDomains30d` — who is winning links and who is losing them.

#### Subdomains

`blog.hubspot.com` is checked as the subdomain `blog.hubspot.com` (rank 53.3 in our test), not as `hubspot.com`. `www.` is always removed. To check the main domain, enter it without the subdomain.

### ⬆️ Output

One row per unique domain. A real row from a test run (30-day changes and traffic on):

```json
{
  "type": "domain",
  "domain": "moz.com",
  "domainRank": 54,
  "domainRank1000": 540,
  "mainDomainRank": 54,
  "authorityTier": "high",
  "backlinks": 3715467,
  "dofollowBacklinks": 2348511,
  "nofollowBacklinks": 1366956,
  "dofollowRatio": 63.2,
  "referringDomains": 119596,
  "referringDomainsNofollow": 22199,
  "referringMainDomains": 110446,
  "referringIps": 59526,
  "referringSubnets": 26094,
  "referringPages": 3009956,
  "brokenBacklinks": 97435,
  "brokenPages": 20275,
  "spamScore": 23,
  "linksPerReferringDomain": 31.1,
  "firstSeen": "2019-01-15T22:55:49.000Z",
  "lostDate": null,
  "newBacklinks30d": 112383,
  "lostBacklinks30d": 18937,
  "newReferringDomains30d": 4269,
  "lostReferringDomains30d": 1389,
  "netReferringDomains30d": 2880,
  "changesSince": "2026-09-01",
  "organicTraffic": 425651,
  "organicKeywords": 48585,
  "hasData": true,
  "input": "https://www.moz.com/blog",
  "checkedAt": "2026-10-01T13:42:14.700Z"
}
```

The Console shows four tabs: **Domain authority** (rank, tier, backlinks, dofollow, referring domains and IPs, spam score, broken backlinks, first seen), **Links in detail** (every link count), **30-day changes and traffic** and **All fields**. Add-on fields are `null` when the add-on is off, so every row has the same columns.

#### Domains without data

A domain the backlink index has never seen — a typo, a parked or a brand-new domain — comes back as a **free** row with `hasData: false`, `domainRank: 0`, `backlinks: 0` and `authorityTier: "none"`. In our test `zzqq-nonexistent-domain-8812.com` came back exactly like that, while a small site with a single known backlink came back as a normal paid row with rank 0 and tier `very-low`.

#### Error rows

Entries that are not domains (`foo`, an IP address like `1.2.3.4`) give a free row:

```json
{ "type": "error", "domain": null, "input": "1.2.3.4", "error": "\"1.2.3.4\" is an IP address — enter a domain name. Not charged.", "checkedAt": "2026-10-01T13:42:54.000Z" }
```

A run summary (entries, duplicates, domains with and without data, add-ons delivered, skipped add-ons) is saved in the key-value store as `SUMMARY`.

### Use cases for bulk domain authority data

#### Link building and outreach

Paste a prospect list from a search, a directory or a competitor's backlinks; keep `minDomainRank ≥ 30`, sort by `referringDomains`, drop high `spamScore` sites. Then find who to email with [Website Contact Scraper](https://apify.com/lergassy/website-contacts-api).

#### Expired and aged domain research

`firstSeen`, `referringMainDomains`, `referringSubnets` and `spamScore` together tell an aged, naturally linked domain from a link farm. `lostDate` marks domains whose links have all disappeared.

#### Competitor and market monitoring

Run your competitors weekly with the 30-day add-on and track `netReferringDomains30d` — the number that shows whose link building is working right now.

#### Lead qualification

Agencies and SaaS sales teams score lists of company websites: `authorityTier` and `organicTraffic` separate established businesses from tiny or dormant sites before anyone spends time on them.

#### Guest posts and PR

Rank a list of publications by authority and traffic before pitching; `dofollowRatio` hints at how a site treats outgoing links.

#### AI agents and LLM pipelines

An agent can pass any list of domains and get flat, typed rows back in seconds — for prospect scoring, research reports or enrichment of a CRM.

### Integrations

Every run is available through the **Apify API**, and the Actor works with **n8n, Make, Zapier, Google Sheets, Airbyte, LangChain** and the **Apify MCP server**.

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("lergassy/bulk-domain-authority-checker").call(run_input={
    "domains": ["moz.com", "semrush.com", "github.com"],
    "include30DayChanges": True,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["domainRank"], row["referringDomains"], row["netReferringDomains30d"])
```

JavaScript:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('lergassy/bulk-domain-authority-checker').call({
    domains: ['moz.com', 'semrush.com', 'github.com'],
    minDomainRank: 30,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => [r.domain, r.domainRank]));
```

Schedule the Actor in the Console to re-check a list every week, and send the dataset to Google Sheets, Slack or a webhook.

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling this Actor through the Apify MCP server or the Apify API (`lergassy/bulk-domain-authority-checker`).

**Purpose:** one row = one domain's backlink authority profile. Answers "how strong is this domain?", "which of these sites are worth a link?", "who gained or lost referring domains this month?".

**Minimal input:**

```json
{ "domains": ["example.com", "https://www.another-site.org/page"] }
```

**Output:** type, domain, domainRank (0–100), domainRank1000, mainDomainRank, authorityTier, backlinks, dofollowBacklinks, nofollowBacklinks, dofollowRatio, referringDomains, referringDomainsNofollow, referringMainDomains, referringIps, referringSubnets, referringPages, brokenBacklinks, brokenPages, spamScore, linksPerReferringDomain, firstSeen, lostDate, newBacklinks30d, lostBacklinks30d, newReferringDomains30d, lostReferringDomains30d, netReferringDomains30d, newReferringMainDomains30d, lostReferringMainDomains30d, changesSince, organicTraffic, organicKeywords, paidTraffic, paidKeywords, hasData, input, checkedAt. Error rows: type = "error", domain, input, error, checkedAt.

**Behaviors an agent should know:**

- URLs are reduced to the host; `www.` is removed; subdomains are kept; duplicates are checked once.
- `domainRank` is a PageRank-style rank of this index on a 0–100 scale — not Moz DA or Ahrefs DR.
- `hasData: false` rows (unknown domains) are free; filter with `minDomainRank` or `includeEmptyDomains: false` instead of post-filtering.
- Add-on fields are null unless `include30DayChanges` / `includeOrganicTraffic` is true; very small runs may skip an add-on (not charged, noted in the status message).
- Billed on the Starter plan: $0.0045 per domain with data, +$0.0036 for 30-day changes, +$0.0027 for traffic (Free plan: $0.005, +$0.004, +$0.003). No start fee.
- All fields are flat scalars.

### ❓ FAQ

#### Is it legal to check domain authority and backlinks?

The Actor reports aggregated link counts about public websites from a commercial backlink index — no personal data and nothing behind a login. Check your local law and your use case; when in doubt, consult a lawyer.

#### Is domainRank the same as Moz DA or Ahrefs DR?

No. It is the rank of the backlink index this Actor reads, computed with a PageRank-style method and shown on a 0–100 scale (the raw 0–1000 value is in `domainRank1000`). Like DA and DR, it grows with the number and strength of linking domains, so it sorts lists the same way in most cases — but the numbers are not interchangeable.

#### How many domains can I check in one run?

Up to 10,000 unique domains (set **Max domains**; the default is 1,000). Data is requested in batches of 100 domains.

#### Why did some domains come back with hasData = false?

The backlink index has no links for them: the domain is misspelled, parked, new, or simply has no backlinks. These rows are free.

#### How much does a typical run cost?

On the Starter plan the default 3-domain run costs about $0.014, 1,000 domains cost $4.50, and $10.80 with both add-ons. On the Free plan: $0.015, $5 and $12. There is no start fee.

#### Why was an add-on skipped in my run?

The run was too small to cover the extra data request the add-on needs (see "Why small runs may skip an add-on"). It was not charged. Put more domains into one run.

#### Are the 30-day changes exact?

They are the counts of links the index found or lost since `changesSince`. Large sites gain and lose thousands of links a month as pages change; compare the trend between domains rather than reading a single number as exact.

#### Can I use Bulk Domain Authority Checker with the Apify API?

Yes. Start runs, read datasets and schedule jobs with the Apify API or the Python and JavaScript clients shown above.

#### Can I use it through an MCP server?

Yes. Add the Apify MCP server (`https://mcp.apify.com`) to Claude, Cursor or any MCP client and call `lergassy/bulk-domain-authority-checker` as a tool.

#### Can I integrate it with other apps?

Yes — n8n, Make, Zapier, Google Sheets, Airbyte, Slack and webhooks through Apify integrations.

#### Is each domain one row?

Yes. One row per unique domain per run; `https://www.example.com/a` and `example.com` count as the same domain and are charged once.

### Your feedback

Found a wrong number, need another metric or a bigger batch? Open an issue on the **Issues** tab — we read every one. If the Actor saved you time, a review on the Store page helps other people find it.

### You might also like

| Actor | What it does |
|---|---|
| [Competitor Keywords Finder](https://apify.com/blueskyscraper/competitor-keywords-finder) | Keywords any domain ranks for in Google, with positions and search volume |
| [Keyword Search Volume Checker](https://apify.com/blueskyscraper/keyword-search-volume-checker) | Monthly search volume, CPC and competition for a list of keywords |
| [Domain Intelligence Scraper](https://apify.com/lergassy/domain-intelligence-scraper) | WHOIS, DNS, hosting and technology data for any domain |
| [Website Contact Scraper](https://apify.com/lergassy/website-contacts-api) | Emails, phones and social profiles from websites — find who to contact for link building |
| [Wappalyzer Scraper](https://apify.com/lergassy/wappalyzer-scraper) | Technologies behind any website |

**Also known as:** bulk DA checker, domain authority checker, domain rating checker, DR checker, bulk backlink checker, backlink checker bulk, referring domains checker, website authority checker, link profile checker, spam score checker, Moz DA alternative, Ahrefs DR alternative, domain authority API.

# Actor input Schema

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

Enter one domain or URL per line (up to 10,000). Protocols, www., ports and paths are removed, so https://www.example.com/blog becomes example.com; duplicates are checked once. Subdomains such as blog.example.com are checked as subdomains.

## `include30DayChanges` (type: `boolean`):

Switch on to add new and lost referring domains and new and lost backlinks over the last 30 days to every row. Billed as a separate add-on per domain with data. For runs with fewer than about 10 domains only the referring-domain changes are added — see the README.

## `includeOrganicTraffic` (type: `boolean`):

Switch on to add the estimated monthly Google organic traffic, the number of organic keywords, and paid traffic and keywords. Billed as a separate add-on per domain with data.

## `minDomainRank` (type: `integer`):

Keep only domains whose domainRank (0–100 scale) is at least this number. Domains below it are dropped and not charged. Leave empty to keep all.

## `includeEmptyDomains` (type: `boolean`):

Keep a free row with hasData = false for domains the backlink index knows nothing about (new, parked or misspelled domains). Switch off to drop them.

## `includeSubdomains` (type: `boolean`):

Count backlinks pointing to every subdomain of the domain (blog., shop., …) in its totals. Switch off to count only the exact host you entered.

## `maxDomains` (type: `integer`):

Set the most unique domains to check in one run (up to 10,000). Extra domains in the list are ignored and not charged.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "ahrefs.com",
    "wikipedia.org"
  ],
  "include30DayChanges": false,
  "includeOrganicTraffic": false,
  "includeEmptyDomains": true,
  "includeSubdomains": true,
  "maxDomains": 1000
}
```

# Actor output Schema

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

One row per unique domain: domain rank 0–100, backlinks, dofollow/nofollow, referring domains, IPs, spam score, first seen; optional 30-day changes and organic traffic.

# 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",
        "ahrefs.com",
        "wikipedia.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("blueskyscraper/bulk-domain-authority-checker").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",
        "ahrefs.com",
        "wikipedia.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("blueskyscraper/bulk-domain-authority-checker").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",
    "ahrefs.com",
    "wikipedia.org"
  ]
}' |
apify call blueskyscraper/bulk-domain-authority-checker --silent --output-dataset

```

## MCP server setup

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

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/e5n2k9ZiaHUjPbfDD/builds/w1ZEfCuw8SN3k0Lfz/openapi.json