# WHOIS Company Intelligence API (`technicaldost/whois-company-intelligence-api`) Actor

Combine public WHOIS/RDAP domain registration data with company website business metadata in one API call. Ideal for lead enrichment and B2B prospecting.

- **URL**: https://apify.com/technicaldost/whois-company-intelligence-api.md
- **Developed by:** [Technical Dost Solutions](https://apify.com/technicaldost) (community)
- **Categories:** Lead generation, Developer tools, Business
- **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 lookups

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Company Intelligence API

### What this Actor does

For each domain you provide, this Actor combines public domain registration data (WHOIS via the public RDAP protocol) with the company's own public website business metadata into one clean, enriched record.

It looks up registrar, registration/update/expiry dates, nameservers, registrant organization and country, and domain status from RDAP. When website enrichment is enabled, it also reads the company's public homepage for its title, description, Organization name, and public social profile links. Each domain produces exactly one dataset row, with source attribution, a confidence score, and a list of missing fields.

### Why this Actor is useful

Sales, marketing, and research teams use domain-to-company enrichment to qualify leads, dedupe accounts, detect newly registered competitors, and append firmographic context to spreadsheets and CRMs. This Actor turns a list of domains into an API-ready dataset without manual lookups.

### Who this is for

- B2B sales and lead-generation teams
- Growth and demand-generation marketers
- Sales and revenue operations
- Data enrichment and list-building teams
- Competitive intelligence analysts
- Anti-fraud and due-diligence researchers

### Common use cases

- Enrich a list of domains with registrar and registration data
- Append company name, description, and social links to leads
- Detect newly registered or recently updated domains
- Build account-level firmographic datasets for outreach
- Add domain-age and registrant signals to lead scoring

### How it works

- WHOIS / registration data comes from the public RDAP service at `https://rdap.org/domain/{domain}` (the modern, structured successor to WHOIS).
- Company business metadata comes only from the company's own public homepage (HTML `<title>`, meta description, schema.org `Organization` JSON-LD, and public social profile links).
- Each request uses a timeout, and a failure in one domain or one source never stops the whole run.

### Input

- `domains`: List of domains to enrich. Accepts bare hostnames or full URLs (protocol and path are stripped automatically). Required.
- `enrichFromWebsite`: When true (default), also fetch the public homepage and read its public business metadata.
- `maxItems`: Maximum number of dataset rows to save.
- `maxConcurrency`: How many domains to process at once. The default is intentionally conservative.
- `requestTimeoutSecs`: Maximum time to spend on a single RDAP or website request.
- `proxyConfiguration`: Optional Apify proxy configuration where permitted by your compliance process.

### Output

- `domain`: The normalized domain that was looked up.
- `registrar`: Registrar name from RDAP.
- `createdDate`: Domain registration date from RDAP.
- `updatedDate`: Last-changed date from RDAP.
- `expiryDate`: Expiration date from RDAP.
- `nameservers`: Nameserver hostnames from RDAP.
- `registrantOrganization`: Registrant organization from RDAP (often redacted by privacy services).
- `registrantCountry`: Registrant country from RDAP when published.
- `domainStatus`: EPP/RDAP status codes for the domain.
- `companyName`: Organization name from the homepage's structured data when enrichment is enabled.
- `companyDescription`: Public meta description from the homepage.
- `websiteTitle`: The homepage `<title>`.
- `socialProfiles`: Public social profile links found on the homepage.
- `sourceUrl`: The homepage URL used for enrichment.
- `detectedAt`: Timestamp when this Actor produced the row.
- `dataSources`: Which sources succeeded, e.g. `["rdap","website"]`.
- `confidenceScore`: Heuristic confidence based on how many sources succeeded and how complete the key fields are.
- `missingFields`: Which of the key fields (`registrar`, `createdDate`, `companyName`) were not available.

### Sample input

```json
{
  "domains": [
    "apify.com"
  ],
  "enrichFromWebsite": true,
  "maxItems": 50,
  "maxConcurrency": 3,
  "requestTimeoutSecs": 30
}
````

### Sample output

```json
{
  "domain": "apify.com",
  "registrar": "Gandi SAS",
  "createdDate": "2015-12-21T13:21:34Z",
  "updatedDate": "2024-11-19T09:14:02Z",
  "expiryDate": "2025-12-21T13:21:34Z",
  "nameservers": [
    "albert.ns.cloudflare.com",
    "lola.ns.cloudflare.com"
  ],
  "registrantOrganization": "Apify Technologies s.r.o.",
  "registrantCountry": "CZ",
  "domainStatus": [
    "client transfer prohibited"
  ],
  "companyName": "Apify",
  "companyDescription": "Apify is the platform where developers build, deploy, and publish web scraping and automation tools.",
  "websiteTitle": "Apify: Full-stack web scraping and data extraction platform",
  "socialProfiles": [
    "https://twitter.com/apify",
    "https://www.linkedin.com/company/apifytech",
    "https://github.com/apify"
  ],
  "sourceUrl": "https://apify.com",
  "detectedAt": "2026-06-27T00:00:00.000Z",
  "dataSources": [
    "rdap",
    "website"
  ],
  "confidenceScore": 1,
  "missingFields": []
}
```

### How to use

Run this Actor on Apify with a list of domains, export the dataset as JSON, CSV, or Excel, or pull it through the Apify API. Connect the output to Google Sheets, Make, Zapier, a webhook, or your CRM. For recurring enrichment, save the input as an Apify task and schedule runs.

### Pricing

This Actor is designed for a pay-per-event model at **$0.003 per lookup** (one event per domain enriched). You pay only for the domains you process.

### Best practices

- Provide clean domains; full URLs are accepted and normalized automatically.
- Keep `maxConcurrency` low to be gentle on RDAP and origin servers.
- Treat redacted registrant fields as expected, not as errors.
- Use `missingFields` and `confidenceScore` to filter records in downstream workflows.

### Compliance and responsible use

- **WHOIS data is sourced only from the public RDAP protocol** (`rdap.org`), which exposes registration data that registries and registrars publish for public access. Many registrants are redacted for privacy (for example under GDPR); this Actor reports those fields as missing rather than inferring them.
- **Company metadata is read only from the company's own public homepage** — the public HTML title, meta description, schema.org `Organization` data, and public social profile links. No login, paywall, CAPTCHA, or access-control bypass is performed.
- **Crunchbase, LinkedIn, and similar proprietary databases are NOT scraped.** Those platforms require their own licensed APIs and have their own terms. This Actor does not access, scrape, or resell their data. Any "company intelligence" here is derived solely from public RDAP records and the company's own public website.
- This Actor is for public data only. It must not be used to gather sensitive personal data, support spam or abuse, or violate applicable laws or source terms. You are responsible for your use of the output.

### Limitations

- Registrant organization and country are frequently redacted by privacy/proxy services and will appear as missing.
- RDAP coverage and field availability vary by TLD and registry; some TLDs expose less data than others.
- Website metadata quality depends entirely on what the company publishes on its public homepage. Sites without structured data or meta tags will have fewer enriched fields.
- This Actor reads only the homepage, not deep crawls of a site.
- It does not provide funding, headcount, revenue, or other proprietary firmographics that require licensed third-party databases (such as Crunchbase or LinkedIn).
- Markup, RDAP availability, and access policies can change over time.

### Troubleshooting

- Empty registrar/dates usually mean the RDAP service had no record or the TLD exposes limited data.
- Empty company fields usually mean the homepage has no structured data or meta description, or enrichment was disabled.
- Slow runs can usually be improved by lowering `maxConcurrency` or `requestTimeoutSecs`.
- Missing fields reflect source-data limitations, not invented values.

### Changelog

- v0.1.0: Initial release combining public RDAP registration data with public website business metadata.

# Actor input Schema

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

List of domains to enrich. Accepts bare hostnames or full URLs (the protocol and path are stripped automatically). Use only domains you are permitted to research.

## `enrichFromWebsite` (type: `boolean`):

Also fetch the company's public homepage and read its public business metadata (title, description, Organization name, social profile links).

## `maxItems` (type: `integer`):

Maximum number of dataset rows to save. The Actor stops processing new domains when this limit is reached.

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

How many domains to process at once. Lower this to be gentler on RDAP and origin servers.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to spend on a single RDAP or website request before it is treated as failed.

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

Optional Apify proxy configuration. Use only where permitted by your compliance process.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "enrichFromWebsite": true,
  "maxItems": 50,
  "maxConcurrency": 3,
  "requestTimeoutSecs": 30
}
```

# 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": [
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("technicaldost/whois-company-intelligence-api").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": ["apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("technicaldost/whois-company-intelligence-api").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": [
    "apify.com"
  ]
}' |
apify call technicaldost/whois-company-intelligence-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=technicaldost/whois-company-intelligence-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WHOIS Company Intelligence API",
        "description": "Combine public WHOIS/RDAP domain registration data with company website business metadata in one API call. Ideal for lead enrichment and B2B prospecting.",
        "version": "0.1",
        "x-build-id": "yfIqClPrvWPHZ8hI6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/technicaldost~whois-company-intelligence-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-technicaldost-whois-company-intelligence-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/technicaldost~whois-company-intelligence-api/runs": {
            "post": {
                "operationId": "runs-sync-technicaldost-whois-company-intelligence-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/technicaldost~whois-company-intelligence-api/run-sync": {
            "post": {
                "operationId": "run-sync-technicaldost-whois-company-intelligence-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "List of domains to enrich. Accepts bare hostnames or full URLs (the protocol and path are stripped automatically). Use only domains you are permitted to research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichFromWebsite": {
                        "title": "Enrich from website",
                        "type": "boolean",
                        "description": "Also fetch the company's public homepage and read its public business metadata (title, description, Organization name, social profile links).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of dataset rows to save. The Actor stops processing new domains when this limit is reached.",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many domains to process at once. Lower this to be gentler on RDAP and origin servers.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time to spend on a single RDAP or website request before it is treated as failed.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Use only where permitted by your compliance process."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```