# Domain Availability & Expiry Checker: Bulk RDAP Lookup (`wisekit/domain-lookup`) Actor

Registration status, expiry date, domain age and registrar for your domain lists, or check names across many TLDs at once. Optional DNS, SPF and DMARC. $2 per 1,000 domains checked, failures free, free demo.

- **URL**: https://apify.com/wisekit/domain-lookup.md
- **Developed by:** [Wisekit](https://apify.com/wisekit) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 domain checkeds

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 Lookup: RDAP, Expiry, Registrar & DNS

Check whether domains are registered, who the registrar is and when each one expires, for **$2 per 1,000 domains checked** ($0.002 each), plus $1 per 1,000 if you add the DNS, SPF and DMARC check. No start fee, and domains that can't be checked are free.
Want to see the output first? Turn on **Free demo** in Options: six fictional sample rows, nothing looked up, no charge.

> **Use the results lawfully.** This Actor returns facts about domain registrations, never the registrant's or any other contact's name, email address, phone number or postal address. Don't use the results for unsolicited marketing; registry terms forbid it. Not affiliated with or endorsed by IANA, ICANN or any domain registry or registrar.

### What it does

You give it a list of domains (or URLs). For each one it asks the domain's registry through RDAP, the lookup service registries run to replace WHOIS, and gives you one tidy row:

- **Registered or likely available.** `registered` when the registry has a record, `likely_available` when it has none (confirm at a registrar before you rely on it; see below).
- **Registrar and dates.** The registrar company and its IANA id, the created, updated and expiry dates, and `daysUntilExpiry`, a whole number you can sort or filter on (negative once the domain has expired).
- **Health flags.** Registry status codes such as `client transfer prohibited` or `redemption period`, the nameservers held at the registry, and whether DNSSEC is on.
- **Alerts.** A short `alerts` list per row: expiring within 30 days (or your `expiringWithinDays`), already expired, a problem status code, a failed lookup, and with DNS on, missing SPF or DMARC, `+all`, more than one SPF record or a DMARC policy of `none`.
- **One name, many extensions.** Give `names` and `tlds` (for example `mybrand` with com, ai, app, dev) and every combination is checked: the quick way to find a free domain for a new brand.
- **Domain age and an expiry window you choose.** `domainAgeDays` from the registration date, and `expiringSoon` for domains that expire within `expiringWithinDays` (30 by default, up to 3,650).
- **Optional DNS check.** With `includeDns` on you also get the A, AAAA, MX, NS and TXT records, the SPF record broken into its parts and the DMARC policy, read with the standard DNS system.

Results land in two tables: **Overview** (every domain) and **Expiry and problems** (the expiry date, days left and alerts first), plus a `SUMMARY` record with counts per status.

### Who uses it

- **Agencies and IT teams** who look after many client domains and want a monthly list of what expires soon, what is stuck in redemption and which domains have no DMARC policy.
- **Brand and portfolio owners** who keep dozens of defensive registrations and need one place to see registrar, expiry and lock status.
- **Name hunters and founders** who want to know which ideas on a shortlist are likely free before they go to a registrar.
- **Email deliverability checks**: run your sending domains with DNS on and look for missing SPF or DMARC.
- **Developers and AI agents** who need structured domain facts in a pipeline through the API or MCP.

### How to use it

1. Paste your domains into **Domains**, one per line. Full URLs are fine: `https://www.shop.example.com/page` is looked up as `example.com`. Duplicates are merged.
2. Optional: tick **Also check DNS, SPF and DMARC** in Options (+$0.001 per domain).
3. Optional: set **Max domains to check** to cap how many domains (and so how much money) one run can use.
4. Click **Start**. The prefilled two domains finish in a few seconds.
5. Open the **Expiry and problems** view to see what needs attention, or export everything as CSV, Excel or JSON.

New here? Turn on **Free demo** first. It shows six fictional rows covering every kind of result (registered, expiring, expired, likely available, not checkable) so you can see the columns before you spend anything.

### Input

| Field | Default | Notes |
|---|---|---|
| `domains` | (none) | Domains or URLs, one per line. Up to 1000 per run (10 on the Apify free plan). `www.` and other subdomains are reduced to the registrable domain. Give `domains`, `names`, or both. |
| `names` | (none) | Names without an extension, for example `mybrand`. Each is checked with every TLD in `tlds`, on top of `domains`. Up to 200 names; the generated domains count toward the limits above and cost the same as any domain. |
| `tlds` | `com, net, org` | Extensions to try for every name ("com", ".ai", "app"). Up to 50. Extensions whose registry isn't checked (for example .io, .co, .xyz, .shop, .co.uk) come back as not checkable, free. No extra cost. |
| `includeDns` | `false` | Also check DNS, SPF and DMARC (+$0.001 per domain whose DNS check finishes). |
| `maxDomains` | `1000` | The most domains this run looks up. Domains beyond it come back as `skipped_max_domains`, free. No extra cost. |
| `demo` | `false` | Six fictional sample rows, no lookups, no charge. |
| `expiringWithinDays` | `30` | A registered domain that expires within this many days gets `expiringSoon` true and an alert. 0 to 3,650. Every domain is still returned and charged the same. No extra cost. |
| `maxConcurrency` | `10` | 1 to 20 domains in parallel across different registries. No extra cost. |

Example input: `{"domains": ["example.com", "apify.com"], "includeDns": true}`

### Sample output (from the free demo, fictional domains)

| domain | status | registrar | daysUntilExpiry | alerts | SPF | DMARC |
|---|---|---|---|---|---|---|
| demo-shop-sample.com | `registered` | Example Registrar, LLC | 21 | expires in 21 days | -all | reject |
| demo-brand-sample.org | `registered` | Sample Domains Inc. | 400 | no DMARC record | ~all | (none) |
| demo-old-store-sample.net | `registered` | Example Registrar, LLC | -12 | expired 12 days ago; status: redemption period; no SPF record; no DMARC record | (none) | (none) |
| demo-new-idea-sample.com | `likely_available` | | | | | |
| demo-cafe-sample.de | `unsupported_tld` | | | DMARC policy is none (monitoring only) | ~all | none |
| demo-agency-sample.co.uk | `unsupported_tld` | | | | -all | quarantine |

One full row looks like this:

```json
{
  "domain": "demo-shop-sample.com",
  "status": "registered",
  "summary": "Demo (fictional data): Registered with Example Registrar, LLC; expires 2026-12-08 (in 21 days); created 2017-04-18; DNSSEC on.",
  "registrar": "Example Registrar, LLC",
  "registrarIanaId": 9999,
  "createdAt": "2017-04-18T00:00:00.000Z",
  "expiresAt": "2026-12-08T00:00:00.000Z",
  "daysUntilExpiry": 21,
  "domainStatus": ["client transfer prohibited"],
  "nameservers": ["ns1.dns-host.example", "ns2.dns-host.example"],
  "dnssec": true,
  "alerts": ["expires in 21 days"],
  "rdapServer": "https://rdap.registry.example/",
  "retryable": false,
  "demo": true
}
```

### What you get per domain

| Field | What it is |
|---|---|
| `status`, `summary` | `registered`, `likely_available`, or why the domain wasn't checked, and a one-line summary |
| `registrar`, `registrarIanaId` | The registrar (a company) and its IANA id, when the registry publishes them |
| `createdAt`, `updatedAt`, `expiresAt`, `daysUntilExpiry` | Registration dates (ISO 8601) and whole days until expiry (negative once past) |
| `domainAgeDays` | Whole days since the domain was registered, when the registry publishes the date |
| `expiringSoon` | `true` when the domain expires within `expiringWithinDays` days (default 30); `null` when no expiry date is published |
| `domainStatus` | Registry status codes, such as `client transfer prohibited` or `redemption period` |
| `nameservers`, `dnssec` | Nameservers held at the registry, and whether the delegation is signed |
| `alerts` | Things worth a look: expiry within `expiringWithinDays` (30 by default), expired, problem status codes, failed lookups, SPF or DMARC gaps |
| `rdapServer` | The registry server that answered |
| `retryable` | `true` when running the domain again later may give a result |
| `demo` | `true` only on the fictional demo rows |

With `includeDns`: `dnsStatus`, `aRecords`, `aaaaRecords`, `mxRecords`, `nsRecords`, `txtRecords`, `spfPresent`, `spfMechanisms`, `spfIncludes`, `spfAllQualifier`, `spfMultipleRecords`, `dmarcPresent`, `dmarcPolicy`, `dmarcSubdomainPolicy`, `dmarcPct`, `dmarcAlignmentDkim`, `dmarcAlignmentSpf`, `dmarcReportDomains` (the domains that receive DMARC reports; never the mailbox).

### "Likely available" means: confirm at a registrar

`likely_available` means the registry's RDAP service has no record of the domain (HTTP 404). That is a strong sign the name is free, but RDAP is not the registry's booking system: reserved, premium, blocked or just-deleted names can also have no record and still not be registrable at the normal price. Always confirm at a registrar before you rely on it.

### Which domains can be checked

Only registries whose RDAP terms we have read and that don't forbid this kind of use are asked. Today that is:

- **Verisign**: .com and .net.
- **Public Interest Registry**: .org, .ngo, .ong, .charity, .foundation, .gives, .giving.
- **Identity Digital**: about 450 TLDs, including .info, .ai, .live, .pro, .mobi, .asia, .life, .company, .agency, .digital, .email, .group, .media, .news, .shopping, .software, .studio, .tools and .travel.
- **Google Registry**: .app, .dev, .page, .new, .how, .day, .foo, .zip, .mov and the other Google TLDs.
- **Radix**: .online, .site, .store, .tech, .website, .space, .fun, .host, .press, .pw, .uno.
- **SIDN**: .nl.
- **AFNIC**: .fr.

Everything else comes back as `unsupported_tld`, **free**, with the reason in `message`:

- **.au, .uk and .no domains are not checked**, nor the other TLDs run from the .uk registry's servers (.wales, .cymru and others), because their registries' terms don't allow automated lookups or commercial reuse of their data.
- Registries whose terms don't allow storing or passing on the data (CentralNic, which runs .xyz and about 90 others, and GoDaddy Registry, which runs .club and others) are not checked.
- Registries we haven't reviewed yet (for example .shop, .biz, .top, .cc, .tv, .ca, .pl, .cz, .in and .br) are not checked for now. We add registries as their terms are reviewed; tell us which ones you need.
- TLDs with no RDAP service in IANA's list (.de, .io, .co, .me, .eu, .us, .ch, .it, .es, .jp and others at the time of writing) are not checked. We never fall back to WHOIS or other lookup sites.

**The DNS check works for every domain.** With `includeDns` on, domains whose registry isn't checked still get the DNS check, and it is charged at $0.001 when it finishes (the registry part stays free). It shows whether the name has nameservers, mail servers, SPF and DMARC in DNS; it is DNS data, not registry data, so it can't tell you who the registrar is or when the domain expires.

### Pricing

**$0.002 per domain checked** (pay per event `domain-checked`), charged only when the registry answered: `registered` or `likely_available`.
**$0.001 per DNS check** (pay per event `dns-checked`), only when `includeDns` is on and the DNS check finished, including for domains whose registry isn't checked.

No start fee. Free: `unsupported_tld`, `rate_limited`, `error`, `invalid_input` and the `skipped_*` statuses, and the demo. Your maximum charge per run is respected, counting domains still being checked, and `maxDomains` caps a run in domains instead of dollars.

**Example 1: monthly expiry check of a 500-domain portfolio, no DNS.** 470 domains are .com, .net, .org and other checked TLDs, 30 are .de and .co.uk. You pay 470 × $0.002 = **$0.94**; the 30 unsupported rows are free.

**Example 2: email health check of 200 client domains with DNS.** 180 are on checked registries, 20 are .com.au. Lookups: 180 × $0.002 = $0.36. DNS checks that finish: 200 × $0.001 = $0.20 (the .com.au domains get the DNS check too). Total **$0.56**, or less if some DNS checks fail (failed DNS checks are free).

#### What the price buys, compared with cheaper options

You can find free WHOIS websites and Store Actors that charge less per lookup. Here is what this one does for its price, so you can judge if it is worth it for you:

- No start fee and no charge for failures, rate limits, unsupported domains or skipped domains: you pay only for answers.
- It only asks registries whose terms don't forbid this kind of use, one request per second per registry, to keep the chance of being blocked low. If a registry still asks us to stop, those domains come back free.
- It never returns personal contact data, so the dataset contains no personal contact data.
- Clean, typed fields (`daysUntilExpiry`, `alerts`) ready for a spreadsheet filter or an automation, plus a ready "Expiry and problems" view.
- A free demo and a `maxDomains` cap, so you know the most a run can cost before you start.

If you only need a handful of lookups once, a free WHOIS site is fine. This Actor is for lists you check again and again.

### How it treats the registries

- One request at a time per registry, at least 1 second apart. A list of 1000 .com domains therefore takes about 17 minutes; domains on different registries run in parallel.
- When a registry answers "too many requests" (HTTP 429), that registry is paused for the time it asks, up to 15 seconds. If it asks for a longer pause, or answers 429 three times in one run, it is left alone for the rest of the run, and its remaining domains come back as `rate_limited`: free, and you can run them again later.
- Redirects are never followed: a registry that redirects the lookup gives an `error` row, free.
- No proxies, no IP rotation, no WHOIS scraping. Every request carries an honest User-Agent, `WisekitDomainLookup/1.0`, that names this Actor.
- Only the registry's answer for the domain itself is read; the registrar's own server is never queried. The list of RDAP servers is read once per run.

### What it never does

- No registrant, administrative, technical, billing or abuse contact data: names, email addresses, phone numbers and postal addresses are dropped before anything is saved, even when a registry publishes them.
- No full DMARC report addresses: only their domain part. Email addresses in TXT records are replaced with `[email removed]`.
- Your results stay in your own Apify dataset. We keep no copy and share no lookups between users; the run log shows counts and statuses only.

### Status values

`registered`, `likely_available`, `unsupported_tld`, `rate_limited`, `error`, `invalid_input`, `skipped_max_charge`, `skipped_max_domains`, `skipped_plan_limit`, `skipped_run_limit`. Only `registered` and `likely_available` are charged.

### Monitor expiry on a schedule

1. Run the Actor once with your domain list and the options you want, then choose **Save as a new task**.
2. In Apify Console go to **Schedules**, create a schedule (for example every Monday at 07:00, cron `0 7 * * 1`) and add the task.
3. Add an integration to the task (email, Slack, Google Sheets, Zapier, Make or a webhook) so each finished run sends you the dataset, or open the **Expiry and problems** view after each run.
4. Filter on `daysUntilExpiry` below 30, or on rows where `alerts` is not empty.

A weekly check of 200 domains on checked registries costs about 200 × $0.002 = $0.40 per run, about $1.73 a month.

### Use it through the API or MCP

Run it and get the rows back in one call (replace `<YOUR_API_TOKEN>` with your Apify API token):

```bash
curl -X POST "https://api.apify.com/v2/acts/wisekit~domain-lookup/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["example.com", "apify.com"], "includeDns": true}'
```

For AI agents (Claude, Cursor and other MCP clients), add Apify's MCP server with this Actor as a tool: `https://mcp.apify.com/?actors=wisekit/domain-lookup`. The input is plain JSON, for example `{"domains":["example.com"]}`, and every row has a one-line `summary` an agent can read directly.

### FAQ

**Is it legal to use?** The Actor reads the public RDAP answers registries provide for domain lookups, only from registries whose terms don't forbid this kind of use, at a slow and honest rate, and it drops all personal contact data. How you use the results is up to you: checking your own or your clients' domains, research and security work are typical uses; sending unsolicited marketing to domain owners is not allowed. This is not legal advice; if you are unsure about your use, ask a lawyer.

**Why is my .de, .co.uk or .xyz domain "unsupported"?** See "Which domains can be checked": either IANA lists no RDAP service for it, or the registry's terms don't allow this use, or we haven't reviewed them yet. Those rows are free.

**Why "likely" available?** RDAP shows registrations, not what a registrar will sell you. Reserved and premium names can have no record. Confirm at a registrar.

**Why is a domain `rate_limited`?** The registry asked us to slow down and we stopped asking it for this run. The row is free; run those domains again later.

**How fast is it?** About one domain per second per registry. Mixed lists run several registries in parallel; 1000 .com domains take about 17 minutes.

**Can I see the WHOIS owner?** No. Contact data is never returned.

**What if I'm on the Apify free plan?** Free-plan runs check up to 10 domains; the rest come back as `skipped_plan_limit`, free.

### Other Wisekit Actors

- [AI Visibility Tracker](https://apify.com/wisekit/ai-search-visibility-tracker): see whether ChatGPT, Perplexity, Gemini and Claude mention your brand.
- [Product, Price & Stock Monitor for Shopify Stores](https://apify.com/wisekit/product-price-monitor): track products, prices and stock on Shopify stores.
- [Store Qualifier for Shopify Stores](https://apify.com/wisekit/store-qualifier): country, catalogue size and price range of Shopify stores.

### Feedback and support

Found a wrong result, need a registry added, or want a field? Open an issue on the Actor's **Issues** tab. We read every issue and aim to reply within one working day. Include the domain and the run ID if you can.

### Changelog

- **0.3 (18 Nov 2026)**: names × TLDs mode (`names`, `tlds`); `domainAgeDays`; `expiringWithinDays` with an `expiringSoon` flag. Same prices.
- **0.2 (17 Nov 2026)**: only registries whose terms allow it are checked (allow-list); .no added to the excluded registries; redirects are never followed; a registry asking for more than a 15-second pause is left alone for the run; free demo mode; `maxDomains` cap; `alerts` field and the "Expiry and problems" view.
- **0.1 (17 Nov 2026)**: first version: RDAP lookup, expiry and registrar, optional DNS, SPF and DMARC check.

# Actor input Schema

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

Domains to look up, one per line (or use Names and TLDs below; at least one is needed): a bare domain ("example.com") or any URL (only its registrable domain is used, so "https://www.shop.example.com/page" is looked up as "example.com"). Up to 1000 per run (10 on the Apify free plan). Duplicates are merged. Checked registries: .com, .net, .org, the Identity Digital, Google Registry and Radix TLDs, .nl and .fr; .au, .uk and .no domains are not checked, and other domains come back as not checkable, free. Agent example: {"domains":\["example.com","apify.com"]}.

## `names` (type: `array`):

Optional. Brand or product names without an extension, e.g. "mybrand". Each name is checked with every TLD in "TLDs" (mybrand.com, mybrand.ai, ...), on top of the domains above. Up to 200 names; the generated domains count toward the per-run and maxDomains limits and cost the same as any domain ($0.002 per domain checked). Only checked registries answer: .com, .net, .org, .ai, .app, .dev, .info, .online, .store, .tech and the other TLDs of the registries listed in the README; others (for example .io, .co, .xyz, .co.uk) come back as not checkable, free. Example: \["mybrand"].

## `tlds` (type: `array`):

The extensions to try for every name above, without or with a dot: "com", ".ai", "app". Up to 50. Leave empty for com, net and org. Ignored without names. No extra cost beyond the domains checked. Example: \["com", "ai", "app", "dev"].

## `includeDns` (type: `boolean`):

Also look up the domain's DNS records with the standard DNS system: A, AAAA, MX, NS and TXT, plus the SPF and DMARC email-authentication policies, parsed. Costs $0.001 per domain whose DNS check finishes (event dns-checked), on top of the lookup. Runs for registered domains and also for domains whose registry isn't checked (for example .de or .co.uk), so those can be charged the DNS price. Example: true. Default off.

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

The most domains this run looks up (1 to 1000). Domains beyond it come back as skipped_max_domains and are free, so this also caps the cost: at most $0.002 per domain, or $0.003 with DNS. No extra cost. Example: 100. Default 1000.

## `demo` (type: `boolean`):

Shows six fictional sample rows (registered, expiring, expired, likely available, not checkable), with DNS fields if the DNS option is on. Nothing is looked up and nothing is charged; the domains you entered are ignored. Example: true. Default off.

## `expiringWithinDays` (type: `integer`):

A registered domain whose expiry date is 0 to this many days away gets expiringSoon true and an "expires in N days" alert, and shows in the "Expiry and problems" view. Every domain is still output and charged the same; this only sets the flag. 0 to 3650. No extra cost. Example: 90. Default 30.

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

How many domains are worked on at the same time across different registries (1 to 20). No extra cost. Each registry still gets at most one request at a time, at least 1 second apart, so a list on one registry (for example all .com) runs at about 1 domain per second whatever this is set to. Example: 10. Default 10.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "apify.com"
  ],
  "includeDns": false,
  "maxDomains": 1000,
  "demo": false,
  "expiringWithinDays": 30,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `domains` (type: `string`):

One row per domain: status, one-line summary, registrar, created, updated and expiry dates, days until expiry, status codes, nameservers, DNSSEC and, if asked for, DNS, SPF and DMARC.

## `problems` (type: `string`):

The same rows with days to expiry and alerts first (expiring within 30 days, expired, problem status codes, missing SPF or DMARC).

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

Counts only: domains by status, requests per registry and rate-limit answers.

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

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

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

```

## MCP server setup

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

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/GZKvM7KuHDP6TbyKM/builds/JtQdxc6YaPQfueK3j/openapi.json
