# Domain to Company Resolver (`mikee368/domain-company-resolver`) Actor

Resolve a domain to a legal entity: RDAP, Impressum, company register and VAT, in one profile. Runs the lookups in one container.

- **URL**: https://apify.com/mikee368/domain-company-resolver.md
- **Developed by:** [Mike Berckmoes](https://apify.com/mikee368) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 domain resolveds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Domain to Company Resolver

One row per domain. The row joins RDAP (registrar and domain age), the website legal notice, a company-register match and a VAT check.

### What does Domain to Company Resolver do?

Give it a list of domains (a lead list, a supplier site, a name that just showed up). For each domain it:

1. Reads RDAP the same way as [Domain RDAP Lookup & Expiry Watch](https://apify.com/mikee368/domain-rdap-watch): registrar, created and expiry dates, domain age. Registrant and contact records are not stored.
2. Fetches the site and parses Impressum / Mentions légales / legal notice the same way as [EU Impressum Lookup](https://apify.com/mikee368/eu-impressum-lookup). Person names are not stored.
3. Looks up the legal name or register number in the same registers as [EU Company Register Lookup](https://apify.com/mikee368/eu-company-register-lookup).
4. Checks the VAT number with the same rules as [EU TIN & VAT Validator](https://apify.com/mikee368/eu-tin-vat-validator). Personal numbers are format-checked only.

If the legal notice has no company fields, the register and VAT steps are skipped. That keeps a dead site cheap.

### Why one run instead of calling the other Actors?

`Actor.call()` would start four more containers and add each Actor's own event price. A VAT check alone is $0.02 on the public validator, before RDAP ($0.0015), Impressum ($0.002) and the register ($0.003). This Actor **imports those functions and runs them here**. `RUN_SUMMARY.chain` is `in-process` and `childActorCalls` is 0. The other Actors are unchanged and are not billed.

Sitemap fetching is off unless you turn it on. A strong national register hit is not followed by a GLEIF name search.

### What does a profile contain?

| Field | Meaning |
|---|---|
| `domain`, `registered`, `registrar` | RDAP result. No registrant |
| `createdAt`, `expiresAt`, `domainAgeDays` | Registry dates. Some TLDs do not publish expiry |
| `legalName`, `legalForm`, `registerType`, `registerNumber` | From the legal notice, filled from the register when the match is strong |
| `registerSource`, `registerStatus`, `lei`, `registerCountry` | Register row |
| `vatNumber`, `vatValid`, `vatExistence` | `vatValid` is true only when the official source says the number exists |
| `matchConfidence` | 0–100 |
| `warnings` | See below |

Warnings include `unregistered`, `rdap_unsupported`, `rdap_unavailable`, `invalid_domain`, `no_register_match`, `name_mismatch`, `vat_invalid`, `vat_unverified`, `impressum_not_found`, `impressum_mismatch`, `impressum_fetch_error` and `impressum_robots`.

Some shops (for example `decathlon.fr`) answer the homepage with HTTP 403 from a datacenter address. The row still keeps the RDAP result and sets `impressum_fetch_error`. The register and VAT steps stay skipped, because there is no legal-notice company to look up.

`.io`, `.eu` and the other suffixes the RDAP Actor marks unsupported are not sent to a registry. The legal notice is still read when you leave that option on.

A RDAP 404 sets `registered` to false. It does not mean the name is free to register.

### How to run it

1. Paste domains under **Domains**. The default cap is 5 and the hard cap is 25.
2. Leave sitemap lookup off unless a first run reports `impressum_not_found`.
3. A Companies House key is optional and only used when the legal notice shows a UK company number.
4. Download the dataset. `RUN_SUMMARY` is in the key-value store.

An empty domain list finishes without charging and without any HTTP call.

### How much does a domain cost?

**Suggested pay-per-event price, not applied on this private Actor: $0.008 per `domain-resolved`.**

That sits in the $0.005–$0.01 range from the pricing notes. $0.005 is enough when many domains have no legal notice (the register and VAT steps are skipped). $0.01 matches a full chain. $0.008 is the single event to set when the Actor is monetized.

The event is one domain that was actually queried, including a negative result. A string that is not a domain is stored and is not charged. Platform compute is separate. The default run is 256 MB.

Do not add the child Actor prices on top. Those Actors are not called.

### Sources

RDAP, legal-notice pages, company registers and VIES are the sources already used by the four Actors above. No new data source was added.

Do not use this Actor to collect private individuals. A legal notice can name a sole trader; sole traders are dropped from the register step.

# Actor input Schema

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

Domains or URLs to resolve, one per line. Example: laposte.fr. Maximum 25 per run.

## `maxDomains` (type: `integer`):

Stop after this many domains. Maximum 25.

## `includeImpressum` (type: `boolean`):

Fetch the site and parse Impressum / Mentions légales / legal notice. Person names are never stored.

## `tryCommonPaths` (type: `boolean`):

If the homepage has no legal-notice link, try /impressum, /mentions-legales and the other common paths.

## `useSitemap` (type: `boolean`):

Off by default to keep the run small. Turn on when the legal page is not linked from the homepage.

## `delayMsPerRegistry` (type: `integer`):

Pause after each RDAP request to a registry. Default 1000 ms. Minimum 200 ms.

## `matchMode` (type: `string`):

How close the register name must be to the legal-notice name. strict keeps whole-word matches and better.

## `companiesHouseApiKey` (type: `string`):

Free key from developer.company-information.service.gov.uk. Without it a UK company number is not sent to Companies House.

## Actor input object example

```json
{
  "domains": [
    "laposte.fr"
  ],
  "maxDomains": 5,
  "includeImpressum": true,
  "tryCommonPaths": true,
  "useSitemap": false,
  "delayMsPerRegistry": 1000,
  "matchMode": "strict"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one row per domain

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

Counts, warning flags and the in-process chain note

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

// Run the Actor and wait for it to finish
const run = await client.actor("mikee368/domain-company-resolver").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": ["laposte.fr"] }

# Run the Actor and wait for it to finish
run = client.actor("mikee368/domain-company-resolver").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": [
    "laposte.fr"
  ]
}' |
apify call mikee368/domain-company-resolver --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mikee368/domain-company-resolver"
        }
    }
}
```

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/UwbrJBfrMJmVAgFdV/builds/132VCEGFefOBFC7QB/openapi.json