# Website Traffic & Domain Authority - SEO Similarweb Alternative (`doesaiknow/domain-authority-checker`) Actor

Bulk website traffic & domain authority checker: one row per domain — estimated search traffic, organic keyword counts, plus opt-in authority rank, top pages & referring-domain counts. Pay-per-use SEO Similarweb / Ahrefs DR / Moz DA alternative — no subscription. From $0.10/domain, free tier.

- **URL**: https://apify.com/doesaiknow/domain-authority-checker.md
- **Developed by:** [Dawid S](https://apify.com/doesaiknow) (community)
- **Categories:** SEO tools, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0625 / domain overview (per domain)

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Website Traffic & Domain Authority Checker - SEO Similarweb Alternative

Bulk **website traffic & domain authority** lookups — paste a list of domains, get **one decisional
row per domain**: organic keyword count, **estimated search traffic**, top-position distribution,
and (opt-in) the domain's **strongest pages**, **authority rank** and **referring-domain counts**. Built for
qualifying competitors, prospects and link/partnership targets **without a monthly SEO-suite
subscription or a sales call** — pay-per-use, **from $0.10 per domain**, free tier, no monthly floor.

> **What this measures — and what it does NOT.** Traffic figures here are **estimated SEARCH
> traffic**: modeled from the domain's organic rankings × keyword volumes × click-through rates.
> They are **not total site visits** — direct, social, referral, email and paid-social traffic are
> not included, so a newsletter- or app-driven site will show a fraction of its panel number. For
> total-visit panels use a panel product (e.g. Similarweb). For qualifying domains by their **SEO
> footprint** — the job this actor is built for — search-derived traffic is the *more* relevant
> metric, not a compromise.

### What you get

| Module | Output | Fires |
|---|---|---|
| **Domain overview** (always) | Organic keyword count, estimated search traffic (organic + paid), top-3 / top-10 position counts | per domain |
| **Top pages** (opt-in flag) | The domain's 10 strongest pages by estimated search traffic, with per-page keyword counts | per domain |
| **Backlink summary** (opt-in flag) | **Authority rank** (`domain_rank`, 0–1000, higher = stronger), referring-domain & total-backlink **counts**, spam score | per domain |

The authority rank is backlink-derived, so it ships with the **backlink summary** module — turn on
`includeBacklinkSummary` to fill the `domain_rank` column (it stays `null` in overview-only runs).

One run = up to **1,000 domains**, one row each — no stitching three tools together.

### Quick start
```json
{ "domains": ["monday.com", "notion.so", "airtable.com"],
  "location": "United States", "language": "English" }
````

Full URLs work too — `https://www.monday.com/pricing` is normalized to `monday.com` automatically.

### Output example

One row per domain, here with `includeBacklinkSummary` on — that add-on fills `domain_rank` and
`referring_domains` (`estimated_search_traffic` = search-derived estimate, monthly):

```json
[
  { "domain": "monday.com",  "domain_rank": 512, "organic_keywords_count": 68352,
    "estimated_search_traffic": 1498322, "positions_top_3": 772, "positions_top_10": 2902,
    "referring_domains": 24012, "location": "United States", "source": "estimated" },
  { "domain": "notion.so",   "domain_rank": 601, "organic_keywords_count": 91000,
    "estimated_search_traffic": 2380000, "positions_top_3": 1402, "positions_top_10": 4422,
    "referring_domains": 51230, "location": "United States", "source": "estimated" }
]
```

With `includeTopPages` each row also carries a `top_pages` array
(`{ page, estimated_search_traffic, organic_keywords_count }` × 10).

### Use cases

- **Qualify competitors** — one row tells you whether a domain is worth a deep-dive.
- **Vet link & partnership targets** — authority + referring-domain counts + real search footprint.
- **Score prospect lists** — enrich a CRM export of 500 company domains in one run.
- **Multi-market checks** — the same list evaluated in any country/language market.

### Pricing

**Pay per event, no subscription.** You pay only for delivered rows — failed lookups, no-data
domains, cache hits and empty runs are never billed per-domain.

| Event | Fires | Price (FREE tier) |
|---|---|---|
| `actor-start` | once per run (validation + cache check) | $0.05 |
| `domain-overview` | per domain row delivered | **$0.10** |
| `top-pages` (opt-in) | per domain with pages delivered | $0.10 |
| `backlink-summary` (opt-in) | per domain with summary delivered | $0.20 |

#### Volume discounts by Apify plan tier

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| `domain-overview` | $0.10 | $0.0875 | $0.075 | **$0.0625** |
| `top-pages` | $0.10 | $0.0875 | $0.075 | **$0.0625** |
| `backlink-summary` | $0.20 | $0.175 | $0.15 | **$0.125** |

> `actor-start` stays flat across tiers. A **full-mix row** (all modules) is **$0.40/domain** on
> FREE and **$0.25/domain** on GOLD. Checking 100 domains (overview only) costs **$10.05** — no
> seat, no monthly minimum. **Free Apify plans:** up to 10 domains per run, overview module only.

### How it compares

| | This actor | Similarweb | Ahrefs | Moz | Semrush |
|---|---|---|---|---|---|
| Entry price | **pay-per-use, from $0.10/domain** | monthly subscription | monthly subscription | monthly subscription | monthly subscription |
| Self-serve API access | **✅ from the first call** (every run is an API call) | sales-gated | top-plan gated | separate paid API packages | top-plan gated |
| Bulk domain lists | **✅ up to 1,000/run** | plan-limited | plan-limited | plan-limited | plan-limited |
| Traffic metric | **estimated search traffic** (honest label) | total-visit panel | search clicks | — | search traffic |
| Data source | **native SEO data APIs — no scraping** | panel | own index | own index | own index |

Most "traffic checker" actors on Apify scrape a SaaS frontend and break whenever it changes. This
one is built on **native data APIs — zero scraping**, so it doesn't rot when someone redesigns a
website.

### What it does NOT do (honest scope)

- **Traffic ≠ total visits.** `estimated_search_traffic` is search-derived (rankings × volume ×
  CTR). Sites living on direct/social/app traffic will read low vs their panel numbers — by design.
- **`domain_rank` is not Ahrefs DR or Moz DA.** It's an authority metric derived from backlink
  data, comparable *in spirit* — the scale and the numbers differ. Compare domains **within** this
  tool, don't mix scales across tools. (Scale details in the FAQ below.)
- **Counts, not link lists.** The backlink summary returns referring-domain/backlink **counts** —
  the full link profile lives in our [Backlink Checker](https://apify.com/doesaiknow/backlink-checker-api-referring-domains-competitor-gap) actor.
- **Numbers + samples, not full keyword dumps.** For the complete list of keywords a domain ranks
  for, use our [Competitor Keyword Research](https://apify.com/doesaiknow/doesaiknow-competitor-keywords-apify) actor.
- All figures are **estimates for prioritization** — labeled `source: "estimated"` on every row.

### FAQ

**Why is my number different from similarweb.com?**
Different metric. Panels estimate **total visits** (direct + social + referral + email + search);
this actor estimates **search-derived traffic** from the domain's actual rankings. A domain with a
big newsletter or app audience will legitimately read lower here — e.g. instagram.com, whose
audience is overwhelmingly app/direct, shows an estimated US search traffic in the low billions
per month while total-visit panels report roughly 2–3× that globally. If you're qualifying domains
for SEO, content or link work, search-derived traffic is the signal you want.

**What scale is `domain_rank` on — is higher better?**
**0–1000, higher = stronger.** It measures the strength of the domain's backlink profile, and the
scale is roughly logarithmic — climbing from 700 to 800 takes far more link equity than from 300
to 400. Rules of thumb: 0–200 little to no authority, 200–400 emerging, 400–600 established,
600–800 strong (e.g. well-known SaaS brands score in the 600s–800s), 800+ internet heavyweights.
The rank ships with the `includeBacklinkSummary` add-on; in overview-only runs the column is `null`.

**Is `domain_rank` the same as Ahrefs DR or Moz DA?**
No — same idea (backlink-derived authority), different scale and math (DR/DA use 0–100, this uses
0–1000). Don't expect 1:1 numbers; use it to rank domains against each other inside your run.

**Which markets are supported?**
Pick the market and language from the input dropdowns — 92 countries and 46 languages (e.g.
'United States'/'English', 'Germany'/'German'). Domains are global; keyword counts and traffic
estimates are computed per market. One market per run.

**Do I need a subscription?**
No. Pay per delivered row; failed, cached, no-data and empty runs are never charged per-domain.

**Can I run it from an AI agent?**
Yes — it's a limited-permission, MCP-ready actor (no first-run approval step), callable from AI
agents and IDEs via the Apify MCP server.

### Related actors

Part of the DoesAiKnow keyword-research & GEO/SEO suite on Apify:

- **[Keyword Metrics Pro — Google + Bing Volume, CPC & Trend](https://apify.com/doesaiknow/doesaiknow-keyword-metrics-apify)** — volume/CPC for the keywords those domains rank for.
- **[Competitor Keyword Research — See Any Site's Ranked Keywords](https://apify.com/doesaiknow/doesaiknow-competitor-keywords-apify)** — the full keyword list behind a domain you qualified here.
- **[Backlink Checker API — Referring Domains & Competitor Gap](https://apify.com/doesaiknow/backlink-checker-api-referring-domains-competitor-gap)** — the full backlink profile behind the counts.
- **[AI Search Volume — GEO / AEO Keyword Research Tool & API](https://apify.com/doesaiknow/ai-search-volume-geo-keyword-research-tool-api)** — AI-search demand for your topics.
- **[AI Brand Visibility Tracker — ChatGPT, Perplexity, Gemini](https://apify.com/doesaiknow/ai-brand-visibility-tracker-chatgpt-perplexity-gemini)** — is your brand cited in AI answers?
- **[AI Keyword Clustering Tool — Topical Clustering + Bulk SERP](https://apify.com/doesaiknow/ai-keyword-clustering-tool-topical-clustering-bulk-serp)** — group keyword lists into topic clusters.
- **[Amazon Keyword Research Tool — Volume + Reverse ASIN](https://apify.com/doesaiknow/amazon-keyword-research-tool-volume-reverse-asin)** — product-search demand + reverse-ASIN.

### Disclaimer

Provided as-is for research. All traffic and authority figures are best-effort **estimates** for
prioritization. Independent project — not affiliated with, endorsed by, or partnered with
Similarweb, Ahrefs, Moz, or Semrush.

### SEO keyword cluster

website traffic checker, domain authority checker, similarweb alternative, seo similarweb
alternative, competitor traffic analysis, website traffic api, domain authority api, seo data api,
bulk domain authority checker, domain rank checker, website authority checker, estimated search
traffic, organic traffic checker, domain overview tool, competitor website analysis, check website
traffic, dr checker, da checker, bulk website traffic checker, domain intelligence, referring
domains checker, link prospect qualification, seo competitor analysis tool, ahrefs alternative,
moz alternative, semrush alternative, pay per use seo tool, mcp seo tool, mcp server, mcp actor,
model context protocol, seo api without subscription, apify mcp server.

# Actor input Schema

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

Up to 1000 domains (paid Apify plans). Paste bare domains or full URLs — each is normalized (protocol / www. / path stripped, lowercased) and deduplicated before any paid call. FREE PLAN: limited to 10 domains per run, overview module only; the actor exits early with an upgrade prompt above the limit. Traffic figures are estimated SEARCH traffic (organic rankings × keyword volume × CTR), not total site visits.

## `location` (type: `string`):

Search market the metrics are computed in. Pick from the list of supported markets (92 countries). Default: United States.

## `language` (type: `string`):

Language of the market. Pick a language actually spoken in the chosen market (e.g. Germany + German, Poland + Polish) — mismatched pairs return little or no data. Default: English.

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

Add each domain's strongest pages (top 10 by estimated search traffic, with per-page keyword counts) to its row. Extra per-domain fee (see README pricing); charged only for domains where pages are actually delivered. Paid Apify plans only. Default false.

## `includeBacklinkSummary` (type: `boolean`):

Add referring-domain and total-backlink COUNTS plus a backlink-derived authority rank (domain\_rank, 0–1000 scale, higher = stronger) and spam score to each row. Counts only — for the full link list use our Backlink Checker actor. Extra per-domain fee (see README pricing); charged only for domains where the summary is actually delivered. Paid Apify plans only. Default false.

## `bypassRunCache` (type: `boolean`):

Skip the 24h KV Store run-cache and re-query the upstream APIs live. You will be charged the per-domain fees again. Default false.

## Actor input object example

```json
{
  "domains": [
    "monday.com",
    "notion.so",
    "airtable.com"
  ],
  "location": "United States",
  "language": "English",
  "includeTopPages": false,
  "includeBacklinkSummary": false,
  "bypassRunCache": false
}
```

# Actor output Schema

## `domainOverview` (type: `string`):

Default dataset link. See dataset\_schema.json for per-field documentation.

# 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": [
        "monday.com",
        "notion.so",
        "airtable.com"
    ],
    "location": "United States",
    "language": "English"
};

// Run the Actor and wait for it to finish
const run = await client.actor("doesaiknow/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": [
        "monday.com",
        "notion.so",
        "airtable.com",
    ],
    "location": "United States",
    "language": "English",
}

# Run the Actor and wait for it to finish
run = client.actor("doesaiknow/domain-authority-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "monday.com",
    "notion.so",
    "airtable.com"
  ],
  "location": "United States",
  "language": "English"
}' |
apify call doesaiknow/domain-authority-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=doesaiknow/domain-authority-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Traffic & Domain Authority - SEO Similarweb Alternative",
        "description": "Bulk website traffic & domain authority checker: one row per domain — estimated search traffic, organic keyword counts, plus opt-in authority rank, top pages & referring-domain counts. Pay-per-use SEO Similarweb / Ahrefs DR / Moz DA alternative — no subscription. From $0.10/domain, free tier.",
        "version": "0.1",
        "x-build-id": "yXuaApeVcjcg1UZyk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/doesaiknow~domain-authority-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-doesaiknow-domain-authority-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/doesaiknow~domain-authority-checker/runs": {
            "post": {
                "operationId": "runs-sync-doesaiknow-domain-authority-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/doesaiknow~domain-authority-checker/run-sync": {
            "post": {
                "operationId": "run-sync-doesaiknow-domain-authority-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Up to 1000 domains (paid Apify plans). Paste bare domains or full URLs — each is normalized (protocol / www. / path stripped, lowercased) and deduplicated before any paid call. FREE PLAN: limited to 10 domains per run, overview module only; the actor exits early with an upgrade prompt above the limit. Traffic figures are estimated SEARCH traffic (organic rankings × keyword volume × CTR), not total site visits.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 250
                        }
                    },
                    "location": {
                        "title": "Country / location",
                        "enum": [
                            "Albania",
                            "Algeria",
                            "Angola",
                            "Argentina",
                            "Armenia",
                            "Australia",
                            "Austria",
                            "Azerbaijan",
                            "Bahrain",
                            "Bangladesh",
                            "Belgium",
                            "Bolivia",
                            "Bosnia and Herzegovina",
                            "Brazil",
                            "Bulgaria",
                            "Burkina Faso",
                            "Cambodia",
                            "Cameroon",
                            "Canada",
                            "Chile",
                            "Colombia",
                            "Costa Rica",
                            "Cote d'Ivoire",
                            "Croatia",
                            "Cyprus",
                            "Czechia",
                            "Denmark",
                            "Ecuador",
                            "Egypt",
                            "El Salvador",
                            "Estonia",
                            "Finland",
                            "France",
                            "Germany",
                            "Ghana",
                            "Greece",
                            "Guatemala",
                            "Hungary",
                            "India",
                            "Indonesia",
                            "Ireland",
                            "Israel",
                            "Italy",
                            "Japan",
                            "Jordan",
                            "Kazakhstan",
                            "Kenya",
                            "Latvia",
                            "Lithuania",
                            "Malaysia",
                            "Malta",
                            "Mexico",
                            "Moldova",
                            "Monaco",
                            "Morocco",
                            "Myanmar (Burma)",
                            "Netherlands",
                            "New Zealand",
                            "Nicaragua",
                            "Nigeria",
                            "North Macedonia",
                            "Norway",
                            "Pakistan",
                            "Panama",
                            "Paraguay",
                            "Peru",
                            "Philippines",
                            "Poland",
                            "Portugal",
                            "Romania",
                            "Saudi Arabia",
                            "Senegal",
                            "Serbia",
                            "Singapore",
                            "Slovakia",
                            "Slovenia",
                            "South Africa",
                            "South Korea",
                            "Spain",
                            "Sri Lanka",
                            "Sweden",
                            "Switzerland",
                            "Thailand",
                            "Tunisia",
                            "Turkiye",
                            "Ukraine",
                            "United Arab Emirates",
                            "United Kingdom",
                            "United States",
                            "Uruguay",
                            "Venezuela",
                            "Vietnam"
                        ],
                        "type": "string",
                        "description": "Search market the metrics are computed in. Pick from the list of supported markets (92 countries). Default: United States.",
                        "default": "United States"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "Albanian",
                            "Arabic",
                            "Armenian",
                            "Azeri",
                            "Bengali",
                            "Bosnian",
                            "Bulgarian",
                            "Chinese (Simplified)",
                            "Chinese (Traditional)",
                            "Croatian",
                            "Czech",
                            "Danish",
                            "Dutch",
                            "English",
                            "Estonian",
                            "Finnish",
                            "French",
                            "German",
                            "Greek",
                            "Hebrew",
                            "Hindi",
                            "Hungarian",
                            "Indonesian",
                            "Italian",
                            "Japanese",
                            "Korean",
                            "Latvian",
                            "Lithuanian",
                            "Macedonian",
                            "Malay",
                            "Norwegian (Bokmål)",
                            "Polish",
                            "Portuguese",
                            "Romanian",
                            "Russian",
                            "Serbian",
                            "Slovak",
                            "Slovenian",
                            "Spanish",
                            "Swedish",
                            "Tagalog",
                            "Thai",
                            "Turkish",
                            "Ukrainian",
                            "Urdu",
                            "Vietnamese"
                        ],
                        "type": "string",
                        "description": "Language of the market. Pick a language actually spoken in the chosen market (e.g. Germany + German, Poland + Polish) — mismatched pairs return little or no data. Default: English.",
                        "default": "English"
                    },
                    "includeTopPages": {
                        "title": "Add-on: top pages",
                        "type": "boolean",
                        "description": "Add each domain's strongest pages (top 10 by estimated search traffic, with per-page keyword counts) to its row. Extra per-domain fee (see README pricing); charged only for domains where pages are actually delivered. Paid Apify plans only. Default false.",
                        "default": false
                    },
                    "includeBacklinkSummary": {
                        "title": "Add-on: backlink summary",
                        "type": "boolean",
                        "description": "Add referring-domain and total-backlink COUNTS plus a backlink-derived authority rank (domain_rank, 0–1000 scale, higher = stronger) and spam score to each row. Counts only — for the full link list use our Backlink Checker actor. Extra per-domain fee (see README pricing); charged only for domains where the summary is actually delivered. Paid Apify plans only. Default false.",
                        "default": false
                    },
                    "bypassRunCache": {
                        "title": "Bypass 24h run-cache",
                        "type": "boolean",
                        "description": "Skip the 24h KV Store run-cache and re-query the upstream APIs live. You will be charged the per-domain fees again. Default false.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
