Domain Registration Lookup Scraper

Refresh registrar, registration, expiry, status, nameserver, DNSSEC, and public entity-handle records for supplied domains through authoritative public RDAP services.

Domain Registration Lookup Scraper routes every domain with IANA's current DNS RDAP bootstrap data. It queries the registry's structured JSON endpoint directly and records the source URL and retrieval time, making the output practical for portfolio monitoring, risk review, and repeatable enrichment.

What does Domain Registration Lookup Scraper do?

The Actor accepts up to 1,000 domain names or URLs per run.

For each unique domain, it:

1. normalizes URLs and internationalized domain names;
2. downloads IANA's current TLD-to-RDAP service map;
3. selects the authoritative registry service;
4. requests the domain's RDAP record;
5. normalizes dates, registrar data, statuses, nameservers, DNSSEC, and entities;
6. saves a typed dataset row with source and retrieval evidence.

It does not scrape search-engine pages or guess registration details from DNS records.

Who is this domain registration lookup for?

• IT operations teams refreshing renewal and registrar inventories.
• Security analysts enriching suspicious-domain lists with age and status signals.
• Brand protection teams tracking lookalike or campaign domains.
• Domain portfolio managers checking expiry dates and nameserver changes.
• Data engineers adding normalized RDAP records to scheduled workflows.
• Due-diligence teams preserving source URLs and retrieval timestamps for review.

Why use authoritative RDAP data?

RDAP is the structured JSON successor to free-form WHOIS responses.

This Actor uses the IANA bootstrap registry to discover each TLD's published RDAP service instead of depending on one third-party aggregator.

Benefits include:

• consistent typed output across registries;
• traceable authoritative source endpoints;
• explicit event, status, entity, and DNSSEC fields;
• URL, duplicate, and internationalized-domain normalization;
• uncharged error records when a domain cannot be resolved;
• bounded concurrency for registry rate-limit safety.

For legacy raw WHOIS text, use WHOIS Lookup instead.

What domain registration data can I extract?

Field	Description
domain	Normalized ASCII domain returned by RDAP
unicodeDomain	Unicode domain form when the registry supplies it
registryHandle	Registry identifier for the domain object
registrar	Registrar name from the registrar entity
registrarHandle	Public registrar entity handle
registrationDate	Registration event timestamp
expirationDate	Registry expiration event timestamp
lastChangedDate	Latest domain-change timestamp when exposed
domainAgeDays	Whole days since registration
daysUntilExpiration	Whole days until expiration
statuses	Registry status codes
nameservers	Nameserver hostnames in the registration record
dnssecSigned	Signed-delegation indicator when exposed
entityHandles	Public entity handles, roles, and names
rdapSourceUrl	Registry RDAP endpoint that supplied the record
bootstrapPublication	IANA bootstrap publication timestamp
retrievedAt	UTC lookup timestamp
lookupStatus	found, not_found, or failed
error	Explanation for an unresolved lookup

Registry redaction policies vary. Fields that are absent upstream remain null or empty; the Actor does not infer private registration data.

How to run a domain registration lookup

1. Open the Actor in Apify Console.
2. Add domain names or website URLs to Domains.
3. Leave Maximum concurrency at 5 unless a registry requires slower requests.
4. Click Start.
5. Open the default dataset to review or export the rows.
6. Schedule the Task when you need recurring snapshots.

A practical first input is:

{
  "domains": [
    "apify.com",
    "wikipedia.org",
    "cloudflare.com"
  ],
  "maxConcurrency": 3
}

Input parameters

Parameter	Type	Required	Default	Limits	Description
domains	string[]	Yes	Prefilled examples	1–1,000	Domain names or URLs to normalize, deduplicate, and resolve
maxConcurrency	integer	No	5	1–10	Maximum simultaneous registry requests

Accepted domain inputs include:

apify.com
https://www.apify.com/store
münchen.de

The Actor removes a leading www, strips URL paths, converts Unicode hostnames to ASCII for lookup, and skips duplicates after normalization.

Malformed input fails the run before any domain requests are made.

Domain registration lookup output example

A successful apify.com lookup produces this shape (some arrays shortened):

{
  "domain": "apify.com",
  "unicodeDomain": null,
  "registryHandle": "1586855587_DOMAIN_COM-VRSN",
  "registrar": "Amazon Registrar, Inc.",
  "registrarHandle": "468",
  "registrationDate": "2009-06-02T17:14:10Z",
  "expirationDate": "2035-06-02T17:14:10Z",
  "lastChangedDate": "2025-05-25T23:25:20Z",
  "domainAgeDays": 6282,
  "daysUntilExpiration": 3214,
  "statuses": ["client transfer prohibited"],
  "nameservers": ["ns-1114.awsdns-11.org"],
  "dnssecSigned": false,
  "entityHandles": [
    {
      "handle": "468",
      "roles": ["registrar"],
      "name": "Amazon Registrar, Inc."
    }
  ],
  "rdapSourceUrl": "https://rdap.verisign.com/com/v1/domain/apify.com",
  "bootstrapPublication": "2026-08-13T20:00:01Z",
  "retrievedAt": "2026-08-14T06:30:00.000Z",
  "lookupStatus": "found",
  "error": null
}

Dates and registry handles above are illustrative snapshots; live registry records can change.

How much does it cost to look up domain registration records?

The Actor uses pay-per-event pricing.

• A one-time Run started event costs $0.001 per run.
• Each successfully resolved domain uses one Domain resolved event.
• Failed and not_found rows are not charged per domain.
• The per-domain rate decreases across Apify pricing tiers.

At the BRONZE rate of $0.0016 per resolved domain:

Successful domains	Example total
1	$0.0026
10	$0.017
100	$0.161
1,000	$1.601

Your active tier is shown in Apify Console. Runtime infrastructure is included in pay-per-event billing; registry rate limits can affect duration but not the number of successfully resolved domain events.

Monitor a domain portfolio

Create an Apify Task with the portfolio's domains and schedule it daily, weekly, or monthly.

Send each finished dataset to a webhook, cloud storage, spreadsheet, or database.

Compare records by domain and flag changes in:

• registrar;
• expirationDate;
• statuses;
• nameservers;
• dnssecSigned.

Keep historical datasets if you need change history. The Actor returns current snapshots; it does not maintain an internal history database or send alerts by itself.

Security and risk enrichment workflow

For incident-response or brand-protection lists:

1. supply normalized or raw URLs from your detection system;
2. inspect domainAgeDays for recently registered domains;
3. retain rdapSourceUrl as evidence;
4. combine statuses and nameservers with DNS or certificate data;
5. route failed rows into a bounded retry queue.

Registration metadata is one signal, not proof that a domain is malicious or trustworthy.

Export and integrations

The default dataset can be downloaded as JSON, CSV, Excel, XML, RSS, or JSONL.

Common integrations include:

• Google Sheets for renewal inventories;
• Airtable for portfolio review;
• Slack or email workflows for expiry thresholds;
• databases and data warehouses for historical comparison;
• security automation platforms for domain enrichment;
• Zapier and Make for no-code routing.

Use domain as the stable join key and retrievedAt as the observation time.

Run through the Apify API with cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~domain-rdap-lookup/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["apify.com", "wikipedia.org"],
    "maxConcurrency": 2
  }'

To wait for completion and receive dataset items directly:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~domain-rdap-lookup/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains":["apify.com"]}'

Run with JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/domain-rdap-lookup').call({
  domains: ['apify.com', 'github.com', 'cloudflare.com'],
  maxConcurrency: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Run with Python

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/domain-rdap-lookup').call(run_input={
    'domains': ['apify.com', 'wikipedia.org'],
    'maxConcurrency': 2,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Use Domain Registration Lookup Scraper with MCP

Add the Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/domain-rdap-lookup"

Claude Desktop setup

Add this server in Claude Desktop's MCP configuration. The same JSON shape works for supported editor clients:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/domain-rdap-lookup"
    }
  }
}

Cursor setup

Open Cursor's MCP settings and add the apify server URL from the JSON above.

VS Code setup

Add the same HTTP MCP server URL through your VS Code MCP extension or workspace MCP configuration.

Example prompts:

• “Look up the registration and expiry dates for these domains and return a table.”
• “Refresh this domain portfolio and show records expiring within 90 days.”
• “Resolve these incident URLs and list recently registered domains with their RDAP source.”

Limits and expected failure behavior

• Coverage depends on IANA listing an RDAP service for the domain's TLD.
• Registry fields and redaction rules differ.
• Some registries omit expiration dates, registrar names, DNSSEC, or entity names.
• Registry rate limits can produce temporary failed records.
• A registry 404 produces an uncharged not_found row.
• The Actor does not query private registrar APIs, historical WHOIS databases, or paid ownership sources.
• The Actor does not determine availability for purchase; a missing RDAP record is not a purchase guarantee.
• The maximum input is 1,000 domains per run and concurrency is capped at 10.

For a throttled registry, reduce maxConcurrency and retry only the failed domains later.

Troubleshooting

Why is the registrar or expiry date null?

The authoritative registry did not expose that field in its RDAP response. Check rdapSourceUrl to inspect the source record.

Why did I receive not_found?

The selected authoritative service returned HTTP 404. The domain may be unregistered, unsupported at that registry, or temporarily unavailable. Do not treat this alone as proof of purchase availability.

Why did I receive failed?

Review error and the run log. Temporary 429 or 5xx responses usually indicate registry throttling or an outage. Lower concurrency and retry the affected domains.

Why were fewer requests made than input rows?

Normalization removes leading www, strips URL paths, and deduplicates domains. google.com and https://www.google.com/path resolve once.

Can I use a proxy?

This Actor does not expose a proxy option because authoritative RDAP requests work directly and adding paid proxy traffic would increase cost without improving the normal route.

Responsible use and legality

RDAP services publish registration data for legitimate technical, operational, security, and legal purposes. Users remain responsible for complying with registry terms, applicable law, and Apify's policies.

Do not use the output to harass registrants, bypass redaction, send unsolicited messages, or make unsupported ownership claims. Entity data can be redacted, privacy-proxied, stale, or incomplete. Minimize retention and access when records contain personal information.

Frequently asked questions

Is RDAP the same as WHOIS?

RDAP serves a similar registration lookup purpose but uses structured JSON, standardized links, and clearer status and entity objects. WHOIS commonly returns free-form text.

Does the Actor return historical registration records?

No. It returns the current public registry response. Preserve scheduled dataset snapshots if you need your own history.

Does it find domains by keyword?

No. Supply exact domains or URLs. The Actor does not search for brand variants or newly registered domains.

Are failed domains billed?

The run start event still applies, but the per-domain event is charged only after the registry successfully resolves a domain.

Can I look up internationalized domains?

Yes. Unicode hostnames are converted to ASCII for routing and lookup. unicodeDomain is populated when the registry returns that form.

How fresh is the data?

Every run queries the registry service selected from the current IANA bootstrap response. Freshness of each field is controlled by that registry.

Related Automation Lab Actors

• WHOIS Lookup for legacy raw WHOIS responses and parsed contact fields.
• SSL Certificate Checker for certificate validity, issuer, and expiry checks.
• MX Record Checker for domain mail-routing records.

Combine these Actors when a workflow needs registration, DNS, and certificate evidence rather than RDAP alone.