# Domain WHOIS & RDAP Lookup MCP Server (`mrbridge/web-intel-mcp`) Actor

Domain WHOIS and RDAP lookup MCP server for Claude, ChatGPT, Cursor and other AI agents. Get a domain's registrar, age, expiry date, status codes and name servers from its registry over RDAP, the successor of WHOIS, or check 5 names at once. Over 500 TLDs, .com and .org included.

- **URL**: https://apify.com/mrbridge/web-intel-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Developer tools
- **Security:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 WHOIS & RDAP Lookup MCP Server

Domain WHOIS & RDAP Lookup MCP Server is an MCP server that lets Claude, ChatGPT, Cursor, VS Code and other AI agents read domain registration data from the registries themselves, over RDAP, the protocol that replaced WHOIS. Its 6 read-only tools look up a domain, check up to five names at once, look up a name server host, find an ICANN registrar by IANA ID or name, and explain which top-level domains are covered.

Ask Claude "how old is wikipedia.org, when does it expire, and is it locked against transfer?" and it calls `web_lookup_domain`. You get the registration and expiry dates with the days left, the registrar with its abuse contact, and each EPP status code explained in plain words. Coverage is limited to the registries whose terms were reviewed, Verisign (.com, .net), Public Interest Registry (.org), Identity Digital and Google Registry, for over 500 top-level domains in total.

### Quick start

1. Copy your API token from [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations).
2. Add `https://mrbridge--web-intel-mcp.apify.actor/mcp` to your AI client with the header `Authorization: Bearer <token>`. The Connect section below has a ready-made snippet for each client.
3. Ask a question such as "are mybrand.com, mybrand.net and mybrand.org registered?"

### What this server exposes

This server gives an AI client 6 read-only tools over domain registration data, read from the registries themselves through RDAP, the protocol that replaced WHOIS. For one domain it returns the registrar with its IANA ID and abuse contact, the registration, expiry and last change dates with the days left before expiry, the EPP status codes with a plain-language meaning, the transfer lock, the name servers, the DNSSEC state and, when the registry publishes them, the registrant's organisation, region and country. A second tool checks up to five names at once and tells which ones have no registration record. The others look up a name server host at its registry, an ICANN registrar in the IANA Registrar IDs registry, the RDAP service of a top-level domain, and the list of top-level domains the server covers. Registries are located through the IANA RDAP bootstrap file. Coverage is limited to the registries whose terms of use were reviewed: Verisign (.com, .net), Public Interest Registry (.org), Identity Digital (for example .info) and Google Registry (for example .app, .dev). No account or API key is needed. This server is not affiliated with any registry, IANA or ICANN.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `web_lookup_domain` | Look up the registration record of a domain | `tool-read` |
| `web_check_domains` | Check whether domain names are registered | `tool-action` |
| `web_lookup_nameserver` | Look up a name server host at its registry | `tool-read` |
| `web_lookup_registrar` | Look up an ICANN registrar by IANA ID or name | `tool-read` |
| `web_get_tld_info` | Get the RDAP service and coverage of a top-level domain | `tool-read` |
| `web_list_covered_tlds` | List the top-level domains this server covers | `tool-read` |

#### `web_lookup_domain`: Look up the registration record of a domain

Use this when you need the registration record of one domain name from its registry, through RDAP (the successor of WHOIS): registrar with IANA ID and abuse contact, registration, expiry and last change dates with the days left before expiry, EPP status codes with their meaning, transfer lock, name servers, DNSSEC, and the registrant organisation, region and country when the registry publishes them. Personal contact details are removed. Covers the TLDs of Verisign (.com, .net), Public Interest Registry (.org), Identity Digital (for example .info) and Google Registry (for example .app, .dev). Do not use for several names or an availability check (web_check_domains), a name server host (web_lookup_nameserver), a registrar by IANA ID (web_lookup_registrar) or a TLD that is not covered (web_get_tld_info explains why). Parameters: `domain` (domain name, URL or e-mail address, e.g. "example.com"), `response_format` ("concise" default, or "detailed" for events, name server addresses, DS records, contacts by role, record links and registry notices).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `domain` | string | yes | `"example.com"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ domain, unicode_domain, normalized_from, tld, registry, registrar, dates, status[], transfer_locked, nameservers[], dnssec_signed, registrant, personal_data, details, attribution }`. Upstream: IANA RDAP bootstrap, Verisign RDAP, Public Interest Registry RDAP, Identity Digital RDAP, Google Registry RDAP. Cache: hourly (1 hour). Read-only.

#### `web_check_domains`: Check whether domain names are registered

Use this when you need to know, for 1 to 5 domain names at once, whether each one is registered at its registry and, when it is, its registrar, expiry date, days left and transfer lock, read through RDAP (the successor of WHOIS). A name without a registry record is reported as not_registered (likely available, confirm with a registrar), a name under a TLD this server does not cover as not_covered. Covers the TLDs of Verisign (.com, .net), Public Interest Registry (.org), Identity Digital and Google Registry (for example .info, .app, .dev). Do not use for the full record of one domain (web_lookup_domain) or for bulk checks of more than five names, which the registries forbid. Parameter: `domains` (array of 1 to 5 domain names, e.g. \["example.com", "example.org"]).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `domains` | array of string | yes | `["example.com","example.org"]` |

Returns `{ results[], summary, attribution }`. Upstream: IANA RDAP bootstrap, Verisign RDAP, Public Interest Registry RDAP, Identity Digital RDAP, Google Registry RDAP. Cache: hourly (1 hour). Read-only.

#### `web_lookup_nameserver`: Look up a name server host at its registry

Use this when you need what a registry holds about a name server host (RDAP host object): its IPv4 and IPv6 glue addresses and its status codes with their meaning. Registries hold host objects mainly for name servers under their own TLD, for example ns1.example.com at the .com registry. Covers the TLDs of Verisign (.com, .net), Public Interest Registry (.org), Identity Digital and Google Registry. Do not use for the name servers a domain delegates to (web_lookup_domain lists them) or for live DNS resolution, which this server does not do. Parameters: `hostname` (e.g. "ns1.example.com"), `response_format` ("concise" default, or "detailed" for events, the record link and registry notices).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `hostname` | string | yes | `"ns1.example.com"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ nameserver, unicode_nameserver, tld, registry, ipv4[], ipv6[], status[], details, attribution }`. Upstream: IANA RDAP bootstrap, Verisign RDAP, Public Interest Registry RDAP, Identity Digital RDAP, Google Registry RDAP. Cache: daily (1 day). Read-only.

#### `web_lookup_registrar`: Look up an ICANN registrar by IANA ID or name

Use this when you need an ICANN registrar from the IANA Registrar IDs registry: its name, accreditation status (accredited, terminated or reserved) and RDAP base URL, found by its IANA ID (as returned by web_lookup_domain) or by a name search. Do not use for the registrar of a given domain (web_lookup_domain returns it) or for country-code registrars outside ICANN accreditation, which this registry does not list. Parameters: `iana_id` (integer or numeric string, e.g. 292) or `name` (at least 2 characters, e.g. "network solutions"), exactly one of them, `status` ("any" default, "accredited", "terminated", "reserved"), `limit` (1 to 50, default 10), `offset` (default 0), `response_format` ("concise" or "detailed" with cache information).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `iana_id` | value | no | `292` |
| `name` | string | no | `"network solutions"` |
| `status` | "any" or "accredited" or "terminated" or "reserved" | no | `"accredited"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ registrars[], pagination, attribution }`. Upstream: IANA Registrar IDs. Cache: daily (1 day). Read-only.

#### `web_get_tld_info`: Get the RDAP service and coverage of a top-level domain

Use this when you need to know whether a top-level domain has an RDAP service registered with IANA, at which base URLs, which registry runs it, and whether this server can look up domains under it, with the reason when it cannot (registry terms not reviewed, plain HTTP only). Do not use for a full domain name (web_lookup_domain) or for the list of every covered TLD (web_list_covered_tlds). Parameter: `tld` (a top-level domain with or without the dot, IDN accepted, e.g. "app", ".org" or "xn--q9jyb4c").

| Parameter | Type | Required | Example |
|---|---|---|---|
| `tld` | string | yes | `"app"` |

Returns `{ tld, unicode_tld, rdap_base_urls[], covered, registry, not_covered_reason, iana_root_zone_page, bootstrap_publication, attribution }`. Upstream: IANA RDAP bootstrap. Cache: daily (1 day). Read-only.

#### `web_list_covered_tlds`: List the top-level domains this server covers

Use this when you need the list of top-level domains whose domains this server can look up, optionally for one registry (Verisign, Public Interest Registry, Identity Digital, Google Registry) or filtered by a substring, with a count per registry and its terms URL. Do not use for one TLD, covered or not (web_get_tld_info), or for domain lookups (web_lookup_domain). Parameters: `registry` ("all" default, or one of "verisign", "pir", "identity-digital", "google"), `contains` (substring, e.g. "app"), `limit` (1 to 200, default 50), `offset` (default 0), `response_format` ("concise", or "detailed" with each RDAP base URL).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `registry` | "all" or "verisign" or "pir" or "identity-digital" or "google" | no | `"google"` |
| `contains` | string | no | `"app"` |
| `limit` | integer | no | `50` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ tlds[], registries[], pagination, bootstrap_publication, attribution }`. Upstream: IANA RDAP bootstrap. Cache: daily (1 day). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--web-intel-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http web-intel "https://mrbridge--web-intel-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "web-intel": {
      "type": "http",
      "url": "https://mrbridge--web-intel-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--web-intel-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add Domain WHOIS & RDAP Lookup MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Domain%20WHOIS%20%26%20RDAP%20Lookup%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--web-intel-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--web-intel-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "web_intel",
  "server_url": "https://mrbridge--web-intel-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--web-intel-mcp.apify.actor/mcp",
      "name": "web-intel",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "web-intel"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/web-intel-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use Domain WHOIS & RDAP Lookup MCP Server

- **Straight from the registry.** Each lookup goes to the registry found through the IANA RDAP bootstrap file, not to a WHOIS reseller database.
- **Status codes in plain words.** Every EPP status, the transfer lock and the days left before expiry are explained in each answer.
- **Domain age at a glance.** The registration date comes with every lookup, so "how old is this domain?" takes one call.
- **Five names per check.** Registered or not, with registrar and expiry date, in a single call.
- **Privacy filtering built in.** Personal contact details are removed from every answer, and each answer says what was removed.
- **Honest coverage.** A coverage tool tells you whether a top-level domain is served and, when it is not, why.

### Pricing (Pay-per-Event)

Domain WHOIS & RDAP Lookup MCP Server uses pay-per-event pricing. Each successful call is one `tool-read` event at $0.005, or one `tool-action` event at $0.01 for a check of up to five names with `web_check_domains`, so 1,000 lookups cost $5 in events, and a check of five names is a single `tool-action` event. These are the FREE plan prices, and Apify plan discounts lower them. Apify also bills its standard `apify-actor-start` event when a Standby run starts, and you pay the platform usage of your own Standby run on top of the events, as explained below. Calls that end in an error carry no event charge, and neither do domains under a top-level domain the server does not cover. See the [Pricing tab](https://apify.com/mrbridge/web-intel-mcp/pricing) for the price on your Apify plan.

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Coverage.** Only four registries are queried, the ones whose RDAP terms allow this kind of service: Verisign, Public Interest Registry, Identity Digital and Google Registry. A domain under any other top-level domain (for example .xyz, .uk, .de or .fr) is answered with the reason it is not covered, without a query to its registry and without a charge. `web_list_covered_tlds` lists the covered TLDs and `web_get_tld_info` explains a single one.
- **Registry data only.** For .com and .net the registry holds no registrant data: it lives at the registrar. This server does not query registrars. In detailed mode the answer gives the link to the registrar's own RDAP record.
- **Personal data.** Personal contact details are removed from every answer: names, e-mail addresses, phone numbers, street, city and postal code. For the registrant and other contacts, only the organisation, region and country are kept. The registrar keeps its name, IANA ID and the e-mail and phone of its abuse desk. Each lookup states how many details were removed and which fields the registry itself declared redacted.
- **Availability.** A name without a registration record is reported as `not_registered`. It is likely available, but reserved, blocked or premium names can still be refused by a registrar. Check with a registrar before relying on it.
- **Volume.** The registries forbid high-volume automated querying. This server looks up one name per call (five per availability check), keeps to about one query every two seconds per registry, caches registration records for an hour and host records for a day, and offers no bulk, search or listing of registrations. Heavy use can meet `UPSTREAM_RATE_LIMITED`.
- **Freshness.** A cached record can be up to an hour old, or up to six hours when the registry is unreachable (the answer then says `stale`). A name that has no record is never cached, so a new registration shows up at once.
- **Not offered.** IP address and AS number lookups, DNS resolution, TLS certificate searches, SSL and page speed tests, and web archive lookups are not part of this server: the terms of their public sources do not allow a paid service.
- **Attribution.** Every answer carries an `attribution` block with the registry or IANA source, its terms URL and the notices the registry terms require. Keep it when you reuse the data.

### Data terms

By using this server you agree to use the data it returns in line with the terms of the registry that holds it, and to pass the same obligations on to anyone you share the data with. In short, from the terms of the four registries: use the data only for lawful purposes, never to support mass unsolicited commercial advertising or solicitations by e-mail, phone or fax, never to feed high-volume automated querying of the registries or registrars, and never to compile or redistribute a substantial part of a registry database. The registries give no guarantee of accuracy.

- Verisign: [RDAP Terms of Service](https://www.verisign.com/legal-center/rdap-terms/)
- Public Interest Registry: [Whois terms of use](https://whois.publicinterestregistry.net/)
- Identity Digital: [RDDS Access Policy](https://www.identity.digital/policies/rdds-access-policy)
- Google Registry: [RDAP Terms](https://www.registry.google/policies/rdap-terms/)
- IANA: the RDAP bootstrap registry is dedicated to the public domain under CC0 1.0 ([licensing terms](https://www.iana.org/help/licensing-terms))

The fee for this server pays for the service (hosting, caching, normalisation, privacy filtering), not for a licence on the data.

### Use cases

- **Your own domain portfolio.** "When do our .com and .org domains expire, and are they all transfer-locked?"
- **Naming a product.** "Are these five names registered?" before you spend time on a shortlist.
- **Domain age checks.** "When was this domain registered?" before you trust a supplier site or a link.
- **Phishing and abuse triage.** "When was this lookalike domain registered, and where do I report it?" returns the creation date and the registrar's abuse contact.
- **IT troubleshooting.** Name servers, DNSSEC state and the glue addresses of a name server host, as the registry holds them.
- **Due diligence.** Registrar, creation date and status codes of a domain that is part of a deal.

Not for bulk lookups, lead lists or contacting domain holders: the registry terms forbid it, and the server answers one domain per lookup and five per check.

### More SEO and AI search tools

- [SERP API and keyword data for AI](https://apify.com/mrbridge/seo-geo-mcp): live SERP, keyword, backlink and site audit data, and brand visibility in AI answers.
- [ChatGPT answers and citations tracker](https://apify.com/mrbridge/chatgpt-results-scraper): ChatGPT answers to any question with their cited sources and a screenshot, from 20 countries.
- [vulnerability intelligence MCP server](https://apify.com/mrbridge/vuln-intel-mcp): known vulnerabilities in your pinned dependencies and CVE records with CVSS scores.

### FAQ

#### Why is the first call slower?

The server runs in Apify Standby mode. When no request comes in for a while, the run stops at its idle timeout, and the next call starts a new one. That cold start took about 5 seconds in the last platform test. Calls made while the server is warm skip the delay.

#### Is this a WHOIS lookup?

Yes, through RDAP, the protocol that replaced WHOIS for generic top-level domains. You get the same registration facts (registrar, dates, status, name servers) in a structured form, straight from the registry.

#### Which top-level domains are covered?

Over 500, served by Verisign (.com, .net), Public Interest Registry (.org), Identity Digital (for example .info) and Google Registry (for example .app and .dev). Other top-level domains, such as .xyz, .uk, .de or .fr, get a not-covered answer with the reason and no event charge. `web_list_covered_tlds` gives the full list.

#### Can it tell me who owns a domain?

Usually not. Personal details are removed from every answer, and for .com and .net the registry holds no registrant data at all. When a registry publishes them, the registrant's organisation, region and country are kept.

#### Does "not_registered" mean I can buy the name?

Often, but not always. Reserved, blocked and premium names can still be refused by a registrar, so check with one before you rely on it.

#### Why are DNS, SSL and page speed checks missing?

The public sources for those checks do not allow a paid service in their terms, so this server sticks to registration data.

#### Can I check thousands of domains?

No. The registries forbid high-volume automated querying, and the server answers one domain per lookup and five per check, with a pace set per registry.

#### Your feedback

Found a bug or a wrong answer? Open an issue on the [Issues tab](https://apify.com/mrbridge/web-intel-mcp/issues). Domain WHOIS & RDAP Lookup MCP Server is built by MrBridge. More servers are listed in the [MCP server catalogue](https://mr-bridge.com/mcp-servers), and more tools and data studies are at [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.4: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.3: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.2: pricing events tool-read and tool-action
- 0.1.1: the server is named Domain WHOIS & RDAP Lookup MCP Server (connector name and connection page), and the `web_check_domains` description says its answers come from RDAP, the successor of WHOIS, like the other domain tools. The endpoint and the tools do not change.
- 0.1.0: initial build (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--web-intel-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--web-intel-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/web-intel-mcp").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 = { "mcpEndpoint": "https://mrbridge--web-intel-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/web-intel-mcp").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 '{
  "mcpEndpoint": "https://mrbridge--web-intel-mcp.apify.actor/mcp"
}' |
apify call mrbridge/web-intel-mcp --silent --output-dataset

```

## MCP server setup

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

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/lxjjGYi2hyQLbdM36/builds/cJiDqdySXwB2j02l2/openapi.json