# DomScan WHOIS and RDAP Lookup (`narrative_karat/domscan-whois-rdap`) Actor

DomScan WHOIS and RDAP Lookup for up to 100 targets with structured per-target results.

- **URL**: https://apify.com/narrative\_karat/domscan-whois-rdap.md
- **Developed by:** [Esteve Castells](https://apify.com/narrative_karat) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 domain results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## DomScan WHOIS and RDAP Lookup

Retrieve structured WHOIS and RDAP registration intelligence, including registrar, lifecycle, status, nameserver, and other publicly available fields where available.

Use it from Apify Console, the Apify API, an Actor task, or an automation workflow. Submit domains such as `example.com` or URLs such as `https://example.com`. Each run performs one selected operation for every target in the input.

### Features

- Process up to 100 domains or public HTTP(S) URLs per run.
- Choose one operation per run.
- Receive one dataset row for every processed target.
- Get an explicit `success` value and HTTP status for each result.
- Preserve the complete DomScan JSON response in the `data` field.
- Export structured results for analysis, enrichment, research, monitoring workflows, or internal tools.
- Run from the Apify UI, API, schedules, integrations, or MCP tools.

### Supported operations

- `overview`: DNS, registration, health, reputation, and popularity observations in one response.
- `whois`: Enhanced WHOIS and RDAP registration information, where available.
- `dns`: A selected DNS record type, including A, AAAA, MX, NS, TXT, SOA, CNAME, CAA, PTR, or SRV.
- `health`: Domain health and live web or mail configuration signals.
- `ssl-audit`: SSL certificate and HTTPS audit details.
- `technology`: Website technology detection with fast, rendered, or deep scan modes.
- `reputation`: Domain reputation signals and supporting details.
- `subdomains`: Discovered subdomains with optional DNS verification.
- `valuation`: An estimated domain value with available supporting factors.
- `availability`: Point-in-time domain availability status.

Results depend on the target, operation, available evidence, and current reachability. An unavailable or inconclusive check remains distinguishable from a confirmed result. A successful result is not a guarantee of ownership, legal identity, security, future availability, or commercial value.

### Quick start in Apify Console

1. Open the Actor's Input tab.
2. Enter one or more domains or URLs in **Domains or URLs**.
3. This Actor uses the fixed whois operation.
4. Review any settings for that operation, then start the Actor.
5. Open the Dataset to inspect or export one row per target.

A simple input looks like this:

```json
{
  "targets": [
    "example.com",
    "https://www.example.org"
  ],
  "operation": "whois",
  "maxConcurrency": 3
}
```

To perform different checks for the same targets, start separate runs with a different `operation` value.

### Output

The Actor writes one dataset item per target. A successful result may look like this:

```json
{
  "target": "example.com",
  "operation": "whois",
  "success": true,
  "statusCode": 200,
  "checkedAt": "2026-08-27T10:30:00.000Z",
  "registrar": "Example Registrar",
  "expiryDate": "2030-01-01T00:00:00.000Z",
  "reputationScore": 92,
  "reputationGrade": "A",
  "data": {
    "domain": "example.com",
    "health": {
      "dns_ok": true,
      "https_ok": true
    },
    "registration": {
      "registered": true,
      "registrar": "Example Registrar"
    }
  },
  "error": null
}
```

If a target cannot be completed, its row still identifies the target and operation:

```json
{
  "target": "invalid target",
  "operation": "dns",
  "success": false,
  "statusCode": 400,
  "checkedAt": "2026-08-27T10:30:00.000Z",
  "data": null,
  "error": {
    "code": "INVALID_TARGET",
    "message": "Each target must be a non-empty domain or HTTP(S) URL."
  }
}
```

The exact fields inside `data` vary by operation. The complete response is retained so you can use details beyond the normalized Actor columns. The run's key-value store also contains a `SUMMARY` record with requested, processed, successful, failed, and budget-skipped counts.

### Pricing

Successful results cost **$3 per 1,000 results**. Apify platform usage is charged separately. There is no startup fee, and failed results are not billed as successful results.

For example, a run with 100 successful target results costs $0.50 for Actor results, plus applicable Apify platform usage.

### Use cases

- Enrich a domain list before sales or market research.
- Review a portfolio for health, SSL, DNS, or reputation signals.
- Compare technology choices across websites.
- Collect subdomain intelligence for an authorized asset inventory.
- Screen domains during acquisition research.
- Check availability for a list of names.
- Feed structured domain results into spreadsheets, databases, AI agents, or internal applications.

Only use the Actor for domains and websites you are authorized to research. Results are intended for intelligence and research workflows, not as a substitute for legal, security, ownership, or compliance decisions.

### Limits and result interpretation

- Maximum 100 targets per run.
- One operation per run.
- Results are based on available evidence and the supplied target.
- Some domains, extensions, websites, or operations may return incomplete, unknown, or unavailable results.
- Rendered and deep technology scans can take longer than fast scans.
- Valuation is an estimate, not an appraisal or guaranteed sale price.
- Reputation and health results are signals, not a security certification.
- Availability is time-sensitive and should be confirmed before registration.
- Do not submit passwords, private credentials, payment data, or other sensitive information as targets.

### API example

Start the Actor synchronously and return its dataset items. Replace `YOUR_ACTOR_ID` and `YOUR_APIFY_TOKEN` with your values.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targets": ["example.com", "example.org"],
    "operation": "whois"
  }'
```

The asynchronous Run Actor endpoint is a better fit for longer jobs. When the run finishes, use the default Dataset to read or export the per-target records.

For response guidance and product details, visit the [DomScan API documentation](https://domscan.net/docs). To manage your DomScan account, visit the [DomScan dashboard](https://domscan.net/dashboard).

### Privacy and data handling

The Actor processes the domains or URLs you submit and returns intelligence associated with those targets. Submit only information you are permitted to process. Avoid placing personal, confidential, or sensitive data in target values.

Results may contain publicly observable domain and website information. Treat exported datasets according to your own privacy, security, retention, and access policies. DomScan does not establish that a domain is owned by a particular person or organization, and public information may be incomplete, outdated, or unavailable.

### Troubleshooting

**The run rejects my input.** Confirm that `targets` is an array with no more than 100 values, every value is a domain or public HTTP(S) URL, and `operation` is one of the supported values.

**Some rows have `success: false`.** Check the `error` object for the affected target. Invalid targets, unreachable websites, unavailable evidence, and inconclusive checks can fail while other rows succeed.

**Technology results are incomplete.** Try rendered or deep technology mode when the fast scan does not expose enough page behavior. These modes may take longer and may take longer than fast scans.

**Availability changed after the run.** Treat availability as a point-in-time result and confirm it before taking action.

**I need more detail.** Inspect the full `data` object in the Dataset row, then consult the [DomScan documentation](https://domscan.net/docs).

# Actor input Schema

## `targets` (type: `array`):

Domains or public HTTP(S) URLs to process. Up to 100 unique targets.

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

Number of targets processed at the same time.

## Actor input object example

```json
{
  "targets": [
    "example.com"
  ],
  "maxConcurrency": 3
}
```

# Actor output Schema

## `results` (type: `string`):

One structured row per processed target.

## `summary` (type: `string`):

Counts of requested, processed, successful, failed, and budget-skipped targets.

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

// Run the Actor and wait for it to finish
const run = await client.actor("narrative_karat/domscan-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 = { "targets": ["example.com"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,narrative_karat/domscan-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/larZvqhDwTu5mXPq3/builds/52SUsKOTPb3PQPyJs/openapi.json