# Domain DNS Checker - WHOIS, Availability & DNS Records (`gochujang/domain-dns-checker`) Actor

Check domain availability, WHOIS registration data, and DNS records (A, AAAA, MX, NS, TXT, CNAME) for any list of domains. Identify expired domains, find nameservers, detect mail providers, and analyze domain infrastructure. Uses public DNS APIs — no API key required.

- **URL**: https://apify.com/gochujang/domain-dns-checker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item processeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Domain DNS Checker do?

**Domain DNS Checker** is a fast, no-API-key tool for bulk **domain DNS record lookup** across any list of domains. It resolves A, AAAA, MX, NS, TXT, and CNAME records via Google DNS-over-HTTPS, fetches WHOIS/RDAP registration data (registrar, creation date, expiry), and automatically detects **mail providers** (Google Workspace, Microsoft 365, Amazon SES) and **nameserver providers** (Cloudflare, AWS Route 53, GoDaddy). It also functions as a **DNS propagation tracker** and domain availability detector, processing up to 10 domains concurrently for fast batch throughput.

### Why use Domain DNS Checker?

**Developers, SEO teams, and security engineers** use this actor to automate DNS intelligence gathering that would take hours to do manually across large domain lists.

- **Domain hunting** — Bulk-check hundreds of domains for availability before registering. A quick NS record lookup is enough to determine registration status — set `checkWhois: false` and `recordTypes: ["NS"]` for maximum speed.
- **Email deliverability audits** — Verify MX records and identify mail providers in bulk. Spot missing SPF (`v=spf1`) or DMARC (`v=DMARC1`) TXT records that cause email rejection.
- **SEO and competitor research** — Discover which hosting stack competitors use, when their domains expire, and whether they are on shared or dedicated infrastructure.
- **Security audits** — Detect shadow IT domains, missing DMARC records, and identify externally facing assets across a corporate domain portfolio.
- **Domain portfolio management** — Monitor expiry dates across owned domains and flag those expiring within 30 days before they lapse unintentionally.
- **Infrastructure mapping** — Map nameserver and mail provider distribution across a vendor list for supply-chain risk assessments.

### How to use Domain DNS Checker

1. Click **Try for free** on the Apify Store listing — no API key needed.
2. Enter your list of domains in the `domains` field (e.g. `["example.com", "openai.com"]`).
3. Select which `recordTypes` to fetch: `A`, `AAAA`, `MX`, `NS`, `TXT`, `CNAME`.
4. Set `checkWhois: true` (default) to retrieve registrar, creation date, and expiry data from RDAP.
5. Click **Start**. The actor processes 10 domains concurrently and returns one record per domain.
6. Filter results in the dataset by `is_registered`, `mail_provider`, or `days_until_expiry` to find what you need instantly.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | string\[] | `["example.com", "github.com"]` | List of domains to check — supports any valid domain name |
| `recordTypes` | string\[] | `["A", "MX", "NS", "TXT"]` | **DNS record types** to fetch per domain |
| `checkWhois` | boolean | `true` | Fetch RDAP registration data (registrar, expiry, creation date) |

#### Example Input

```json
{
  "domains": ["example.com", "openai.com", "anthropic.com"],
  "recordTypes": ["A", "MX", "NS", "TXT", "CNAME"],
  "checkWhois": true
}
```

### Output

One structured record per domain:

```json
{
  "domain": "example.com",
  "tld": "com",
  "is_registered": true,
  "dns_records": {
    "A": ["93.184.216.34"],
    "MX": ["0 example-com.mail.protection.outlook.com"],
    "NS": ["a.iana-servers.net", "b.iana-servers.net"],
    "TXT": ["v=spf1 -all"]
  },
  "mail_provider": "microsoft",
  "nameserver_provider": "iana",
  "registrar": "IANA",
  "created_date": "1995-08-14",
  "expiry_date": "2027-08-13",
  "days_until_expiry": 710,
  "fetched_at": "2026-09-02T10:00:00Z"
}
```

### Data fields

| Field | Description |
|---|---|
| `domain` | Normalized domain name (lowercase) |
| `tld` | Top-level domain (e.g. `com`, `io`, `net`) |
| `is_registered` | `true` if A, AAAA, or NS records exist — domain is registered |
| `dns_records` | Object mapping each record type to its resolved values |
| `mail_provider` | Detected provider from MX records: `google`, `microsoft`, `amazon`, `cloudflare`, `zoho`, `protonmail`, `custom`, or `null` |
| `nameserver_provider` | Detected NS provider: `cloudflare`, `aws`, `google`, `namecheap`, `godaddy`, `digitalocean`, `custom`, or `null` |
| `registrar` | Registrar name from RDAP (populated when `checkWhois: true`) |
| `created_date` | Domain registration date `YYYY-MM-DD` |
| `expiry_date` | Domain expiry date `YYYY-MM-DD` |
| `days_until_expiry` | Days until expiry — **negative value means already expired** |
| `fetched_at` | ISO 8601 timestamp of when the check was performed |

### Cost estimation

**$0.001 per domain checked** (Pay-Per-Event).

| Scenario | Domains | Estimated Cost |
|---|---|---|
| Quick spot check | 10 | $0.01 |
| Competitor research sweep | 100 | $0.10 |
| Portfolio expiry monitoring | 1,000 | $1.00 |
| Large-scale infrastructure map | 10,000 | $10.00 |

No additional fees for record types or WHOIS lookups — the $0.001/domain price covers everything.

### FAQ

**Which DNS record types are supported?**
The actor supports **A** (IPv4), **AAAA** (IPv6), **MX** (mail), **NS** (nameserver), **TXT** (SPF, DMARC, verification tokens), and **CNAME** (canonical name) records via Google DNS-over-HTTPS. Include any combination in the `recordTypes` input.

**How do I check if SPF and DMARC are configured correctly?**
Include `"TXT"` in `recordTypes` and inspect the `dns_records.TXT` array in output. Look for strings beginning with `v=spf1` (SPF policy) and `v=DMARC1` (DMARC policy). Missing either means the domain is vulnerable to email spoofing.

**Can I use this as a DNS propagation tracker?**
Yes. Run the actor at intervals (using Apify's scheduler) and compare `dns_records` output across runs. Changes in A record IPs, NS servers, or MX routing appear immediately in the structured output, making it straightforward to confirm when a DNS change has propagated.

***

*Data sources: [Google DNS-over-HTTPS](https://developers.google.com/speed/public-dns/docs/doh/json) for DNS resolution (no API key required) and [RDAP.org](https://rdap.org/) for WHOIS/registration data. All lookups are read-only and passive — no data is modified or written to any external service.*

***

### Related actors

- [Domain Availability Checker](https://apify.com/gochujang/domain-availability-checker) — Check domain registration status to pair with DNS record analysis
- [Domain Breach Checker](https://apify.com/gochujang/domain-breach-checker) — HIBP breach history for domains discovered via DNS lookup
- [SSL Certificate Monitor](https://apify.com/gochujang/ssl-certificate-monitor) — TLS certificate expiry and chain validation alongside DNS records

### Feedback

If this actor helps your DNS research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/domain-dns-checker#reviews)

***

**Keywords:** domain DNS checker, WHOIS lookup, DNS records scraper, A record lookup, MX record checker, TXT record DNS, CNAME lookup, nameserver check, expired domain finder, domain availability, DNS infrastructure analysis, mail provider detection, bulk DNS check, domain research

# Actor input Schema

## `domains` (type: `array`):

List of domain names to check (e.g. \['example.com', 'google.com'])

## `recordTypes` (type: `array`):

DNS record types to fetch: A, AAAA, MX, NS, TXT, CNAME

## `checkWhois` (type: `boolean`):

Fetch RDAP registration data (registrar, expiry, creation date)

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "github.com"
  ],
  "recordTypes": [
    "A",
    "MX",
    "NS",
    "TXT"
  ],
  "checkWhois": true
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/domain-dns-checker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/domain-dns-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call gochujang/domain-dns-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/domain-dns-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hPUiYsc7c6mk2cX34/builds/o6dw4xYNdHzKGLZZJ/openapi.json