# Expiring Domains Finder: Expired Domain List and SEO

> Expiring Domains Finder is an Apify actor (API) by CheapAPI Labs. Expiring and expired domains by date, ending and keyword, with backlinks and traffic. A daily feed of only new ones. It costs $1.99 per 1,000 domains on every Apify plan, plus $0.16 per domain list request, billed through your Apify account with no API key. Compared with the most used expired domain list scraper on Apify Store (about 300 users): 1,000 domains costs $2.15 here and $3.08 there (Apify Store listing prices, checked September 2026). Apify platform usage is billed on top here.

- Page: https://cheapapilabs.com/actors/expiring-domains-finder/
- Run on Apify: https://apify.com/cheapapi/expiring-domains-finder
- Publisher: CheapAPI Labs (Apify username cheapapi)
- Main price: $1.99 per 1,000 domains on Free, $1.99 on Gold
- Our prices updated: 2026-10-30

## Prices per event (USD)

| Event | Free | Bronze | Silver | Gold |
|---|---:|---:|---:|---:|
| Domain list request | $0.16 | $0.16 | $0.16 | $0.16 |
| Domain | $0.00199 | $0.00199 | $0.00199 | $0.00199 |
| Domain checked for minimum score | $0.0018 | $0.0018 | $0.0018 | $0.0018 |
| Fetched domain not delivered | $0.0015 | $0.0015 | $0.0015 | $0.0015 |

Platinum and Diamond pay the Gold price. Apify platform usage: billed separately by Apify.

## Call it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/cheapapi~expiring-domains-finder/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"expiringWithinDays":30,"tlds":["com","net","org"],"maxResults":100}'
```

## Example output row

```json
{
  "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"
}
```

## Fields

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 to 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`).

## 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 to $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.

## 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](https://cheapapilabs.com/actors/backlink-checker/).
- **A detailed SEO profile of one domain** (ranked keywords, competitors, traffic history): use [Domain SEO Analyzer](https://cheapapilabs.com/actors/domain-seo-analyzer/).
- **Keyword ideas and search volumes** for naming a domain: use [Keyword Research Tool](https://cheapapilabs.com/actors/keyword-research-tool/).
- **Who ranks in Google for a term** (to judge a niche): use [Google SERP Scraper](https://cheapapilabs.com/actors/google-serp-scraper/).

## Limits

- `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.

## 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 to $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.