# QName AI WHOIS & RDAP (`qname/qname-ai-whois-rdap`) Actor

Structured WHOIS and RDAP domain intelligence for one domain or bulk lists up to 1,000, powered by a managed QName AI API pool with source-aware evidence.

- **URL**: https://apify.com/qname/qname-ai-whois-rdap.md
- **Developed by:** [QName AI](https://apify.com/qname) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

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

### WHOIS domain lookup powered by QName AI

QName AI WHOIS & RDAP Domain Intelligence turns a domain list into structured,
source-aware registration evidence. Add one domain or up to 1,000 domains, run
the Actor, and receive one dataset row per domain. The WHOIS domain lookup is
designed for domain research, portfolio checks, brand protection, SEO research,
security triage, and AI Agent workflows that need predictable JSON instead of
unstructured terminal output.

This Actor uses the managed QName AI API pool, so you do not need to expose a
QName API key. Each WHOIS domain lookup can use RDAP, registrar WHOIS, or DNS
evidence. The source distinguishes a complete WHOIS record from a DNS-only
observation.

Key capabilities:

- Run a single or bulk WHOIS domain lookup with up to 1,000 unique domains.
- Receive normalized registrar, creation, update, expiry, nameserver, DNSSEC,
  status, error-code, and source fields.
- Preserve nested QName AI data for workflows that need more than the table view.
- Export WHOIS and RDAP results through Apify as JSON, JSONL, CSV, Excel, XML,
  or RSS.
- Schedule a recurring bulk WHOIS check or connect the dataset to other Apify
  integrations.
- Call the Actor from Apify API clients, CLI tools, or AI Agents through the
  Apify MCP server.

### How to run a bulk WHOIS lookup

Open the Input tab and enter domains as a list. Bare domains and full URLs are
accepted. The Actor extracts the hostname, converts it to lowercase, removes a
trailing dot, and deduplicates the list before sending one bulk request to QName
AI. Invalid or empty entries do not become WHOIS requests.

Example input:

```json
{
  "domains": [
    "qname.ai",
    "example.com",
    "https://www.cloudflare.com/products/registrar/"
  ],
  "includeRaw": false
}
```

The maximum input is 1,000 domains per run. For recurring monitoring, save the
configuration as an Apify task and attach a schedule. For a one-time WHOIS domain
lookup, run the Actor and open the default dataset.

The optional `includeRaw` setting adds upstream WHOIS or RDAP evidence. Leave it
disabled for compact datasets; enable it for parsing audits or later review.

### WHOIS and RDAP output

Every requested domain produces an independent dataset row. A typical structured
WHOIS result looks like this:

```json
{
  "domain": "qname.ai",
  "registrationStatus": "registered",
  "code": "SUCCESS",
  "source": "rdap",
  "registrar": "Example Registrar",
  "createdDate": "2024-01-01T00:00:00Z",
  "expirationDate": "2027-01-01T00:00:00Z",
  "updatedDate": "2026-01-01T00:00:00Z",
  "nameServers": ["ns1.example.com", "ns2.example.com"],
  "statuses": ["clientTransferProhibited"],
  "dnssec": "signedDelegation",
  "error": null,
  "checkedAt": "2026-09-13T00:00:00.000Z"
}
```

The `code` and `registrationStatus` fields are intentionally separate. Common
codes include `SUCCESS`, `DOMAIN_NOT_REGISTERED`, `DOMAIN_RESERVED`,
`DOMAIN_DROPZONE`, `DOMAIN_REGISTRY_RESTRICTED`, and `QUERY_FAILED`. A failed
WHOIS domain lookup is kept in the dataset instead of silently disappearing,
which makes batch completeness easy to audit.

The `source` field can be `rdap`, `whois`, `registrar`, or `dns`. QName AI does
not treat DNS-only evidence as a complete WHOIS record. When only DNS evidence
is available, `registrationStatus` is `dns_observed`; the Actor does not invent
registration dates, registrar details, or availability conclusions.

### Why source-aware domain intelligence matters

WHOIS data is not uniform. Registries may provide structured RDAP, text WHOIS,
redacted records, or restricted responses. A domain can resolve in DNS while a
registration service is unavailable. Treating these signals as equivalent can
create false availability alerts or incorrect domain-age calculations.

QName AI keeps structured evidence and exposes the source used for each result.
An AI Agent can attribute registrar and expiry data to RDAP while flagging a
DNS-only result for follow-up instead of presenting a guess as verified WHOIS.

### Use cases

#### Domain portfolio monitoring

Schedule a bulk WHOIS domain lookup to track expiry dates, nameserver changes,
transfer locks, and registrar changes. Treat each run as a timestamped
observation rather than a permanent fact.

#### Domain acquisition research

Check candidates before deeper trademark or pricing research.
`DOMAIN_NOT_REGISTERED` does not guarantee a normal-price purchase. Premium,
reserved, restricted, and dropzone domains need a registrar check.

#### SEO and competitive research

Add creation dates, registrars, nameservers, and status codes to research data.
WHOIS and RDAP evidence does not prove company age, traffic, or commercial
success.

#### AI Agent and automation workflows

Use the Apify API or MCP server as a bounded WHOIS lookup tool. Stable output
fields are easier for Agents to validate than free-form WHOIS text.

### API and integrations

Run the Actor from Apify Console, API clients, CLI, schedules, or integrations.
The API tab provides generated examples. Results use the default dataset, so
Apify exports work without a separate QName credential.

The managed QName API key is an Actor secret environment variable. It is not
included in inputs, datasets, logs, source files, or sample requests.

### Limits and responsible use

- Maximum input: 1,000 unique domains per Actor run.
- Large WHOIS datasets can take longer because registries impose different
  latency and rate limits.
- Contact fields may be redacted or absent due to registry policy and privacy
  rules.
- WHOIS, RDAP, DNS, and registrar responses are observations, not legal advice
  or a guaranteed purchase decision.
- Do not use the Actor to collect or misuse personal data. Follow applicable law,
  registry terms, and Apify platform rules.

### Frequently asked questions

#### Does the Actor require my QName API key?

No. The Store version uses a managed API pool configured by QName AI. A private
QName key is never requested in the Actor input.

#### Can I check 1,000 domains in one run?

Yes. The input schema accepts up to 1,000 unique entries. The Actor normalizes
URLs to hostnames and removes duplicates before the bulk WHOIS request.

#### Does `DOMAIN_NOT_REGISTERED` guarantee availability?

No. Confirm purchase availability and final price with a registrar. Reserved,
premium, restricted, and dropzone names can behave differently from an ordinary
unregistered domain.

#### Why is a result marked `dns_observed`?

It means QName AI found DNS evidence but did not receive complete structured
WHOIS or RDAP evidence. The conservative label prevents DNS reachability from
being presented as a verified registration record.

#### Where can I learn more about QName AI?

Visit [QName AI](https://qname.ai), explore the
[WHOIS domain lookup](https://qname.ai/whois), or review the
[qname-cli guide](https://qname.ai/cli) for terminal and Agent-native access.

# Actor input Schema

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

Add one domain or URL per row. Duplicate values are removed before the WHOIS domain lookup starts.

## `includeRaw` (type: `boolean`):

Include the upstream raw WHOIS or RDAP evidence when it is available. Raw records can make datasets much larger.

## Actor input object example

```json
{
  "domains": [
    "qname.ai",
    "example.com"
  ],
  "includeRaw": false
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("qname/qname-ai-whois-rdap").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": [
        "qname.ai",
        "example.com",
    ] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,qname/qname-ai-whois-rdap"
        }
    }
}
```

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/4rauHenSjlmg4YppJ/builds/ZCGcHsuf8e5Uhw2P2/openapi.json