# Bulk Domain Strength Checker (`searchshark/bulk-domain-strength-checker`) Actor

Score and qualify domains in bulk using transparent registration age, DNS, website availability, HTTPS certificate health, indexability, and homepage SEO signals. No API keys or paid data providers required.

- **URL**: https://apify.com/searchshark/bulk-domain-strength-checker.md
- **Developed by:** [SearchShark Tools](https://apify.com/searchshark) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🌐 Bulk Domain Strength Checker

**Bulk Domain Strength Checker** analyzes domains in bulk using **transparent, factual signals** from registration data, DNS, website availability, HTTPS/TLS, technical indexability, and homepage SEO setup.

Generate a **SearchShark Domain Strength Score from 0 to 100** for every domain without requiring **customer API keys or paid authority-data providers**.

- 🎯 **Qualify domain lists:** quickly identify stronger and weaker domains
- 🔎 **Research domains:** inspect registration, DNS, website, and SEO signals
- 📈 **Screen prospects:** prioritize domains for SEO outreach or lead qualification
- 🧹 **Avoid duplicate work:** normalized duplicate domains are analyzed only once
- 🛡 **Handle missing data safely:** unavailable signals reduce score coverage instead of automatically scoring zero
- ⚡ **Process domains in bulk:** analyze hundreds or thousands of inputs in one Actor run

***

### 📊 What does the Domain Strength Score measure?

The **SearchShark Domain Strength Score** estimates how **established, active, healthy, and technically credible** a domain appears based on observable signals.

It evaluates:

| | |
| --- | --- |
| 🕒 **Domain maturity** | 🌐 **Website availability** |
| 🧭 **DNS health** | 🔒 **HTTPS / TLS health** |
| 🤖 **Technical indexability** | 📝 **Homepage SEO setup** |

> **This is not a backlink-authority metric.**

The score does **not** attempt to reproduce:

```text
Moz Domain Authority
Ahrefs Domain Rating
Majestic Trust Flow
Majestic Citation Flow
```

It does not use a proprietary backlink database.

***

## 🚀 Features

Bulk Domain Strength Checker is designed for **bulk domain qualification and technical research**.

- **Bulk domain analysis:** process large lists in one Actor run
- **URL normalization:** convert URLs and subdomains to the ICANN registrable domain
- **Duplicate-safe processing:** analyze each normalized domain only once
- **Authoritative RDAP registration data**
- **Native DNS resolution:** A, AAAA, MX, and NS records
- **Homepage availability checks**
- **Redirect tracking**
- **Response-time observation**
- **HTTPS detection**
- **TLS certificate inspection**
- **robots.txt analysis**
- **Meta robots detection**
- **X-Robots-Tag detection**
- **Technical indexability evaluation**
- **Sitemap discovery**
- **Homepage title extraction**
- **Meta description extraction**
- **Canonical URL extraction**
- **Transparent component scoring**
- **Score coverage protection**
- **Partial failure handling**
- **One Dataset row per original input**
- **No paid domain-authority API required**

***

## ⬇️ Input

You can run the Actor from the **Apify Console** or programmatically through the **Apify API**.

### 🌐 Domains or URLs

Provide one or more domains or URLs.

Example:

```json
{
    "domains": [
        "example.com",
        "openai.com",
        "https://www.mozilla.org/firefox/"
    ]
}
```

You can provide:

```text
example.com
www.example.com
support.mozilla.org
https://www.example.com/about
https://example.co.uk/page?id=10
```

The Actor normalizes every valid input to its **ICANN registrable domain**.

For example:

```text
https://www.example.com/article?source=test
→ example.com
```

```text
support.mozilla.org
→ mozilla.org
```

The exact submitted value is preserved in:

```text
originalInput
```

***

### 🧹 Duplicate domain handling

Inputs that normalize to the same registrable domain are **analyzed only once**.

For example:

```text
example.com
www.example.com
https://example.com/about
```

all normalize to:

```text
example.com
```

The Actor performs **one actual domain analysis** and reuses that result for all matching inputs.

You still receive:

> **One Dataset row per original input.**

This reduces unnecessary:

```text
DNS requests
HTTP requests
TLS connections
RDAP lookups
robots.txt requests
sitemap checks
```

***

## 🧮 Domain Strength Score

The Domain Strength Score has a maximum of **100 points**.

| Category | Maximum points |
| --- | ---: |
| 🕒 **Domain maturity** | 15 |
| 🌐 **Website availability** | 25 |
| 🧭 **DNS health** | 15 |
| 🔒 **HTTPS / certificate health** | 15 |
| 🤖 **Technical indexability** | 20 |
| 📝 **Homepage SEO setup** | 10 |
| **Total** | **100** |

***

### 🕒 Domain maturity — 15 points

Domain maturity uses the **registration creation date reported by authoritative RDAP**.

| Current registration age | Points |
| --- | ---: |
| **Less than 30 days** | 1 |
| **30–179 days** | 3 |
| **180–364 days** | 5 |
| **1–2 years** | 8 |
| **2–5 years** | 11 |
| **5–10 years** | 13 |
| **10+ years** | 15 |

> **Domain age is an establishment signal, not proof of authority.**

An older registration does not prove:

```text
Backlink quality
Continuous ownership
Historical reputation
Search rankings
Content quality
```

***

### 🌐 Website availability — 25 points

Availability evaluates **homepage reachability, redirect behavior, and observed response time**.

#### HTTP reachability — 15 points

| Result | Points |
| --- | ---: |
| **Final 2xx response** | 15 |
| **401 / 403** | 8 |
| **Redirect loop or redirect limit** | 4 |
| **404 / 410** | 2 |
| **5xx or connection failure** | 0 |

***

#### Redirect behavior — 4 points

| Redirect count | Points |
| --- | ---: |
| **0–2 redirects** | 4 |
| **3–4 redirects** | 2 |
| **5+ redirects or loop** | 0 |

***

#### Response time — 6 points

| Observed response time | Points |
| --- | ---: |
| **≤ 1,000 ms** | 6 |
| **≤ 2,000 ms** | 4 |
| **≤ 4,000 ms** | 2 |
| **> 4,000 ms** | 0 |

> **Response time is a point-in-time observation from the Actor's Apify execution region.**

It is **not a Core Web Vitals measurement** and should not be treated as a permanent website-performance score.

***

### 🧭 DNS health — 15 points

DNS health evaluates whether the domain resolves and whether nameservers are configured.

| Signal | Points |
| --- | ---: |
| **A or AAAA resolves** | 10 |
| **2+ distinct nameservers** | 5 |
| **1 nameserver** | 2 |
| **No nameservers** | 0 |

The Actor also collects:

```text
A records
AAAA records
MX records
NS records
```

> **MX records are informational and do not contribute to the Domain Strength Score.**

Nameserver provider or brand is also **not scored**.

***

### 🔒 HTTPS / certificate health — 15 points

Security scoring evaluates **HTTPS usage and observable TLS certificate health**.

| Signal | Points |
| --- | ---: |
| **Homepage successfully uses HTTPS** | 5 |
| **TLS certificate valid for hostname** | 7 |
| **Certificate expires in more than 30 days** | 3 |
| **Certificate expires in 8–30 days** | 2 |
| **Certificate expires in 1–7 days** | 1 |
| **Certificate expired** | 0 |

The TLS check can collect:

```text
Certificate validity
Certificate issuer
Expiration date
Days remaining
Hostname validity
```

> **HTTPS is treated as an operational and security signal, not backlink authority.**

***

### 🤖 Technical indexability — 20 points

The Actor evaluates observable signals that affect whether the homepage is **technically available for indexing**.

| Signal | Points |
| --- | ---: |
| **Final homepage is successful 2xx HTML** | 5 |
| **No meta robots `noindex`** | 5 |
| **No X-Robots-Tag `noindex`** | 5 |
| **robots.txt allows homepage** | 5 |

The output includes:

```text
indexable
```

Possible values:

```text
true
false
null
```

> **`indexable: true` does not mean the page is indexed by Google.**

It only means the Actor did not observe a technical directive preventing homepage indexing.

***

### 📝 Homepage SEO setup — 10 points

Homepage SEO setup evaluates three basic metadata signals.

| Signal | Points |
| --- | ---: |
| **Non-empty HTML title** | 4 |
| **Non-empty meta description** | 3 |
| **Valid canonical on same registrable site** | 3 |

The Actor extracts:

```text
title
metaDescription
canonical
metaRobots
xRobotsTag
```

Sitemap presence is also collected.

> **Sitemap presence is informational and does not contribute to the score.**

***

## 📊 Score coverage

External domain data is **not always available**.

For example:

- 🌐 **A website may block automated requests**
- 🕒 **A TLD may not provide RDAP**
- 🔒 **A TLS connection may fail**
- 🤖 **robots.txt may be temporarily unreachable**
- 📡 **DNS requests may encounter network errors**
- 🛡 **A firewall may reject the Actor's request**

The Actor does **not automatically convert unavailable data into zero points**.

Instead, every row contains:

```text
scoreCoveragePercent
```

The final score is calculated from **measurable scoring components only**.

Conceptually:

```text
earned measurable points
──────────────────────── × 100
measurable possible points
```

If:

```text
scoreCoveragePercent < 70
```

then:

```text
domainStrengthScore = null
strengthLevel = null
```

This prevents the Actor from assigning a misleading score when **too much underlying data is unknown**.

***

## 🏆 Strength levels

When score coverage is sufficient, the final score is converted into a strength category.

| Score | Strength level |
| --- | --- |
| **0–24** | `very_weak` |
| **25–44** | `weak` |
| **45–64** | `average` |
| **65–84** | `strong` |
| **85–100** | `very_strong` |

***

## 📡 Data sources

The Actor uses **direct and publicly available technical data sources**.

### 🕒 Registration data

Registration information follows:

```text
IANA RDAP bootstrap
→ authoritative RDAP server
```

The Actor can collect:

```text
Registration status
Creation date
Current registration age
Expiration date
Registrar
RDAP status
```

The current version does **not use port-43 WHOIS fallback**.

If authoritative RDAP is unavailable for a TLD, registration data is returned as **unknown rather than automatically scored zero**.

***

### 🧭 DNS data

DNS information is resolved directly using **Node.js native DNS**.

The Actor queries:

```text
A
AAAA
MX
NS
```

***

### 🌐 Website data

The Actor performs direct HTTP/HTTPS requests and observes:

```text
HTTP status
Final URL
Redirect count
Response time
Content type
Homepage HTML
```

The Actor normally starts with:

```text
HTTPS
```

and can fall back to:

```text
HTTP
```

when the HTTPS connection itself cannot be established.

***

### 🔒 TLS certificate data

The Actor directly inspects the domain's TLS certificate.

It can determine:

- **Certificate authorization**
- **Hostname validity**
- **Certificate validity period**
- **Certificate issuer**
- **Expiration timestamp**
- **Days remaining**

***

### 🤖 robots.txt

The Actor checks the website's:

```text
/robots.txt
```

and evaluates wildcard-user-agent rules against the homepage.

A missing robots.txt file does **not automatically block indexing**.

A temporarily unreachable robots.txt file is returned as **unknown**.

***

### 🗺 Sitemap discovery

The Actor checks sitemap availability using:

1. **Sitemap declarations inside robots.txt**
2. **`/sitemap.xml` fallback**

Sitemap presence is returned in:

```text
sitemapExists
```

> **Sitemap presence does not contribute points to the Domain Strength Score.**

***

## ⬆️ Output

Results are stored in the Actor's default **Apify Dataset**.

You can access them through:

```text
Output
Storage
Apify API
Integrations
```

Each row represents:

> **One original input submitted to the Actor.**

***

### 📊 Primary result fields

| Field | Description |
| --- | --- |
| **originalInput** | Exact value supplied by the user |
| **domain** | Normalized registrable domain |
| **domainStrengthScore** | Final score from 0–100 |
| **strengthLevel** | Strength category |
| **scoreCoveragePercent** | Percentage of measurable score components |
| **scoreVersion** | Score methodology version |
| **maturityScore** | Registration maturity points |
| **availabilityScore** | Website availability points |
| **dnsScore** | DNS health points |
| **securityScore** | HTTPS/TLS health points |
| **indexabilityScore** | Technical indexability points |
| **seoSetupScore** | Homepage SEO setup points |
| **status** | Overall analysis status |

***

### 📋 Registration fields

```text
registered
rdapStatus
createdAt
domainAgeDays
domainAgeYears
expiresAt
registrar
registrationStatus
```

***

### 🧭 DNS fields

```text
dnsResolved
ipv4
ipv6
mxRecords
nameservers
```

***

### 🌐 Website fields

```text
httpStatus
finalUrl
redirectCount
responseTimeMs
contentType
```

***

### 🔒 TLS fields

```text
https
sslValid
sslIssuer
sslExpiresAt
sslDaysRemaining
```

***

### 📝 Homepage SEO fields

```text
title
metaDescription
canonical
```

***

### 🤖 Indexability fields

```text
metaRobots
xRobotsTag
robotsExists
robotsAllowsHomepage
sitemapExists
indexable
```

***

### 🛠 Diagnostic fields

```text
status
errors
checkedAt
```

***

## 🧪 Example result

```json
{
    "originalInput": "https://www.example.com/about",
    "domain": "example.com",

    "domainStrengthScore": 94,
    "strengthLevel": "very_strong",
    "scoreCoveragePercent": 100,
    "scoreVersion": "1.0",

    "maturityScore": 15,
    "availabilityScore": 25,
    "dnsScore": 15,
    "securityScore": 15,
    "indexabilityScore": 20,
    "seoSetupScore": 4,

    "registered": true,
    "rdapStatus": "success",
    "createdAt": "1995-08-14T04:00:00.000Z",
    "domainAgeDays": 11347,
    "domainAgeYears": 31.07,
    "expiresAt": "2027-08-13T04:00:00.000Z",
    "registrar": "Example Registrar",
    "registrationStatus": [],

    "dnsResolved": true,
    "ipv4": [
        "93.184.216.34"
    ],
    "ipv6": [],
    "mxRecords": [],
    "nameservers": [
        "a.iana-servers.net",
        "b.iana-servers.net"
    ],

    "httpStatus": 200,
    "finalUrl": "https://example.com/",
    "redirectCount": 0,
    "responseTimeMs": 350,
    "contentType": "text/html",

    "https": true,
    "sslValid": true,
    "sslIssuer": "Example CA",
    "sslExpiresAt": "2026-12-01T00:00:00.000Z",
    "sslDaysRemaining": 84,

    "title": "Example Domain",
    "metaDescription": null,
    "canonical": null,

    "metaRobots": null,
    "xRobotsTag": null,

    "robotsExists": true,
    "robotsAllowsHomepage": true,
    "sitemapExists": false,

    "indexable": true,

    "status": "success",
    "errors": [],
    "checkedAt": "2026-09-08T07:00:00.000Z"
}
```

> **Actual values depend on the domain and internet conditions at the time of the run.**

***

## 🛡 Result status

Each Dataset row contains one of four statuses.

### ✅ `success`

The analysis completed with **full measurable coverage** and no condition requiring a partial result.

***

### ⚠️ `partial`

The Actor successfully returned available domain information, but **one or more signals could not be fully determined**.

For example:

```text
RDAP unsupported
robots.txt unreachable
website blocks automated requests
TLS signal unavailable
homepage metadata unavailable
```

> **A partial result is not the same as a failed domain analysis.**

***

### ❌ `invalid_input`

The supplied value could not be converted into a valid **ICANN registrable domain**.

Examples may include:

```text
Empty input
IP address
Invalid hostname
Non-registrable value
```

***

### 🛑 `failed`

An unexpected processing failure prevented meaningful analysis.

The Actor is designed to **preserve successful subsystem data whenever possible**, so normal external website failures generally produce `partial` rather than `failed`.

***

## ⚡ Bulk processing

The Actor is designed for **large domain lists**.

During processing it:

- 🧹 **Normalizes inputs before analysis**
- 🔁 **Deduplicates normalized domains**
- ♻️ **Reuses results for duplicate inputs**
- ⚡ **Runs multiple domain analyses concurrently**
- 🕒 **Limits RDAP concurrency**
- 🛡 **Preserves partial results**
- 📊 **Calculates score coverage**
- 📦 **Produces one Dataset row per original input**

A slow or unreachable domain does **not prevent other domains from completing**.

***

## 💡 Example use cases

### 🎯 SEO prospect qualification

Analyze a large outreach list and prioritize domains using:

```text
Domain maturity
Website availability
DNS health
HTTPS health
Technical indexability
Homepage SEO setup
```

This can help reduce time spent manually checking low-quality or inactive prospects.

***

### 🔎 Domain research

Inspect:

- **Registration age**
- **Current registration status**
- **Registrar**
- **DNS resolution**
- **Nameserver setup**
- **Website availability**
- **HTTPS certificate health**
- **robots.txt behavior**
- **Homepage metadata**

from one structured Dataset.

***

### 🏷 Expired-domain screening

Use registration, DNS, and website signals to help identify domains that appear:

```text
Registered and active
Registered but inactive
Technically broken
Recently registered
Long-established
Potentially unavailable
```

> **The score does not evaluate backlink history.**

***

### 🗂 Website portfolio audits

Run hundreds or thousands of owned domains to identify:

```text
Unreachable websites
DNS failures
HTTPS problems
Expired certificates
Indexability restrictions
Missing titles
Missing descriptions
Missing canonicals
```

***

### 📈 Lead qualification

Combine the Domain Strength Score with your CRM or lead-generation workflow to prioritize websites that appear **active and technically established**.

***

## 🔌 API & integrations

Bulk Domain Strength Checker can be started through the **Apify API**.

Dataset results can be integrated with workflows such as:

- Google Sheets
- Make
- Zapier
- CRMs
- Internal APIs
- Data warehouses
- Lead-generation systems
- SEO workflows
- AI agents
- MCP workflows

Every run stores **structured Dataset rows**, making the output easy to process automatically.

***

## ⚠️ Important limitations

### This is not backlink authority

The Domain Strength Score does **not use**:

```text
Backlink counts
Referring-domain databases
Moz metrics
Ahrefs metrics
Majestic metrics
```

Do not interpret it as a replacement for proprietary backlink-based metrics.

***

### Domain age does not prove authority

An older registration date does **not guarantee**:

```text
Strong backlinks
Continuous ownership
Historical website quality
Search rankings
Trusted content
Traffic
```

***

### Technical indexability does not mean indexed

If:

```text
indexable: true
```

the Actor did not observe an applicable technical directive blocking the homepage.

It does **not confirm Google or Bing currently indexes the page**.

***

### Website responses can vary

Websites may behave differently depending on:

```text
Execution region
CDN routing
Server load
Bot protection
Firewall configuration
Temporary outages
Geographic restrictions
```

Results represent what the Actor **observed during that run**.

***

### Some websites block automated requests

A domain may use:

- **Bot protection**
- **CAPTCHA systems**
- **Firewalls**
- **Authentication**
- **Rate limits**
- **Geographic restrictions**

When the Actor cannot reliably measure a signal, it returns **unknown or partial data instead of inventing a value**.

***

## ❓ FAQ

### Does this calculate Domain Authority?

**No.**

The Actor calculates the **SearchShark Domain Strength Score**, which uses transparent registration, DNS, website, HTTPS, indexability, and homepage SEO signals.

It does not calculate Moz Domain Authority.

***

### Does it use Ahrefs or Majestic?

**No.**

The Actor does not require:

```text
Ahrefs
Moz
Majestic
DomDetailer
paid backlink APIs
customer authority-metric API keys
```

***

### Do I need an API key?

**No external API key is required.**

The Actor uses direct technical sources such as **RDAP, DNS, HTTP, and TLS**.

***

### Can I submit URLs instead of domains?

**Yes.**

For example:

```text
https://www.mozilla.org/firefox/
```

is normalized to:

```text
mozilla.org
```

***

### What happens to subdomains?

Inputs are normalized to the **ICANN registrable domain**.

For example:

```text
support.mozilla.org
```

becomes:

```text
mozilla.org
```

***

### What happens to duplicate domains?

Duplicate normalized domains are **analyzed once and reused**.

You still receive **one Dataset row for every original input**.

***

### Why is `domainStrengthScore` sometimes null?

If:

```text
scoreCoveragePercent < 70
```

the Actor intentionally returns:

```text
domainStrengthScore: null
strengthLevel: null
```

This prevents a misleading score when too much source data is unavailable.

***

### Why is a result marked `partial`?

A `partial` result means **some analysis succeeded but one or more signals could not be fully determined**.

It does not mean the entire analysis failed.

***

### Does `indexable: true` mean Google indexes the domain?

**No.**

It means the Actor did not observe technical homepage directives preventing indexing.

It does not query Google's index.

***

### Is sitemap presence scored?

**No.**

Sitemap presence is collected as an informational signal only.

***

### Are MX records scored?

**No.**

MX records are collected but do not affect the score.

***

### Can I export the results?

**Yes.**

Apify Dataset results can be exported using supported formats such as:

```text
JSON
CSV
Excel
XML
HTML
```

***

## 🧭 Recommended workflow

For large prospect or domain lists:

1. **Submit the entire list**
2. **Sort by Domain Strength Score**
3. **Check score coverage**
4. **Review partial results when necessary**
5. **Use component scores to understand why a domain scored higher or lower**
6. **Export qualified domains into your next workflow**

For example:

```text
Domain A
Score: 98
Coverage: 100%
Status: success

Domain B
Score: 72
Coverage: 100%
Status: success

Domain C
Score: null
Coverage: 60%
Status: partial
```

Domain C should be treated as **insufficiently measured**, not automatically as a weak domain.

***

## 🧪 Score version

Current scoring methodology:

```text
SearchShark Domain Strength Score v1.0
```

Every Dataset row includes:

```text
scoreVersion: "1.0"
```

This allows results to remain associated with the scoring methodology used when the domain was analyzed.

***

## 💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's **Issues** tab on Apify.

Useful future additions may include:

```text
Additional technical signals
Optional analysis modes
Expanded domain diagnostics
Portfolio monitoring
Additional bulk filtering
Performance improvements
```

***

### 🚀 Qualify domain lists without manually checking every website

Enter your domains, run the Actor, and receive **structured Domain Strength Scores plus transparent registration, DNS, availability, HTTPS, indexability, and homepage SEO signals** ready for **SEO research, prospecting, domain screening, APIs, and automation**.

# Actor input Schema

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

Enter one domain or URL per item. URLs, subdomains, paths, query strings, and fragments are normalized to the registrable domain. For example, https://www.example.com/article becomes example.com.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "openai.com",
    "https://www.mozilla.org/firefox/"
  ]
}
```

# Actor output Schema

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

Domain Strength Scores and the registration, DNS, website, TLS, indexability, and homepage SEO signals used to calculate them.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("searchshark/bulk-domain-strength-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("searchshark/bulk-domain-strength-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 '{}' |
apify call searchshark/bulk-domain-strength-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,searchshark/bulk-domain-strength-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/dLb0Tpk5Jrzu7UO9K/builds/zZZxm9mFUh8wsk4uo/openapi.json