Expiring Domains Finder — Expired Domain List & SEO

Get ready-to-use lists of expiring and recently expired domains, filtered by expiration date, TLD, keywords, backlinks, referring domains and organic traffic, with WHOIS dates and registrar for every domain, as a one-off list or a daily feed of only new domains.

Why this Actor

• $2.15 per 1,000 domains, including the list request fee. No subscription, no login, no API key. Apify platform usage is billed separately by Apify (usually $0.001–$0.005 for a small run).
• Large lists: up to 1,000 domains per request and up to 100,000 domains per run.
• 29 fields per domain: stable id, expiration, creation and update dates, days left, domain age, registrar, status codes, backlinks, dofollow links, referring domains, organic keywords, organic traffic and its dollar value, paid search metrics, and a transparent domainScore (0–100) (plus 24 optional ranking-distribution columns).
• Filters built for domain investors and SEOs: expiring within N days or any date range, TLDs, several keywords at once (any may match; contains / starts / ends / exact / regex), no hyphens, maximum name length, minimum age, minimum referring domains, backlinks and traffic, and a minimum domain score. Sort by domain score too.
• Daily monitoring built in: turn on Only new domains since the last run and schedule it. Each domain is delivered once per search; repeats are skipped and cost only $0.0015 each (less than a delivered domain).
• Full expert control: raw filters with and / or nesting on every database field, up to 3 sort rules, and a start offset.
• Not included: registrant contact details, auction or backorder prices, live availability checks and third-party authority scores (see Not included).

Compared with alternatives

Typical run: 1,000 domains. Prices from public Apify Store listings, checked September 2026 (Free plan; our price is the same on every plan). For this Actor, Apify platform usage is billed separately by Apify on top of the price shown (at the default 256 MB a small run typically uses about $0.001–$0.005).

Option	Price for 1,000 domains	Still-registered domains expiring in a date window	Organic traffic and keywords per domain	Only-new-domains mode
Most-used expired-domain list scraper on the Store (~300 users)	$3.08 ($0.09 start + $0.00299 per row) plus platform usage you pay separately	Partly (whatever lists the scraped listing site shows)	✗ (backlinks, popularity, rank)	✗
Free community expired-domain finder (~76 users)	$0 Actor fee, you pay platform usage and proxies	✗ (days since expiry only)	✗ (backlinks, referring domains, archive history)	✗
Expired-domain marketplace aggregator API (~13 users)	$0.17, cheaper than us: its only listed charge is a $0.017 start fee per run, and one run returns one page of up to 100 domains (max 5,000 per search), so 1,000 domains = 10 runs	Partly (names already listed at auction or backorder)	Third-party visit estimates	Not documented
Dropped-names daily feed (~12 users)	$1.20 ($0.0012 per row; $0.50 on Gold), cheaper than us	✗ (dropped names)	✗ (not documented)	✓ (daily deduplicated feed)
This Actor	$2.15 ($0.16 per list request + $0.00199 per domain) plus platform usage billed separately by Apify	✓ any past or future window, still registered or expired	✓ organic and paid keywords, traffic and traffic value	✓ repeats skipped ($0.0015 each)

Small runs: our $0.16 list-request fee is charged once per request, so runs of fewer than about 160 domains cost more per domain than the most-used scraper's $0.00299 per row (100 domains: $0.36 here, i.e. $0.0036 per domain), and below about 70 domains we are more expensive even after its $0.09 start fee. From about 160 domains up we are cheaper per domain.

The two cheaper options cover different inventory. The aggregator lists names that are already on auction, backorder or dropped, with third-party authority scores and archive history, which we do not provide. The daily feed gives dropped domain names without link or traffic metrics. What you get here for the extra cost is the list of domains before they expire, filtered and sorted by our own link and Google traffic data, with WHOIS dates and a scheduled feed of only new domains.

What data you get

One row per domain.

Field	Type	Example
id	string	d8ecef93d64672f5 (stable: hash of domain + expiration date)
position	integer	1 (position in the sorted list)
domain	string	harborviewbakery.com
tld	string	com
name	string	harborviewbakery
expiresAt	ISO date	2026-10-12T17:22:41.000Z
daysUntilExpiration	integer	14 (negative = already expired)
isRegistered	boolean	true (false = registration expired / dropped)
createdAt	ISO date	2011-10-12T17:22:41.000Z
domainAgeYears	number	15
domainScore	integer	73 (0–100, calculated by the Actor, see Domain score)
lastChangedAt	ISO date	2025-10-13T08:14:02.000Z
whoisUpdatedAt	ISO date	2026-09-20T04:31:10.000Z
firstSeenAt	ISO date	2020-10-07T00:00:00.000Z
registrar	string	GoDaddy.com, LLC
statusCodes	array	["client_transfer_prohibited"]
referringDomains	integer	214
referringMainDomains	integer	187
referringPages	integer	2911
backlinks	integer	3870
dofollowBacklinks	integer	2645
backlinksUpdatedAt	ISO date	2026-09-04T18:57:50.000Z
organicKeywords	integer	1180 (keywords ranking in Google)
organicTraffic	number	420 (estimated monthly visits)
organicTrafficValue	number	612.88 (USD, what that traffic would cost as ads)
paidKeywords / paidTraffic / paidTrafficValue	number	0
organicPos1 … organicPos91to100, paidPos1 … paidPos91to100	integer	only with includeRankingDistribution
scrapedAt	ISO date	2026-09-28T15:51:53.371Z

A RUN_SUMMARY record in the key-value store lists the filters and sort rules applied, the number of domains matching the filters in total, pages charged, domains checked and saved, how many domains were skipped for a low domain score (domainsBelowScore), and (with Only new domains) how many domains were already known and skipped (repeatsSkipped, repeatChecksCharged).

Domain score

domainScore is a simple, fully documented 0–100 score calculated by the Actor from four columns of the same row. It is not a third-party authority metric; use it to rank a list quickly, then check the raw columns.

domainScore = round( 40 × part(referringDomains, 1,000)
                   + 20 × part(backlinks, 100,000)
                   + 25 × part(organicTraffic, 10,000)
                   + 15 × min(domainAgeYears / 20, 1) )

part(value, cap) = min( log10(1 + value) / log10(1 + cap), 1 )      missing values count as 0

Links and traffic grow over several orders of magnitude, so each tenfold increase adds the same number of points until the cap (1,000 referring domains, 100,000 backlinks, 10,000 monthly visits, 20 years) gives the full share.

Referring domains	Backlinks	Organic traffic	Age (years)	domainScore
5	20	0	3	18
30	300	50	12	49
100	1,000	100	10	59
1,000+	100,000+	10,000+	20+	100

• Filter: Minimum domain score (minDomainScore, 0–100). The score is calculated after the data is fetched, so it does not use one of the 8 filter conditions. Domains below it are skipped, and because they were fetched and checked for you, each one costs $0.0018 (score-check event); every list request pays the $0.16 request fee, even if no domain passes. Without a minimum score this fee is never charged. To keep checks cheap, combine it with a database minimum such as Minimum referring domains so fewer weak domains have to be checked, and keep the default sort by referring domains. RUN_SUMMARY.domainsBelowScore shows how many domains were skipped.
• Sort: Sort by = Domain score. The database picks the domains by referring domains (the largest part of the score), then the Actor re-orders the whole list by score in the chosen direction and numbers position in that order. Up to 10,000 domains per run with this sort.
• In raw filters and additional sort rules, use the underlying columns (referringDomains, backlinks, organicTraffic, createdAt).

How to use

1. Open the Actor in Apify Console and click Try for free.
2. Set Expiring within (days) (default 30), the TLDs you want and optionally one or more Keywords in domain (a domain matches if it contains any of them; leave empty for all names).
3. Set Maximum domains (default 100).
4. Optional: open Advanced: SEO quality filters and set e.g. Minimum referring domains = 20.
5. For a daily feed: open Scheduled monitoring, tick Only new domains since the last run, then save the task and add a schedule (see Daily monitoring).
6. Click Start. Download the list as CSV, Excel or JSON, or use the Expiring domains table view.

Ready-to-paste input:

{
    "expiringWithinDays": 30,
    "tlds": ["com", "net", "org"],
    "keywords": ["shop", "store"],
    "maxResults": 1000,
    "minReferringDomains": 20,
    "excludeHyphens": true,
    "sortBy": "referringDomains",
    "sortDirection": "desc"
}

API (curl):

curl -X POST "https://api.apify.com/v2/acts/cheapapi~expiring-domains-finder/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"expiringWithinDays": 30, "tlds": ["com"], "maxResults": 1000, "minReferringDomains": 20}'

JavaScript (apify-client):

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_TOKEN>' });
const run = await client.actor('cheapapi/expiring-domains-finder').call({
    expiringWithinDays: 30,
    tlds: ['com'],
    maxResults: 1000,
    minReferringDomains: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python (apify-client):

from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("cheapapi/expiring-domains-finder").call(run_input={
    "expiringWithinDays": 30,
    "tlds": ["com"],
    "maxResults": 1000,
    "minReferringDomains": 20,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["domain"], item["expiresAt"], item["referringDomains"])

Use cases

• Domain investing: shortlist aged, short, hyphen-free .com names that expire in the next weeks, before they reach auction or drop.
• Expired domains for SEO: find domains with many referring domains and remaining organic traffic for 301 redirects or site rebuilds.
• Backorder planning: export daily lists of domains expiring tomorrow in your target TLDs and feed them to your backorder workflow.
• Brand monitoring: find expiring domains that contain any of your brand or product names (list them all in Keywords in domain).
• Daily "new expiring domains" feed: schedule the Actor with Only new domains on and get only the domains you have not seen yet, straight into Google Sheets or Slack.
• Lead generation: reach out to owners of valuable domains about to expire (e.g. for agencies and registrars).
• Market research: analyse registrars, TLDs and domain ages of expiring inventory.

Advanced options

Input	Default	Meaning
minReferringDomains	–	Only domains with at least this many referring domains (0–1,000,000).
minBacklinks	–	Minimum total backlinks (0–1,000,000,000).
minDofollowBacklinks	–	Minimum dofollow backlinks (0–1,000,000,000).
minReferringMainDomains	–	Minimum referring root domains (0–1,000,000).
minOrganicTraffic	–	Minimum estimated monthly organic visits (0–1,000,000,000).
minOrganicKeywords	–	Minimum number of ranking keywords (0–100,000,000).
minOrganicTrafficValue	–	Minimum monthly traffic value in USD (0–1,000,000,000).
minDomainScore	–	Minimum domainScore (0–100). Applied by the Actor after fetching; each skipped domain costs $0.0018; does not count toward the 8 conditions.
expiresFrom / expiresTo	–	Custom expiration range (2026-10-31, -30 days, +90 days, today). Replaces Expiring within. A past range finds recently expired domains.
registrationStatus	any	registered (still active) or expired (registration ended, recently dropped).
minDomainAgeYears	–	Only domains created at least N years ago.
keywords	[]	Simple section. Empty = all domain names. Otherwise the domain must contain at least one of these texts (OR). Letters, digits, hyphens, dots; up to 50.
keywordMatch	contains	How keywords match: contains, startsWith, endsWith (name ends with it), exact (name equals it, any TLD), regex (each keyword is a pattern).
excludeKeywords	[]	Skip domains containing any of these texts.
excludeHyphens	false	Skip domains with a hyphen.
maxNameLength	–	Maximum length of the name before the first dot.
registrar	–	Registrar name contains this text (2–100 characters).
onlyNewDomains	false	Skip domains this search already delivered in an earlier run. Each skipped repeat costs $0.0015; every list request costs $0.16 even if nothing new is found.
monitoringName	–	Optional name for the delivered-domains history (letters, digits, spaces, ., -, _). Empty = one history per filter set.
maxScannedDomains	auto: with onlyNewDomains 200 (or maxResults if higher, a protective default); with only minDomainScore 2 × maxResults, min 1,000	With onlyNewDomains or minDomainScore: how many domains of the sorted list are checked at most to find ones to deliver (100–100,000). With a minimum score it also caps the score-check fees.
sortBy / sortDirection	referringDomains / desc	Main sort: referring domains, domain score (re-ordered by the Actor, max 10,000 domains), backlinks, dofollow backlinks, referring root domains, referring pages, organic traffic, organic keywords, traffic value, expiration date, creation date, first seen, last changed, domain name, or none.
additionalSortRules	[]	Up to 2 tie-breakers as "field,direction", e.g. "expiresAt,asc".
startOffset	0	Skip the first N domains of the sorted list (max 10,000).
rawFilters	–	Expert conditions on any output field, e.g. [["organicTraffic", ">", 100], "or", ["referringDomains", ">=", 50]]. Operators: =, <>, <, <=, >, >=, in, not_in, like, not_like (% = any text), regex. Groups can be nested.
includeRankingDistribution	false	Adds 24 columns: keywords ranking in positions 1, 2–3, 4–10 … 91–100 (organic and paid).

A run can combine at most 8 filter conditions (the date window counts as 2; the TLD list, each keyword, each exclusion, each minimum and each raw condition count as 1). Keywords are combined with OR; when they do not all fit, the Actor automatically merges them into one pattern (1 condition) and says so in the log. For anything else over the limit it tells you clearly which filters to remove.

Daily monitoring (only new domains)

1. Set your filters, tick Only new domains since the last run and save the input as a task.
2. In the task, click Schedule and choose e.g. daily at 06:00.
3. Every run returns only domains that this search has not delivered before. The first run returns the full list.

How it works:

• Repeats are not fetched at all. The Actor remembers how far earlier complete runs got and only asks for the part that is new:
  • Expiring windows (for example Expiring within 30 days, run daily): only domains whose expiration date falls after the end of the window already covered, which is the newly added day. The first run (no history yet) fetches the full window.
  • Recently expired windows (a past date range or Registration status: expired): only domains whose registration record changed since the last complete run. This uses one of the 8 filter conditions; if none is free, the full window is fetched and repeats are skipped instead.
  • A one-hour overlap catches boundary cases. The few domains in that overlap are removed by the list of domains already delivered, so they are never delivered twice (each costs only the $0.0015 repeat check).
• The list of domains already delivered is saved after every page in a named key-value store, expiring-domains-monitor, in your own Apify account. The history is kept per filter set as you wrote it, so a relative window keeps its history even though its dates move every day. Changing a filter starts a new history. Set monitoringName to share one list of delivered domains across filter changes or to run several independent feeds; the "already covered" point is still kept separately for each filter set.
• Request size: when many domains are repeats, the Actor asks for more domains per request, but never more than the domains still needed plus the few extra that request's own fees cover (about 6 + a third of the domains still needed). A generous Maximum domains therefore means fewer list requests.
• What counts as a complete run: the list ended, or the run stopped at Maximum domains. If a run stops at Maximum domains, the rest of that window is not revisited; raise Maximum domains or sort by expiration date ascending (then the next run continues from the last expiration date checked). Runs stopped by the maximum cost or by Maximum domains to check (a safety cap) do not move the covered point, so nothing is lost.
• A domain that has not appeared in any run for 120 days is forgotten, so a domain that is renewed and expires again a year later is reported again.
• RUN_SUMMARY.onlyNewDomains shows the window actually fetched (fetchedWindow), the covered point after the run (coveredAfterRun), and the new and skipped counts.

A one-day slice also works well for large feeds, for example:

{
    "expiresFrom": "+30 days",
    "expiresTo": "+30 days",
    "tlds": ["com", "net"],
    "minReferringDomains": 10,
    "maxResults": 5000,
    "onlyNewDomains": true
}

Output example

Example output: one row of a list of .com domains expiring within 30 days (the same row as in the field table above).

{
    "id": "d8ecef93d64672f5",
    "position": 1,
    "domain": "harborviewbakery.com",
    "tld": "com",
    "name": "harborviewbakery",
    "expiresAt": "2026-10-12T17:22:41.000Z",
    "daysUntilExpiration": 14,
    "isRegistered": true,
    "createdAt": "2011-10-12T17:22:41.000Z",
    "domainAgeYears": 15,
    "domainScore": 73,
    "lastChangedAt": "2025-10-13T08:14:02.000Z",
    "whoisUpdatedAt": "2026-09-20T04:31:10.000Z",
    "firstSeenAt": "2020-10-07T00:00:00.000Z",
    "registrar": "GoDaddy.com, LLC",
    "statusCodes": ["client_transfer_prohibited"],
    "referringDomains": 214,
    "referringMainDomains": 187,
    "referringPages": 2911,
    "backlinks": 3870,
    "dofollowBacklinks": 2645,
    "backlinksUpdatedAt": "2026-09-04T18:57:50.000Z",
    "organicKeywords": 1180,
    "organicTraffic": 420,
    "organicTrafficValue": 612.88,
    "paidKeywords": 0,
    "paidTraffic": 0,
    "paidTrafficValue": 0,
    "scrapedAt": "2026-09-28T15:51:53.371Z"
}

Pricing

Apify Free plan: Apify does not pay developers for usage on its Free plan, so on the Free plan this Actor can be used for up to $0.25 of results per calendar month — enough to try it on a small input. When the allowance is used up, the run ends with a clear message (not an error). Any paid Apify plan removes the limit; prices are the same.

Pay per event. You are charged per list request made, even if nothing (new) is found, because the domain database is queried either way; plus one fee per domain you receive. With Only new domains, domains delivered in an earlier run are skipped and cost $0.0015 each (they were fetched and checked for you), which is less than a delivered domain.

Event	Price (every plan)	When
Domain list request	$0.16	Once per list request made (up to 1,000 domains per request), even if it returns no domain or nothing new
Domain	$0.00199	Per delivered domain
Domain checked for minimum score	$0.0018	Only with Minimum domain score: per fetched domain skipped because it is below your minimum. With default settings only in the rare case described below (a request that got no answer).
Already-delivered domain skipped	$0.0015	Only with Only new domains (or a repeat inside a run sorted by domain score): per fetched domain skipped because it was delivered before. Never charged with default settings.

1,000 domains = $0.16 + 1,000 × $0.00199 = $2.15.

The price is the same on every Apify plan (Free, Bronze, Silver, Gold, Platinum and Diamond). There is no start fee and no subscription. Apify platform usage is billed separately by Apify (at the default 256 MB a small run typically uses about $0.001–$0.005); the prices and examples on this page are event fees only. The score-check and repeat-check fees exist because those domains are fetched and checked before they are skipped; with default settings they are never charged. A search that matches nothing still costs one list request ($0.16).

Worked examples:

• 100 domains expiring this month: $0.16 + 100 × $0.00199 = $0.36.
• 1,000 domains: $0.16 + 1,000 × $0.00199 = $2.15.
• 10,000 domains (10 list requests): 10 × $0.16 + 10,000 × $0.00199 = $21.50.
• Top 500 by domain score (sortBy: "domainScore", 500 domains, one list request): $0.16 + 500 × $0.00199 = $1.16.
• 500 domains with minDomainScore: 50, when about half of the checked domains pass (about 1,000 checked in 3 list requests): 3 × $0.16 + 500 × $0.0018 + 500 × $0.00199 = $2.38. Without the minimum score, 500 domains cost $1.16.
• Daily monitoring, 150 new domains per day on average and 20 overlapping repeats skipped (one list request per run): $0.16 + 150 × $0.00199 + 20 × $0.0015 = $0.49 per day, about $14.66 per month (30 days) (plus platform usage).
• Daily monitoring on a day with nothing new (one list request returns 40 domains, all delivered before): $0.16 + 40 × $0.0015 = $0.22.
• A search that matches nothing: one list request = $0.16.

Set Maximum cost per run on the run to cap spending. The Actor only requests as many domains as your budget covers and stops cleanly.

Integrations

• Scheduling / monitoring: run it every morning with Only new domains on and get only the domains you have not seen yet (Apify Schedules).
• API and MCP: start runs and read results from your own code with the Apify API or apify-client, or let an AI agent call the Actor through the Apify MCP server.
• Google Sheets, Make, Zapier, n8n: send the dataset to a sheet or your CRM with the ready-made Apify integrations.
• Webhooks: get notified when a run finishes and fetch the dataset via API.
• Exports: CSV, Excel, JSON, XML, RSS from the dataset.

FAQ

Is there a limit on the Apify Free plan? Yes: up to $0.25 of this Actor's results per calendar month, enough to try it. Apify pays developers nothing for Free-plan usage while our data costs are real, so this keeps the Actor sustainable. Runs that reach the allowance stop cleanly and keep everything collected so far; the allowance resets on the 1st of the month. Any paid Apify plan has no limit.

Is it legal? The Actor returns public domain registration data (WHOIS dates, registrar, status) and aggregated SEO metrics. It contains no personal registrant contact data. Always follow the rules of the registries and marketplaces you buy from.

Is Apify platform usage included? No. Apify platform usage (compute) is billed separately by Apify, on top of the event fees. At the default 256 MB memory a small run typically uses about $0.001–$0.005; very large runs use more. Each run's usage is shown in Apify Console.

How fresh is the data? The domain database is updated continuously. Registration data shows its last update in whoisUpdatedAt, backlink metrics in backlinksUpdatedAt. Expiration dates can change when an owner renews, so check availability at your registrar before buying.

Why did I get fewer results than "Maximum domains"? Fewer domains match your filters (see totalMatchingDomains in RUN_SUMMARY), your maximum cost per run was reached, or, with Only new domains, most matching domains were already delivered earlier (see repeatsSkipped in RUN_SUMMARY). Widen the date window, add TLDs or keywords, or lower the minimums.

How do I get only new domains every day? Tick Only new domains since the last run, save the input as a task and add a daily schedule. See Daily monitoring. Repeats are skipped and cost $0.0015 each; each list request costs $0.16 even if nothing new is found.

How do I control my budget? Set Maximum cost per run when starting the run or in the task. The Actor only requests as many domains as the budget covers, stops cleanly and records stoppedByBudget: true in RUN_SUMMARY.

What is the difference between "expiring" and "expired"? Expiring domains are still registered and have an expiration date in your window. Expired domains (registrationStatus: "expired") had their registration end; they stay in the database only for a short time after dropping.

Does an expiring domain become available? Not necessarily. Many owners renew at the last minute, and many registrars keep domains in a grace or auction period (see statusCodes). Treat the list as candidates to monitor or backorder.

Which export formats are available? JSON, CSV, Excel, XML, RSS and HTML from the dataset, in the Console or via the API. The table views Expiring domains, SEO metrics and Registration details export only their columns.

How do I get more than 10,000 domains, and which fields can I sort and filter on? Set maxResults up to 100,000; the Actor pages through the list automatically (startOffset, max 10,000, is only for skipping the start). Every database field can be used in sorting and raw filters, with the same names as in the output. Columns the Actor calculates itself (domainScore, id, position, name, daysUntilExpiration, domainAgeYears) are not database fields; filter and sort by domainScore with Minimum domain score and Sort by: Domain score.

What does a scheduled "only new" run cost when nothing is new? With the defaults (Maximum domains 100, Maximum domains to check left empty = 200), at most 200 domains are checked: 2 list requests × $0.16 + 200 × $0.0015 = $0.62 on every plan. Set Maximum domains to check yourself to allow more (each extra 1,000 checked domains adds about $1.50 plus list requests), or set Maximum cost per run as a hard cap.

Why was I charged when a request failed with "Network problem"? Very rarely a list request gets no answer although the database may already have processed (and billed) it, including every requested domain. It is never resent (that could bill it twice); instead it is charged like an answered request that delivered nothing: $0.16 plus $0.0015 per requested domain (at most $1.66 for a 1,000-domain request, always within your maximum cost per run). RUN_SUMMARY shows unansweredRequestsCharged.

Why was I charged $0.16 when I got no domains (or no new ones)? Every list request queries the domain database, which costs us money whether or not something matches, so each list request made is charged ($0.16), even if nothing (new) is found. With Only new domains, each fetched domain that was already delivered costs $0.0015. Example: a scheduled run whose request returns 40 domains, all delivered before, costs $0.16 + 40 × $0.0015 = $0.22. RUN_SUMMARY shows pagesCharged, repeatsSkipped and repeatChecksCharged. To keep this low, schedule less often or use a narrower window.

Why does "Minimum domain score" cost extra? The score is calculated from the fetched data, so domains below your minimum have to be fetched and checked before they can be skipped. Each of them costs $0.0018, less than a delivered domain ($0.00199). Database minimums such as Minimum referring domains are free and filter before fetching, so use them first and add the score on top. Set Maximum cost per run or Maximum domains to check to cap spending.

How is the domain score calculated, and can I trust it? It is a fixed formula of four output columns, shown in Domain score, so you can recompute it in a spreadsheet. It ranks link, traffic and age signals together; it does not check spam, topic relevance or link quality, so review the top domains before buying.

Do I need an API key, and where do I get help? No key or account elsewhere, only your Apify account. For questions, bugs or feature requests, open an issue on the Actor's Issues tab.

Not included

• Registrant contact details (names, emails, phones): not collected, for privacy reasons.
• Auction, backorder or buy-now prices and live availability checks at a registrar: the list shows registration data and status codes; check availability at your registrar before buying.
• Third-party authority scores (for example domain rating or trust flow style metrics) and archive history: domainScore is our own documented formula instead.
• The full backlink list of a domain: use Backlink Checker.
• A detailed SEO profile of one domain (ranked keywords, competitors, traffic history): use Domain SEO Analyzer.
• Keyword ideas and search volumes for naming a domain: use Keyword Research Tool.
• Who ranks in Google for a term (to judge a niche): use Google SERP Scraper.

Limitations

• domainScore is calculated after fetching: Minimum domain score charges $0.0018 per skipped domain and can reach Maximum domains to check before the list is full, and Sort by: Domain score allows at most 10,000 domains per run.
• At most 8 filter conditions and 3 sort rules per run; startOffset max 10,000; maxResults max 100,000 per run.
• The database does not contain every registered domain; coverage is best for domains that have some web presence (links or rankings). Brand-new domains without any footprint may be missing.
• Expired domains stay in the database only briefly after they drop, so date ranges far in the past return few rows.
• Traffic and keyword numbers are estimates for Google; backlink metrics are from our own link index and differ from other SEO tools.
• Expiration dates reflect the last registration update and may already be renewed at the registry.
• No single-domain WHOIS lookups: the Actor is built for filtered lists of many domains.
• Only new domains remembers domains per Apify account and per filter set (or monitoring name). Deleting the expiring-domains-monitor store resets it. Only domains that newly enter the window (or, for recently expired windows, whose registration record changes) are fetched; a domain added to the database later with an expiration date in an already covered range is not picked up. maxScannedDomains caps how many domains one run checks (default 200 with Only new domains, so a run with nothing new costs at most about $0.62 with default settings).
• The list request fee ($0.16) applies to every list request made, even one that returns nothing (new), so very small lists cost more per domain.

Privacy and personal data

The output contains domain-level data only: registration dates, registrar, status codes and SEO metrics. It contains no registrant names, emails, phone numbers or addresses. If you combine the list with other sources to contact domain owners, you are responsible for complying with GDPR, CAN-SPAM and similar laws.