# Domain Inspector — WHOIS/RDAP, DNS & SSL (`hipersoft/domain-inspector`) Actor

Inspect any list of domains: registrar, registration/expiry dates and status via RDAP; DNS records (A, AAAA, MX, NS, TXT, CNAME); and SSL certificate issuer and expiry. Bulk-ready, no login, no API key. Great for domain portfolios, security audits and lead research.

- **URL**: https://apify.com/hipersoft/domain-inspector.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0016 / domain inspected

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Domain Inspector — WHOIS/RDAP, DNS & SSL

Everything about a domain in one row. Give the Actor a list of domains and it returns
each one's **registrar, registration & expiry dates, status and nameservers (via
RDAP), full DNS records, and SSL certificate details** — over public sources, no login
and no API key.

Perfect for **domain portfolio monitoring, expiry/SSL alerting, security audits,
due-diligence and lead enrichment**.

### What you get per domain

| Field | Notes |
|---|---|
| `registrar` | Registrar name (RDAP). |
| `createdDate`, `updatedDate`, `expiryDate` | Registration lifecycle dates. |
| `statuses` | EPP status codes (e.g. `clientTransferProhibited`). |
| `nameservers` | Authoritative nameservers from the registry. |
| `dns` | `{ a, aaaa, mx, ns, txt, cname }` resolved live. |
| `ssl` | `{ issuer, subject, validFrom, validTo, daysToExpiry, authorized }`. |
| `registrableDomain` | The eTLD+1 used for the registry lookup. |

### Input

```json
{
  "domains": ["google.com", "example.co.uk", "apify.com"],
  "includeRdap": true,
  "includeDns": true,
  "includeSsl": true
}
```

- **domains** — domains (or URLs — the host is used), one per line.
- **includeRdap / includeDns / includeSsl** — toggle each data source (all on by default).
- **maxConcurrency** — domains inspected in parallel.
- **proxyConfiguration** — optional; only if RDAP rate-limits your IP.

### Output (one row per domain)

```json
{
  "input": "google.com",
  "domain": "google.com",
  "registrar": "MarkMonitor Inc.",
  "createdDate": "1997-09-15T04:00:00Z",
  "expiryDate": "2028-09-14T04:00:00Z",
  "statuses": ["clientTransferProhibited"],
  "nameservers": ["ns1.google.com", "ns2.google.com"],
  "dns": { "a": ["142.250.72.14"], "mx": ["smtp.google.com"], "ns": ["ns1.google.com"], "txt": ["v=spf1 ..."] },
  "ssl": { "issuer": "Google Trust Services", "validTo": "2026-09-01T00:00:00.000Z", "daysToExpiry": 52, "authorized": true },
  "error": null
}
```

### FAQ

**Do I need an account or API key?**
No. The Actor queries public sources — RDAP (modern WHOIS), live DNS, and TLS certificates — with no login or API key.

**How many domains can I inspect per run?**
There's no fixed cap. `maxConcurrency` controls how many domains are looked up in parallel, and each domain is time-capped so one slow lookup can't stall a bulk run.

**Is domain inspection legal?**
Yes. The Actor collects only publicly available registration, DNS, and certificate data. RDAP and DNS are designed to be publicly queryable.

**What's the output format?**
A JSON dataset with one row per domain (registrar, lifecycle dates, statuses, nameservers, DNS records, SSL details). Export as JSON, CSV, or Excel from the Apify Console or API.

**Can I filter or limit results?**
Yes. Toggle `includeRdap`, `includeDns`, and `includeSsl` to choose which data sources to query, and use `maxConcurrency` to tune throughput.

### Related Actors

Combine domain data with other web-diagnostics and archival tools:

- [Bulk URL Status Checker](https://apify.com/hipersoft/bulk-url-checker) — check thousands of links for broken status, redirects, and SSL.
- [Wayback Machine Scraper](https://apify.com/hipersoft/wayback-machine-scraper) — list archived snapshots of a URL or domain.
- [Bulk Image Downloader](https://apify.com/hipersoft/bulk-image-downloader) — fetch and store images at scale from a URL list.
- [Website Contact Scraper](https://apify.com/hipersoft/website-contact-scraper) — extract emails, phones, and social links from websites.

### Notes

Registration data comes from RDAP (the modern WHOIS); a few TLDs expose limited fields.
Each domain is hard-capped in time so one slow lookup can't stall a bulk run. Only
publicly available registration/DNS/certificate data is collected.

# Actor input Schema

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

Domains to inspect (e.g. "google.com", "example.co.uk"). URLs are accepted too — the host is used. One per line.

## `includeRdap` (type: `boolean`):

Look up registrar, creation/expiry dates, status and nameservers via RDAP.

## `includeDns` (type: `boolean`):

Resolve A, AAAA, MX, NS, TXT and CNAME records.

## `includeSsl` (type: `boolean`):

Fetch the TLS certificate issuer, validity and days-to-expiry (https).

## `maxConcurrency` (type: `integer`):

How many domains to inspect in parallel.

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

Optional. Only needed if RDAP rate-limits your IP.

## Actor input object example

```json
{
  "domains": [
    "google.com",
    "apify.com"
  ],
  "includeRdap": true,
  "includeDns": true,
  "includeSsl": true,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "domains": [
        "google.com",
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/domain-inspector").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 = { "domains": [
        "google.com",
        "apify.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/domain-inspector").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 '{
  "domains": [
    "google.com",
    "apify.com"
  ]
}' |
apify call hipersoft/domain-inspector --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/qua6VHO79mZCgENiZ/builds/yp5CYzky138PJfsHW/openapi.json