# Domain Age Checker (`automation-lab/domain-age-checker`) Actor

Check domain age and registration dates in bulk using RDAP — the modern WHOIS replacement. Returns registration date, expiration date, registrar, nameservers, and age in days/years. Ideal for SEO analysis, fraud detection, and domain research.

- **URL**: https://apify.com/automation-lab/domain-age-checker.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, SEO tools, Lead generation
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 46 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 4.00 out of 5 stars

## Pricing

from $0.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Age Checker

Check domain registration age and dates using RDAP protocol.

### What does Domain Age Checker do?

**Domain Age Checker** retrieves domain registration data using the RDAP (Registration Data Access Protocol) -- the modern, structured replacement for WHOIS. It returns the registration date, expiration date, registrar, nameservers, domain status, and calculates the domain age in both days and years. Configurable risk fields also flag newly registered and soon-to-expire domains without downstream formulas. Supports .com, .net, .org, .io, .dev, .app, and many other TLDs.

Use it for domain research, SEO analysis, fraud detection, competitive intelligence, or any workflow that needs to know how long a domain has been registered. The structured JSON output makes it easy to filter, sort, and analyze domain age data at scale.

### Server API: check a domain over HTTP

Domain Age Checker is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each lookup. Copy the server URL from the Actor's **Server** tab (do not build it from the Actor name) and authenticate with your Apify token. Use normal Actor runs for long domain lists.

```bash
curl -sS "$SERVER_URL/domain?domain=google.com" -H "Authorization: Bearer $APIFY_TOKEN"
curl -sS "$SERVER_URL/domains" -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' -d '{"domains":["google.com","apify.com"],"newDomainThresholdDays":90}'
```

| Method and path | Input | Output and charge |
| --- | --- | --- |
| `GET /` | None | `ready: true`, the routes and limits; no lookup or charge |
| `GET /domain` | Query `domain` (a URL or `www.` prefix is stripped), optional `newDomainThresholdDays` and `expirationWarningDays` (0–36500, defaults 90 and 30) | `{ok,count,results}` with the same record as a dataset item; one Domain checked event when the record has a registration date; no start fee |
| `POST /domains` | JSON `domains` (1–10 names; duplicates checked once), optional `newDomainThresholdDays` and `expirationWarningDays` | `{ok,count,results}` with one record per registered domain, in input order; one Domain checked event per returned domain with a registration date; no start fee |

Unregistered and failed domains are left out of `results` and are not charged; when no domain is found, the answer is an error and free. A .de record has no registration date (see below), so it is returned free. Bodies must be JSON and at most 4096 bytes. Each request has a 30-second deadline and a 64 KiB response cap, and one server works on at most eight requests at once. Nothing caller-specific is cached; the public IANA list of registry servers is reused for up to six hours. Errors use `{ "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }`: 400 invalid domain, list, threshold or JSON; 402 spending limit; 404 `DOMAIN_NOT_FOUND` (unregistered), `TLD_NOT_SUPPORTED` (no public RDAP registry), `NO_RESULTS` (several domains, none found) or unknown route; 405 wrong method; 413 size limit; 415 media type; 429 registry rate limit; 502 registry or charging failure; 503 server busy or stopping; 504 timeout. Retry only when `retryable` is true. A successful answer can carry `warning: { code: "CHARGE_INCOMPLETE" }` when only part of its charge went through; you are charged only for what went through. The Server tab shows the full OpenAPI description.

### Technical SEO monitoring workflow

Use Domain Age Checker as the domain-registration step in a technical SEO audit. It checks registration date, age, expiration date, registrar, nameservers, and status codes for each domain you submit. Domain age itself is a point-in-time lookup, while expiration dates and registrar data can be rechecked on a schedule for portfolio or vendor monitoring.

For a complete domain, redirect, robots.txt, and sitemap workflow, combine it with:

- [Redirect Chain Analyzer](https://apify.com/automation-lab/redirect-chain-analyzer) to verify HTTP-to-HTTPS, www/non-www, redirect loops, final URLs, and 301/302 behavior.
- [Robots.txt & Sitemap Analyzer](https://apify.com/automation-lab/robots-sitemap-analyzer) to check crawl rules, sitemap declarations, crawl-delay directives, and sitemap URL counts.
- [Sitemap URL Extractor](https://apify.com/automation-lab/sitemap-url-extractor) to export the URLs listed in XML sitemaps for inventory or migration planning.
- [Sitemap Diff Tool](https://apify.com/automation-lab/sitemap-diff-tool) to compare two sitemap versions and find added, removed, or metadata-changed URLs.

### Who is it for?

- 🔍 **SEO specialists** — evaluating domain age as a ranking and authority signal when auditing backlink profiles or vetting link prospects
- 🛡️ **Fraud investigators** — flagging newly registered domains associated with phishing, spam, or impersonation campaigns
- 🏢 **Domain investors** — assessing domain value based on registration history and expiration timing before making purchase decisions
- 📊 **Brand protection teams** — detecting suspicious lookalike domains registered recently and monitoring for cybersquatting
- 📋 **Compliance analysts** — verifying domain registration longevity as part of vendor and partner due diligence
- 🔬 **Competitive researchers** — determining when competitors registered their domains and tracking new market entrants

### Why use Domain Age Checker?

- **Modern RDAP protocol** — uses the structured RDAP API instead of legacy WHOIS text parsing, providing more reliable results
- **Age calculation built in** — returns age in both days and years, so you do not need to calculate it yourself
- **Actionable risk flags** — get `isNewDomain`, `daysUntilExpiration`, and `expiresSoon` using thresholds you control
- **Expiration tracking** — see when a domain expires to catch upcoming renewals or acquisition opportunities
- **Batch processing** — check hundreds of domains in a single run
- **Broad TLD support** — works with .com, .net, .org, .io, .dev, .app, and many other top-level domains
- **Pay-per-event pricing** — costs scale with actual usage, just $0.001 per domain checked
- **Structured JSON output** — parsed fields ready for filtering, sorting, and integration with downstream tools

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `domains` | string\[] | Yes | — | List of domains to check age for. Enter bare domain names (e.g., `google.com`). |
| `newDomainThresholdDays` | integer | No | `90` | Set `isNewDomain` to `true` when age is less than or equal to this many complete days (0–36,500). |
| `expirationWarningDays` | integer | No | `30` | Set `expiresSoon` to `true` when expiry is this many complete days away or less (0–36,500), including expired domains. |

#### Example input

```json
{
    "domains": [
        "google.com",
        "github.com",
        "example.com"
    ],
    "newDomainThresholdDays": 90,
    "expirationWarningDays": 30
}
```

### Recurring site-audit workflow

Domain age rarely changes, but expiration dates and registrar data are worth monitoring for portfolios, vendor lists, and suspicious-domain watchlists. Save your `domains` input and schedule it monthly for normal audits, or weekly for domains close to expiry.

Example monthly monitoring input:

```json
{
    "domains": [
        "example.com",
        "vendor-site.com",
        "competitor.com"
    ]
}
```

For a broader website audit bundle, combine the results with [SSL Certificate Checker](https://apify.com/automation-lab/ssl-certificate-checker) for certificate expiry, [Sitemap URL Extractor](https://apify.com/automation-lab/sitemap-url-extractor) for URL inventory, [Tech Stack Detector](https://apify.com/automation-lab/tech-stack-detector) for technology changes, and [Font Detector](https://apify.com/automation-lab/font-detector) for brand/design drift.

### Output example

Each domain produces one result object with age calculations, registration and expiration dates, registrar information, nameservers, and status codes.

| Field | Description |
|-------|-------------|
| `domain` | The queried domain name |
| `ageDays` | Domain age in days since registration |
| `ageYears` | Domain age in years (decimal) |
| `isNewDomain` | `true` when `ageDays <= newDomainThresholdDays`; otherwise `false`, or `null` if registration date is unavailable/invalid |
| `registrationDate` | Original registration date (ISO 8601) |
| `expirationDate` | Expiration date (ISO 8601) |
| `daysUntilExpiration` | Complete days from `checkedAt` until expiration; negative when already expired, or `null` when unavailable/invalid |
| `expiresSoon` | `true` when `daysUntilExpiration <= expirationWarningDays`, including expired domains; `null` when expiration is unavailable/invalid |
| `registrar` | Registrar name |
| `nameservers` | Authoritative name servers |
| `status` | Domain status codes |
| `error` | Error message if lookup failed |
| `checkedAt` | ISO timestamp of the check |

All date-derived fields use the same `checkedAt` reference and floor elapsed milliseconds to complete 24-hour days. Both threshold comparisons are inclusive. A missing or invalid source date produces `null` derived values rather than a misleading flag.

```json
{
    "domain": "google.com",
    "ageDays": 9862,
    "ageYears": 27.0,
    "isNewDomain": false,
    "registrationDate": "1997-09-15T04:00:00Z",
    "expirationDate": "2028-09-14T04:00:00Z",
    "daysUntilExpiration": 927,
    "expiresSoon": false,
    "registrar": "MarkMonitor Inc.",
    "nameservers": ["ns1.google.com", "ns2.google.com"],
    "status": ["client delete prohibited", "client transfer prohibited"],
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}
```

### How to check domain age

1. Go to [Domain Age Checker](https://apify.com/automation-lab/domain-age-checker) on Apify Store
2. Enter one or more domain names (e.g., `google.com`, `github.com`)
3. Click **Start** and wait for the run to finish
4. Review registration date, expiration date, age in days/years, and registrar for each domain
5. Download your results as JSON, CSV, or Excel from the **Dataset** tab

### How much does it cost to check domain age?

Domain Age Checker uses Apify's pay-per-event pricing:

| Event | Price | Description |
|-------|-------|-------------|
| Start | $0.035 | One-time per run |
| Domain checked | $0.001 | Per domain with a registration date |

You pay only for domains the registry returns a registration date for. Unregistered domains, failed lookups and registries that publish no dates (such as .de) still get a row with the reason, free of charge. A run in which no domain has a registration date costs nothing, not even the start fee.

**Examples:**

- 10 domains: $0.035 + 10 x $0.001 = **$0.045**
- 100 domains: $0.035 + 100 x $0.001 = **$0.135**
- 1,000 domains: $0.035 + 1,000 x $0.001 = **$1.035**
- Server API: $0.001 per returned domain with a registration date, with no start fee; failed and empty answers, and .de records, are free

### API usage

The Apify API lets you control Domain Age Checker programmatically. Schedule runs, read datasets, manage webhooks, and more. See the [Apify API reference](https://docs.apify.com/api/v2) for details.

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('automation-lab/domain-age-checker').call({
    domains: ['google.com', 'github.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_API_TOKEN>')
run = client.actor('automation-lab/domain-age-checker').call(run_input={
    'domains': ['google.com', 'github.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~domain-age-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"domains": ["google.com", "github.com"]}'
```

### Use with AI agents via MCP

Domain Age Checker is available as a tool for AI assistants via the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/domain-age-checker"
```

#### Setup for Claude Desktop, Cursor, or VS Code

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/domain-age-checker"
        }
    }
}
```

#### Example prompts

- "How old is the domain example.com?"
- "Check domain ages for these competitor websites"
- "Find the registration and expiration dates for these 10 domains"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Integrations

Connect Domain Age Checker with other apps and services using [Apify integrations](https://apify.com/integrations):

- **Google Sheets** — automatically push domain age results to a spreadsheet for collaborative analysis, historical tracking, and sorting by registration date
- **Zapier / Make (Integromat)** — trigger a domain age check whenever a new lead enters your CRM, then enrich the lead record with domain age and registrar data
- **Slack** — schedule weekly runs on a watchlist of domains and receive alerts when any domain is within 30 days of expiration
- **n8n** — build self-hosted workflows that combine domain age data with WHOIS lookups and DNS checks for comprehensive domain intelligence reports
- **Webhooks** — receive HTTP POST notifications when a run completes, enabling custom integrations with fraud detection systems, SEO dashboards, or domain monitoring platforms

### Tips and best practices

- **Use for lead qualification** — domain age is a useful signal for determining whether a business is established or newly created
- **Combine with WHOIS Lookup** — if you need registrant contact info in addition to age, use WHOIS Lookup for the full picture
- **Schedule periodic checks** — set up weekly runs to monitor expiration dates across your domain portfolio and catch renewals early
- **Filter by age in downstream tools** — export to Google Sheets or a database and filter for domains older or newer than a threshold
- **Check TLD support** — while most common TLDs are supported, some country-code TLDs may not have RDAP servers; the `error` field will indicate when a lookup fails
- **Export and sort by age** — download results as JSON, CSV, or Excel and sort by `ageDays` to quickly identify the oldest or newest domains in your list

### Diagnostic reporting

When a run or server request fails, Domain Age Checker sends sanitized diagnostic input, the exception and the Actor, build and run IDs to our private GlitchTip service so we can repair it. Secret fields and URL queries are removed, and reports are kept for 30 days.

### Legality

This tool analyzes publicly accessible web content. Automated analysis of public web resources is standard practice in SEO and web development. Always respect robots.txt directives and rate limits when analyzing third-party websites. For personal data processing, ensure compliance with applicable privacy regulations.

### FAQ

**What is the difference between RDAP and WHOIS?**
RDAP is the modern replacement for WHOIS. It returns structured JSON data instead of unformatted text, making it more reliable for automated processing. Domain Age Checker uses RDAP for accuracy and consistency.

**What happens if a domain is not found?**
If the domain does not exist or the TLD has no RDAP server, the result will include an `error` field explaining the failure. That row is free. Other domains in the batch are not affected.

**Can I check domain age for country-code TLDs like .uk or .de?**
Yes for both. The Actor follows the official IANA list of RDAP registries and adds the registries for .io, .me, .co and .de, which that list leaves out. A country-code TLD without any public RDAP registry returns an error. The .de registry (DENIC) confirms that a domain exists and returns its status, nameservers and last update, but it does not publish registration or expiry dates or the registrar, so those fields are `null` for .de domains. Because a .de record has no age to report, it is free.

**How accurate is the age calculation?**
The age is calculated from the registration date returned by the RDAP server to the time of the check. It is as accurate as the data provided by the domain registry. The `ageDays` field is an integer count of days, and `ageYears` is a decimal for convenience.

**Does the actor show when a domain will expire?**
Yes. `expirationDate` contains the ISO 8601 expiry timestamp, `daysUntilExpiration` gives the integer countdown, and `expiresSoon` applies your inclusive warning window (30 days by default). Expired domains have a negative countdown and are also flagged. If RDAP omits or returns an invalid expiration date, all expiration-derived fields are `null`.

**The actor returned an error for a .de (or other ccTLD) domain. Why?**
Domain Age Checker uses the RDAP protocol, which requires the TLD registry to operate an RDAP server. Some country-code TLDs (for example .cn or .ru) do not offer RDAP. For those TLDs, use the WHOIS Lookup actor instead, which queries traditional WHOIS servers. A .de domain does not return an error, but its dates are empty because DENIC does not publish them.

**The registration date seems wrong or different from what another tool shows. Why?**
RDAP returns the date from the registry, which may reflect the original creation date or the most recent transfer. Some registries reset the creation date on domain transfers. If you need the full history, check the raw WHOIS text via the WHOIS Lookup actor.

### How to check domain age in bulk

Checking domain age one at a time through manual WHOIS lookups is impractical when you have dozens or hundreds of domains to evaluate. Domain Age Checker processes your entire list in a single run, returning structured results you can sort, filter, and export.

To bulk-check domain ages:

1. Collect your domains into a list — from a spreadsheet, a backlink audit export, a lead database, or a competitor research file
2. Paste them into the `domains` input field (one per line or as a JSON array)
3. Start the run and get a structured report with registration date, expiration date, age in days/years, and registrar for every domain
4. Download results as CSV or Excel and sort by `ageDays` to quickly rank domains from oldest to newest

For recurring checks — such as monitoring a portfolio of domains for upcoming expirations — use [Apify Schedules](https://docs.apify.com/platform/schedules) to automate weekly or monthly runs. Combine with the Google Sheets integration to maintain a live dashboard of domain ages across your watchlist.

At $0.001 per domain, checking 1,000 domains costs just over $1 — far cheaper than manual WHOIS lookups or subscription-based domain research tools.

### How to verify domain age for fraud detection

Domain age is one of the strongest signals for identifying potentially fraudulent websites. Phishing sites, scam storefronts, and impersonation domains are almost always newly registered — typically days or weeks old rather than months or years.

Here is how to use domain age as part of a fraud detection workflow:

1. **Collect suspicious domains** — from reported phishing emails, ad campaigns, affiliate links, or customer complaints
2. **Run Domain Age Checker** with `newDomainThresholdDays: 90` to get registration data and an `isNewDomain` flag
3. **Review domains where `isNewDomain` is `true`** — these are high-risk triage candidates. Legitimate businesses rarely operate on brand-new domains
4. **Cross-reference with other signals** — combine domain age with WHOIS registrar data (privacy-protected registrations on new domains are a red flag), SSL certificate age, and website content analysis
5. **Automate the pipeline** — use Apify Schedules and webhooks to check new domains daily and push flagged results to your security team's Slack channel or incident management system

Domain age alone does not prove fraud, but it is a reliable triage filter. A domain registered yesterday that claims to be an established bank or retailer deserves immediate investigation. Pair Domain Age Checker with [WHOIS Lookup](https://apify.com/automation-lab/whois-lookup) for full registrant details and [SSL Certificate Checker](https://apify.com/automation-lab/ssl-certificate-checker) for certificate validation.

### Related DNS and domain tools

- [DNS Lookup](https://apify.com/automation-lab/dns-lookup) — Look up all DNS record types for any domain
- [DNS Propagation Checker](https://apify.com/automation-lab/dns-propagation-checker) — Check DNS propagation across global resolvers
- [DMARC Record Checker](https://apify.com/automation-lab/dmarc-record-checker) — Check DMARC email authentication policies
- [SPF Record Checker](https://apify.com/automation-lab/spf-record-checker) — Check SPF records for email sender authorization
- [MX Record Checker](https://apify.com/automation-lab/mx-record-checker) — Check MX records for mail server configuration
- [TXT Record Checker](https://apify.com/automation-lab/txt-record-checker) — Look up TXT records for any domain
- [AAAA Record Checker](https://apify.com/automation-lab/aaaa-record-checker) — Check IPv6 AAAA records
- [CNAME Record Checker](https://apify.com/automation-lab/cname-record-checker) — Check CNAME alias records
- [NS Record Checker](https://apify.com/automation-lab/ns-record-checker) — Check authoritative name servers
- [SSL Certificate Checker](https://apify.com/automation-lab/ssl-certificate-checker) — Check SSL/TLS certificate details
- [WHOIS Lookup](https://apify.com/automation-lab/whois-lookup) — Look up domain registration details
- [Domain Availability Checker](https://apify.com/automation-lab/domain-availability-checker) — Check if domains are available for registration

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/domain-age-checker/changelog.md

# Actor input Schema

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

Enter domain names to check registration age for. Use bare domain names (e.g. google.com).

## `newDomainThresholdDays` (type: `integer`):

Mark a domain as new when its age is less than or equal to this many complete days. Uses an inclusive comparison.

## `expirationWarningDays` (type: `integer`):

Mark a domain as expiring soon when its expiration is this many complete days away or less. Uses an inclusive comparison and also flags already-expired domains.

## Actor input object example

```json
{
  "domains": [
    "google.com"
  ],
  "newDomainThresholdDays": 90,
  "expirationWarningDays": 30
}
```

# Actor output Schema

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

Open the filtered Dataset overview with the most actionable domain fields.

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

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/domain-age-checker").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": ["google.com"] }

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

```

## MCP server setup

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

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/EeVB7aPicalAgepB6/builds/tkbRhuoI7gQhC6JK7/openapi.json