# Expired Domains Scraper - SEO Domain Data (`benthepythondev/expired-domains-scraper`) Actor

Scrape ExpiredDomains.net listing pages for domains, backlinks, archive age, related domains, drops and TLD status.

- **URL**: https://apify.com/benthepythondev/expired-domains-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** SEO tools, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Expired Domains Scraper - SEO Domain Leads

Scrape ExpiredDomains.net listing pages into structured SEO domain datasets. The actor extracts domain names, backlink counts, domain-pop metrics, Archive.org first-seen year, crawl counts, Dmoz status, registered TLD count, related domain count, dropped date, Whois status, and common TLD availability indicators. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the Expired Domains Scraper?

ExpiredDomains.net is a popular research site for people who buy domains, rebuild aged sites, evaluate backlink opportunities, monitor dropped domains, and find names for SEO projects or brand portfolios. Its tables are useful, but manually copying rows into a spreadsheet is slow. This actor turns the public listing table into clean rows that can be filtered, scored, exported, or enriched downstream.

The actor works with ExpiredDomains.net listing URLs such as deleted domains, expired domains, or filtered search pages. Paste the URL you care about and set a result limit. The engine uses direct HTTP and parses the server-rendered table, which keeps it fast, low-cost, and suitable for scheduled monitoring.

#### What data does it extract?

- Domain name
- Domain TLD
- Majestic backlink count
- Domain-pop count
- Archive.org first-seen year
- Archive.org crawl result count
- Dmoz field
- Number of registered related TLDs
- Related domain count
- Dropped date / drop signal
- Whois status text
- Common TLD status for .com, .net, .org and .de
- Source listing URL
- ExpiredDomains domain-search URL

### Input

| Field | Type | Description |
| --- | --- | --- |
| `urls` | array | ExpiredDomains.net listing URLs to scrape. |
| `maxResults` | integer | Maximum domains to return per listing URL. |

#### Example input

```json
{
  "urls": [
    "https://www.expireddomains.net/deleted-domains/"
  ],
  "maxResults": 50
}
````

Use ExpiredDomains.net filters in the browser first, then paste the resulting URL into `urls` to scrape that exact filtered page.

### Output

```json
{
  "domain": "exampledomain.com",
  "domain_tld": "com",
  "backlinks": 42,
  "domain_pop": 12,
  "archive_birth_year": 2018,
  "archive_crawl_results": 19,
  "dmoz": null,
  "registered_tlds": 3,
  "related_domains": 8,
  "dropped": "2026-07-07",
  "whois_status": "available",
  "tld_status": {
    ".com": ".com registered",
    ".net": ".net available"
  },
  "source_url": "https://www.expireddomains.net/deleted-domains/",
  "domain_search_url": "https://www.expireddomains.net/domain/exampledomain.com/",
  "source": "expireddomains.net"
}
```

### Use cases

- SEO domain research: find aged domains with backlinks and archive history.
- Domain investing: monitor deleted or expired names and export candidates.
- Lead generation: identify domains that may need rebuild, brokerage, hosting, or SEO services.
- Competitive research: collect filtered domain lists and rank them in your own workflow.

### Practical tips

Use ExpiredDomains.net's own filters first. For example, filter by TLD, backlink count, length, dictionary words, archive age, or dropped date in the browser, then paste the filtered URL into this actor. That gives you a focused dataset instead of a generic dump.

For domain investing workflows, export the results to CSV and sort by `backlinks`, `domain_pop`, `archive_birth_year`, and `registered_tlds`. For SEO workflows, treat these metrics as starting signals rather than final quality scores. Always review backlink quality, trademark risk, spam history, and live availability before buying or rebuilding a domain.

For agency and lead-gen workflows, use the dataset as a first-pass signal list. A dropped domain with history, related TLD activity, or multiple registered variants can point to an old business, brand, project, or niche site. Combine this output with WHOIS, contact discovery, archive screenshots, and search-result checks before outreach. The actor is not a replacement for domain due diligence; it is a fast way to turn a public research table into a pipeline you can score.

### Reliability and performance

The actor uses a direct HTTP request and parses the public table. It does not use a browser and does not require a login. If a URL fails, it logs the error and continues with the next listing URL. Keep `maxResults` modest for scheduled monitoring, then raise it for larger one-off exports.

The parser prefers stable table classes such as `field_domain`, `field_bl`, `field_domainpop`, `field_abirth`, and `field_changes` instead of relying on fragile column positions. That makes the actor more tolerant of optional columns, hidden menu links, and small layout changes on the listing page.

### FAQ

**Does it require an ExpiredDomains.net account?** No. It reads public listing pages.

**Can it scrape filtered searches?** Yes. Apply filters on ExpiredDomains.net and paste the resulting URL.

**Does it register domains?** No. It extracts research data only.

**Does it verify current availability?** It returns the status fields visible in the listing table. Verify availability with a registrar before purchase.

**Can I export to Excel?** Yes. Apify datasets export to JSON, CSV, Excel, XML, and RSS.

**Can I schedule monitoring?** Yes. Create a saved task and run it daily or weekly.

**Is it legal?** The actor reads public pages. You must follow website terms, rate limits, and applicable laws.

**How is billing calculated?** Pay-per-event billing charges per domain row pushed to the dataset.

**Can it scrape multiple pages?** Paste multiple listing URLs. Pagination can be added for custom high-volume workflows.

**Does it include backlinks themselves?** No. It extracts summary counts and related fields from the listing table.

### You might also like

- Domain Intelligence Scraper
- Website Contact Extractor
- Sitemap URL Extractor
- WHOIS Domain Intelligence
- Google Trends RSS Scraper

**Keywords:** expired domains scraper, ExpiredDomains.net scraper, deleted domains, domain leads, SEO domains, aged domains, backlink domain research, domain investing, dropped domains, domain pop, archive age, website flipping, SEO lead generation, Apify domain scraper, domain availability data

# Actor input Schema

## `urls` (type: `array`):

ExpiredDomains.net listing URLs to scrape, such as deleted domains, expired domains or filtered search pages.

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

Maximum number of domains to return per listing page.

## Actor input object example

```json
{
  "urls": [
    "https://www.expireddomains.net/deleted-domains/"
  ],
  "maxResults": 10
}
```

# 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 = {
    "urls": [
        "https://www.expireddomains.net/deleted-domains/"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/expired-domains-scraper").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 = {
    "urls": ["https://www.expireddomains.net/deleted-domains/"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/expired-domains-scraper").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 '{
  "urls": [
    "https://www.expireddomains.net/deleted-domains/"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/expired-domains-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Expired Domains Scraper - SEO Domain Data",
        "description": "Scrape ExpiredDomains.net listing pages for domains, backlinks, archive age, related domains, drops and TLD status.",
        "version": "1.0",
        "x-build-id": "ns1R4U5dBY237ejNE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~expired-domains-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-expired-domains-scraper",
                "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/benthepythondev~expired-domains-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-expired-domains-scraper",
                "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/benthepythondev~expired-domains-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-expired-domains-scraper",
                "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": {
                    "urls": {
                        "title": "ExpiredDomains URLs",
                        "type": "array",
                        "description": "ExpiredDomains.net listing URLs to scrape, such as deleted domains, expired domains or filtered search pages.",
                        "default": [
                            "https://www.expireddomains.net/deleted-domains/"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of domains to return per listing page.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
