# 🎯 Expired Domain Sniper - Daily Drops with Backlink History (`nogards95/domain-drop-monitor-scraper`) Actor

Get daily lists of expiring, pending-delete, and dropped domains. Filter by TLD, age, Wayback history, and social signals. Perfect for SEO, domain investing, and PBN building. No login required.

- **URL**: https://apify.com/nogards95/domain-drop-monitor-scraper.md
- **Developed by:** [Nogards](https://apify.com/nogards95) (community)
- **Categories:** Lead generation, Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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

### What does Daily Domain Drop Monitor do?

**Daily Domain Drop Monitor** downloads fresh lists of expiring, pending-delete, and dropped domains from [domainreborn.com](https://domainreborn.com) — a public aggregator built on ICANN CZDS zone files. It works as a **domain expiry API alternative**: no login, no browser, no proxies. Just a direct CSV download filtered and structured for immediate use.

It covers 12 major TLDs (org · info · dev · app · blog · store · tech · site · online · xyz · name · biz) and returns up to 5,000 domains per run with registration history, Wayback Machine snapshots, social signals, and Certificate Transparency data.

---

### Why use Daily Domain Drop Monitor?

Finding quality expired domains manually is tedious — you'd have to visit multiple registrars, export data, and cross-reference history signals. This Actor automates the entire pipeline:

- 🔍 **Filter by TLD, age, and history signals** — target exactly the domains that match your use case
- 📦 **Structured output** — JSON, CSV, or Excel ready to import into your workflow
- ⏱️ **Fast runs** — typically under 30 seconds with no browser overhead
- 🔁 **Schedule daily** — run automatically at 07:30 UTC right after the source updates
- 🔗 **Integrate anywhere** — connect to Google Sheets, Airtable, Slack, or your own API via Apify integrations

**Common use cases:**
- Domain investors looking for valuable names before they hit the open market
- SEO professionals building PBNs or acquiring domains with existing backlink history  
- Marketers finding aged brand domains with Wikipedia refs or social proof
- Developers building domain monitoring and drop-catching workflows
- Researchers tracking expiration trends across TLDs

---

### What data can Daily Domain Drop Monitor extract?

| Field | Type | Description |
|---|---|---|
| `domain` | string | Full domain name (e.g. `example.org`) |
| `tld` | string | Top-level domain without dot |
| `status` | string | `pending_delete` or `available` |
| `registeredAt` | string | Original registration date (ISO 8601) |
| `expiresAt` | string | Expiration date |
| `droppedAt` | string | Expected or actual drop date |
| `ageYears` | integer | Domain age in years |
| `waybackCount` | integer | Wayback Machine snapshot count — proxy for historical web presence |
| `wikipediaRefs` | integer | Number of Wikipedia references |
| `hnMentions` | integer | Hacker News mentions |
| `redditMentions` | integer | Reddit mentions |
| `ctCerts` | integer | Certificate Transparency certificates issued |
| `ctSubdomains` | integer | Unique subdomains seen in CT logs |
| `registrar` | string | Last known registrar |
| `registerUrl` | string | Direct link to the domain page on domainreborn.com |

---

### How to scrape expired and pending delete domains

1. **Open the Actor** and click **Try for free**
2. **Set the status filter** — use `pending_delete` for drop-catching (last 5 days before release) or `available` to find domains you can register today
3. **Add TLD filters** (optional) — enter TLDs without the dot: `org`, `dev`, `blog`. Leave empty to fetch all supported TLDs at once
4. **Set quality filters** — use `minAge`, `minWayback`, `minHnMentions`, or `minRedditMentions` to narrow results to domains with real history
5. **Set maxResults** — start with 50–100 for a test run, up to 5,000 for full lists
6. **Click Start** — results appear in the Output tab within seconds
7. **Export** — download as JSON, CSV, or Excel from the Output tab, or connect to Google Sheets via Apify integrations

**Schedule for daily monitoring:** Open the Schedules tab, set the cron to `30 7 * * *` (07:30 UTC), and configure your filters once. You'll get a fresh dataset every morning.

---

### How much will it cost to scrape expired domains?

This Actor is priced at **$2.00 per 1,000 results**.

- Free tier: includes enough platform credits to run a test with 50–100 results at no cost
- A daily run returning 1,000 domains costs $2.00/day — $60/month
- A daily run returning 5,000 domains (maximum) costs $10.00/day — $300/month

Since the source is a single CSV download (no browser, no pagination), compute costs are minimal — you're paying almost entirely for the results, not infrastructure.

---

### Input

See the **Input tab** for the full configuration form. Key fields:

- **Status** (`pending_delete` / `available` / `all`) — controls which stage of the expiration lifecycle to fetch
- **TLDs** — comma-separated list, leave empty for all 12 supported TLDs
- **minWayback** — set to `50` or higher to filter for domains with documented history
- **maxResults** — keep low (50–200) for targeted searches, up to 5,000 for bulk data

> ⚠️ **.com is not available** — Verisign requires separate zone file access not covered by ICANN CZDS.

---

### Output

You can download the dataset in various formats such as **JSON, CSV, or Excel** from the Output tab.

Example output record:

```json
{
  "domain": "opendesign.org",
  "tld": "org",
  "status": "pending_delete",
  "registeredAt": "2011-06-14",
  "expiresAt": "2026-06-14",
  "droppedAt": "2026-07-02",
  "ageYears": 15,
  "waybackCount": 842,
  "wikipediaRefs": 0,
  "hnMentions": 3,
  "redditMentions": 1,
  "ctCerts": 4,
  "ctSubdomains": 2,
  "ctFirstSeen": "2018-03-10",
  "registrar": "GoDaddy",
  "registerUrl": "https://domainreborn.com/d/opendesign.org",
  "scrapedAt": "2026-06-06T07:31:00.000Z"
}
````

***

### Tips and advanced options

- **`status: "pending_delete"`** is the best window for drop-catching services — domains are in their last 5 days before release
- **`minWayback: 100`** reliably filters for domains that had real web presence; `500+` indicates heavy traffic history
- **`minHnMentions: 1`** or **`minRedditMentions: 1`** finds domains with actual community presence — strong signal for brand value
- **`minAge: 5` + `minWayback: 200`** is a solid combo for domain investing
- Specify multiple TLDs (e.g. `["org", "dev", "app"]`) to get separate filtered lists for each — results are deduplicated across TLDs
- Use the **Apify API tab** to trigger runs programmatically and integrate into your own pipeline

***

### FAQ, disclaimers, and support

**Is this legal to use?**\
This Actor fetches publicly available data from domainreborn.com, which aggregates public ICANN CZDS zone files. No login, authentication, or private data is accessed.

> Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

**Why is .com not available?**\
Verisign, the .com registry, does not participate in ICANN CZDS and requires a separate data access agreement. All other major TLDs in this Actor are covered via the public CZDS program.

**The data looks the same every run — is it stale?**\
The source updates once daily between 06:00–07:30 UTC. Schedule your runs at 07:30 UTC to always get the freshest data. Running multiple times per day will return identical results.

**Found a bug or need a new feature?**\
Open an issue in the Issues tab and I'll respond quickly. For programmatic access and integrations, see the **API tab**.

# Actor input Schema

## `status` (type: `string`):

Filter by domain lifecycle status. 'pending\_delete' = last 5 days before release (best for drop-catching). 'available' = register right now.

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

Filter by TLD without dot (e.g. 'org', 'dev', 'blog'). Leave empty to fetch all supported TLDs in one request. Supported: org info dev app blog store tech site online xyz name biz. Note: .com is not available.

## `minAge` (type: `integer`):

Only return domains registered at least this many years ago. Use 3+ to find established domains with history.

## `minWayback` (type: `integer`):

Only return domains with at least this many Wayback Machine archives. Use 50+ for meaningful history, 200+ for strong SEO signals.

## `minHnMentions` (type: `integer`):

Only return domains mentioned on Hacker News at least this many times. Use 1 to find domains with any tech community presence.

## `minRedditMentions` (type: `integer`):

Only return domains mentioned on Reddit at least this many times. Use 1 to find domains with any social media presence.

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

Maximum number of domains to return. Each source returns up to 5,000 domains per run.

## Actor input object example

```json
{
  "status": "pending_delete",
  "tlds": [
    "org"
  ],
  "minAge": 0,
  "minWayback": 0,
  "minHnMentions": 0,
  "minRedditMentions": 0,
  "maxResults": 50
}
```

# Actor output Schema

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

No description

# 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 = {
    "status": "pending_delete",
    "tlds": [
        "org"
    ],
    "minAge": 0,
    "minWayback": 0,
    "minHnMentions": 0,
    "minRedditMentions": 0,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("nogards95/domain-drop-monitor-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 = {
    "status": "pending_delete",
    "tlds": ["org"],
    "minAge": 0,
    "minWayback": 0,
    "minHnMentions": 0,
    "minRedditMentions": 0,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("nogards95/domain-drop-monitor-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 '{
  "status": "pending_delete",
  "tlds": [
    "org"
  ],
  "minAge": 0,
  "minWayback": 0,
  "minHnMentions": 0,
  "minRedditMentions": 0,
  "maxResults": 50
}' |
apify call nogards95/domain-drop-monitor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🎯 Expired Domain Sniper - Daily Drops with Backlink History",
        "description": "Get daily lists of expiring, pending-delete, and dropped domains. Filter by TLD, age, Wayback history, and social signals. Perfect for SEO, domain investing, and PBN building. No login required.",
        "version": "0.1",
        "x-build-id": "6l1Goj8a3VDE6H9tx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nogards95~domain-drop-monitor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nogards95-domain-drop-monitor-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/nogards95~domain-drop-monitor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nogards95-domain-drop-monitor-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/nogards95~domain-drop-monitor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nogards95-domain-drop-monitor-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",
                "required": [
                    "status",
                    "maxResults"
                ],
                "properties": {
                    "status": {
                        "title": "Domain status",
                        "enum": [
                            "all",
                            "pending_delete",
                            "available"
                        ],
                        "type": "string",
                        "description": "Filter by domain lifecycle status. 'pending_delete' = last 5 days before release (best for drop-catching). 'available' = register right now.",
                        "default": "pending_delete"
                    },
                    "tlds": {
                        "title": "TLDs to include",
                        "type": "array",
                        "description": "Filter by TLD without dot (e.g. 'org', 'dev', 'blog'). Leave empty to fetch all supported TLDs in one request. Supported: org info dev app blog store tech site online xyz name biz. Note: .com is not available.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minAge": {
                        "title": "Minimum domain age (years)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains registered at least this many years ago. Use 3+ to find established domains with history.",
                        "default": 0
                    },
                    "minWayback": {
                        "title": "Minimum Wayback Machine snapshots",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains with at least this many Wayback Machine archives. Use 50+ for meaningful history, 200+ for strong SEO signals.",
                        "default": 0
                    },
                    "minHnMentions": {
                        "title": "Minimum Hacker News mentions",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains mentioned on Hacker News at least this many times. Use 1 to find domains with any tech community presence.",
                        "default": 0
                    },
                    "minRedditMentions": {
                        "title": "Minimum Reddit mentions",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains mentioned on Reddit at least this many times. Use 1 to find domains with any social media presence.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of domains to return. Each source returns up to 5,000 domains per run.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
