# Expired Domain Finder with SEO Metrics (`constant_quadruped/expired-domain-finder`) Actor

Find expired and expiring domains enriched with WHOIS data, backlink counts, domain authority, and Wayback Machine history. Quality scored and ranked.

- **URL**: https://apify.com/constant\_quadruped/expired-domain-finder.md
- **Developed by:** [CQ](https://apify.com/constant_quadruped) (community)
- **Categories:** SEO tools, Lead generation, Automation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Expired Domain Finder with SEO Metrics

Find recently expired domains enriched with backlink counts, domain popularity scores, Wayback Machine archive history, spam detection, and a quality score with BUY/WATCH/SKIP recommendations.

### What it does

This actor scrapes [ExpiredDomains.net](https://www.expireddomains.net) for domains that have recently expired or are about to drop, then enriches each domain with additional metrics to help domain investors make buy decisions.

Per domain, you get:

- **Basic info**: domain name, TLD, expiry date, age, previous registrar
- **SEO metrics**: backlink count, referring domains (domain popularity), archive snapshot count
- **Historical context**: first and last Wayback Machine capture dates, last known page title
- **Risk signals**: spam indicator count (from keyword heuristics on domain name and title)
- **Scoring**: composite quality score (0-10) with BUY/WATCH/SKIP recommendation and rough estimated value

### When to use it

- **Domain investors** looking for aged domains with existing backlinks
- **SEO professionals** finding expired domains for 301 redirects or backlink recovery
- **Brand monitoring** watching for expired trademark variants
- **Content marketers** finding relevant expired domains in specific niches

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `tlds` | array | `["com"]` | TLDs to include (e.g., `["com","net","org"]`) |
| `minBacklinks` | integer | `5` | Minimum backlink count |
| `minDomainPopularity` | integer | `5` | Minimum referring domains |
| `maxAge` | integer | `7` | Max days since expiry (0 = no filter, 7 = last week, 30 = last month) |
| `maxDomainLength` | integer | `25` | Max domain name length (excl. TLD, 3-63) |
| `keywords` | string | — | Comma-separated keywords to filter (e.g., `"tech,blog,shop"`) |
| `maxResults` | integer | `100` | Max domains to return (1-1000) |
| `checkWayback` | boolean | `true` | Query Wayback Machine archive history (~0.5s/domain) |
| `proxyConfiguration` | object | Apify proxy | Proxy settings |

### Output format

Each result is stored in the dataset as a JSON object:

```json
{
  "domain": "scrantonrent.com",
  "tld": "com",
  "status": "expired",
  "expiryDate": "2026-04-14",
  "domainAge": "20 years",
  "registrar": null,
  "backlinks": 25,
  "referringDomains": 929,
  "domainAuthority": null,
  "archiveSnapshots": 83,
  "firstArchiveDate": "2006-02-08",
  "lastArchiveDate": "2025-07-13",
  "previousTitle": null,
  "spamIndicators": 0,
  "qualityScore": 7.4,
  "recommendation": "BUY",
  "estimatedValue": "$500-2,000"
}
````

### Quality scoring

The composite score (0-10) weighs:

- Backlink count (0-2 pts)
- Referring domains (0-2.5 pts)
- Archive snapshot history (0-2 pts)
- Domain age (0-1.5 pts)
- Name quality (length, no hyphens, 0-1.5 pts)
- Spam indicators (penalty, -0.5/indicator)

**Recommendations:**

- `BUY` — score ≥ 7 (strong signals, worth acquiring)
- `WATCH` — score 4-6.9 (moderate, keep an eye on it)
- `SKIP` — score < 4 (weak or spammy)

### Pricing model

Pay-per-result. Each enriched domain = 1 billable result.

### Notes and caveats

- **Source data** comes from the default ExpiredDomains.net feed (recently expired domains list). The feed refreshes daily.
- **No official API keys required.** Runs entirely via HTTP scraping + free Wayback Machine API.
- **Wayback Machine adds latency** — disable `checkWayback` for faster runs if history isn't needed.
- **Keyword filter scans up to 10x the requested page count** to find matches, since keyword-matching domains are rare in the daily feed.
- **Domain authority field is always null** in this version — integrating Moz/Ahrefs API is planned but requires paid keys.
- **`dist_` and location fields do not apply** — this is for domain metrics, not geographic fires.

### Example inputs

#### Quick BUY list

```json
{
  "tlds": ["com"],
  "minBacklinks": 100,
  "minDomainPopularity": 50,
  "maxResults": 20,
  "checkWayback": true
}
```

#### Niche filter

```json
{
  "tlds": ["com", "net"],
  "keywords": "tech,ai,saas",
  "minBacklinks": 10,
  "maxResults": 50,
  "maxAge": 30
}
```

#### Raw feed dump (no filters)

```json
{
  "tlds": ["com"],
  "minBacklinks": 0,
  "minDomainPopularity": 0,
  "maxAge": 0,
  "maxResults": 200,
  "checkWayback": false
}
```

### Version history

- **v1.7** — Keyword filter now scans 10x more pages when active (was missing matches)
- **v1.6** — Fixed metric extraction bug where BL showed inflated values (582M instead of 582)
- **v1.5** — Fixed HTML table parser to match actual ExpiredDomains.net structure
- **v1.4** — Added `maxAge` parameter for date-range filtering; server-side filters for BL/DP
- **v1.3** — Added multi-strategy HTML parsing (selectors + regex fallback)
- **v1.2** — Output schema integration with dataset views
- **v1.1** — Logo, metadata refinements
- **v1.0** — Initial release

# Actor input Schema

## `tlds` (type: `array`):

Domain extensions to include (e.g., 'com', 'net', 'org'). Leave empty for all.

## `minBacklinks` (type: `integer`):

Minimum number of backlinks required

## `minDomainPopularity` (type: `integer`):

Minimum domain popularity score (number of referring domains)

## `keywords` (type: `string`):

Only include domains containing these keywords (comma-separated, e.g., 'tech,blog,shop')

## `maxAge` (type: `integer`):

Only show domains that expired within this many days (e.g., 7 = last week, 30 = last month, 0 = no filter)

## `maxDomainLength` (type: `integer`):

Maximum domain name length (characters, excluding TLD)

## `maxResults` (type: `integer`):

Maximum number of domains to return

## `checkWayback` (type: `boolean`):

Query Wayback Machine for archive history (adds ~0.5s per domain)

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping ExpiredDomains.net

## Actor input object example

```json
{
  "tlds": [
    "com"
  ],
  "minBacklinks": 5,
  "minDomainPopularity": 5,
  "maxAge": 7,
  "maxDomainLength": 25,
  "maxResults": 100,
  "checkWayback": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `domains` (type: `string`):

Expired domains with SEO metrics, quality scores, and investment recommendations

# 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 = {
    "tlds": [
        "com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("constant_quadruped/expired-domain-finder").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 = {
    "tlds": ["com"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("constant_quadruped/expired-domain-finder").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 '{
  "tlds": [
    "com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call constant_quadruped/expired-domain-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Expired Domain Finder with SEO Metrics",
        "description": "Find expired and expiring domains enriched with WHOIS data, backlink counts, domain authority, and Wayback Machine history. Quality scored and ranked.",
        "version": "1.8",
        "x-build-id": "zIw6ZMclxeFxQcEpH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constant_quadruped~expired-domain-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constant_quadruped-expired-domain-finder",
                "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/constant_quadruped~expired-domain-finder/runs": {
            "post": {
                "operationId": "runs-sync-constant_quadruped-expired-domain-finder",
                "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/constant_quadruped~expired-domain-finder/run-sync": {
            "post": {
                "operationId": "run-sync-constant_quadruped-expired-domain-finder",
                "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",
                "properties": {
                    "tlds": {
                        "title": "TLD Filter",
                        "type": "array",
                        "description": "Domain extensions to include (e.g., 'com', 'net', 'org'). Leave empty for all.",
                        "default": [
                            "com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minBacklinks": {
                        "title": "Minimum Backlinks",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of backlinks required",
                        "default": 5
                    },
                    "minDomainPopularity": {
                        "title": "Minimum Domain Popularity",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum domain popularity score (number of referring domains)",
                        "default": 5
                    },
                    "keywords": {
                        "title": "Keyword Filter",
                        "type": "string",
                        "description": "Only include domains containing these keywords (comma-separated, e.g., 'tech,blog,shop')"
                    },
                    "maxAge": {
                        "title": "Max Days Since Expiry",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only show domains that expired within this many days (e.g., 7 = last week, 30 = last month, 0 = no filter)",
                        "default": 7
                    },
                    "maxDomainLength": {
                        "title": "Max Domain Length",
                        "minimum": 3,
                        "maximum": 63,
                        "type": "integer",
                        "description": "Maximum domain name length (characters, excluding TLD)",
                        "default": 25
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of domains to return",
                        "default": 100
                    },
                    "checkWayback": {
                        "title": "Check Wayback Machine",
                        "type": "boolean",
                        "description": "Query Wayback Machine for archive history (adds ~0.5s per domain)",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping ExpiredDomains.net"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```