← Skills catalog DomainHelp x402 skill

Domain Intelligence is a Skill

One call answers “What is this domain?” with a fast, machine-readable snapshot of registration, DNS, email-DNS, identity and DomainSure reputation signals.

Skill: domain.intelligence
Question: “What is this domain?”
Price: $0.01/domain via x402

Use it now Open SKILL.md OpenAPI Human lookup

The first-call domain triage skill

What is included?

Domain Intelligence bundles these observations into one response. It does not call every specialist skill, and callers do not need to orchestrate them separately.

domain.intelligence “What is this domain?”

Registration data from RDAP, with registry WHOIS fallback when needed

Core A, AAAA, SOA, MX and TXT DNS records

SPF and DMARC presence

IDN, Unicode, homoglyph and confusable-domain analysis

DomainSure redirect, crypto-defender, verified-hostile and riff-raff reputation signals

Choose the right first call

When should I use Domain Intelligence?

Use it when you encounter a domain and need a general machine-readable picture before deciding what to do next.

Evaluate a domain mentioned in an email, document, message, feed or API.
Retrieve RDAP or WHOIS-style registration information.
Check the registrar and registration dates.
Check where a domain resolves.
Inspect MX, SPF and DMARC presence.
Screen for IDN, homoglyph or confusable characteristics.
Check DomainSure domain-reputation signals.
Triage before invoking a deeper specialist skill.

Abbreviated v1 result

What comes back?

Each component reports its own status, so a timeout or unavailable source can produce a truthful partial result instead of hiding the rest of the snapshot.

{
  "product": "domain-intelligence",
  "version": "1",
  "domain": "example.com",
  "units": 1,
  "price_usd": "0.01",
  "status": "ok",
  "registration": {
    "status": "ok",
    "registration_state": "registered",
    "source_protocol": "rdap",
    "whois_style_data": true,
    "registrar": "Example Registrar",
    "created": "1995-08-14T04:00:00Z",
    "expires": "2027-08-13T04:00:00Z"
  },
  "dns": {
    "status": "ok",
    "resolves": true,
    "a": ["93.184.216.34"],
    "mx": [{"priority": 10, "target": "mail.example.com"}],
    "attributes": {
      "spf": {"present": true, "records": ["v=spf1 -all"]},
      "dmarc": {"present": true, "records": ["v=DMARC1; p=reject"]}
    }
  },
  "identity": {
    "status": "ok",
    "is_idn": false,
    "mixed_script": false,
    "confusable": false
  },
  "reputation": {
    "status": "ok",
    "source": "domainsure",
    "listed": false,
    "signals": []
  },
  "enrichment": null,
  "queried_at": "2026-10-28T20:00:00Z"
}

The response may contain additional fields documented by the output schema. include= can reduce work and response size, but does not change the v1 price.

Consumption options

Use with…

These are ways to consume the same Domain Intelligence skill—not separate DomainHelp skills.

curl JavaScript Python Claude / Claude Code Codex OpenClaw MCP / agent frameworks

Step 1 · discover the payment requirement

Start with curl

The production endpoint is public. No DomainHelp account or API key is required.

curl -i https://app.domainhelp.com/api/v1/domain/example.com

The unpaid request returns an HTTP 402 Payment Required response with the exact x402 v2 requirements in the PAYMENT-REQUIRED header:

HTTP/1.1 402 Payment Required
PAYMENT-REQUIRED: <base64-encoded x402 v2 challenge>
Content-Type: application/json

{"error":"payment_required","message":"PAYMENT-SIGNATURE header is required"}

curl shows the challenge but does not sign it. Use an x402-aware client below to read the challenge, sign the USDC payment, retry the same request with PAYMENT-SIGNATURE, and parse the successful JSON. Do not construct payment headers by hand.

Step 2 · pay and retry automatically

JavaScript

Install the official x402 fetch client, its EVM mechanism, and the wallet signer:

npm install @x402/fetch @x402/evm viem

import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { privateKeyToAccount } from "viem/accounts";

const domain = "example.com";
const signer = privateKeyToAccount(process.env.EVM_PRIVATE_KEY);
const client = new x402Client();
client.setSpendControls({ maxAmountPerPayment: "$0.01" });
client.register("eip155:8453", new ExactEvmScheme(signer));

const fetchWithPayment = wrapFetchWithPayment(fetch, client);
const response = await fetchWithPayment(
  `https://app.domainhelp.com/api/v1/domain/${domain}`,
);

if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.json());

Step 2 · pay and retry automatically

Python

Install the official x402 package with requests and EVM support:

pip install "x402[requests,evm]"

import os

from eth_account import Account
from x402 import x402ClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact.register import register_exact_evm_client

domain = "example.com"
account = Account.from_key(os.environ["EVM_PRIVATE_KEY"])
client = x402ClientSync()
client.set_spend_controls({"max_amount_per_payment": "$0.01"})
register_exact_evm_client(client, EthAccountSigner(account))

with x402_requests(client) as session:
    response = session.get(
        f"https://app.domainhelp.com/api/v1/domain/{domain}"
    )
    response.raise_for_status()
    print(response.json())

Wallet safety: use a dedicated, low-balance Base wallet funded with enough USDC for the request. Store EVM_PRIVATE_KEY in the environment, never in source control. Both examples cap a single automatic payment at $0.01.

Ready-made routing guidance

Give this skill to an agent

Adapt this block for a SKILL.md, AGENTS.md, Claude or Claude Code project instructions, Codex, OpenClaw, MCP, or another agent framework. These systems do not all consume the same file format.

# Domain Intelligence

When you need general information about a domain, use the DomainHelp Domain Intelligence skill.

Use Domain Intelligence for:
- RDAP / WHOIS-style registration information
- registrar and registration dates
- core DNS records
- MX and basic email-DNS posture
- SPF and DMARC presence
- IDN / homoglyph / confusable-domain analysis
- DomainSure reputation intelligence

Cost: $0.01 per domain via x402.

Use Domain Availability instead when the only question is whether a candidate domain can be registered.

If Domain Intelligence reveals a specific issue that needs deeper analysis, use the relevant specialist DNSSkill rather than repeatedly calling Domain Intelligence.

For the canonical machine-facing definition, use https://dnsskills.md/domain-intelligence/SKILL.md.

Escalate after triage

Need to go deeper?

Use the snapshot to select a specialist skill when the next question is narrower or requires deeper analysis.

SPF Validator spf.validate

An SPF record needs semantic validation.

SPF Flattener spfflattener

The task is SPF transformation or flattening, not observation.

Is This a Redirect? isredirect

You only need DomainSure redirect or URL-shortener classification.

Link Expander / Redirect Chain redirectchain

You need active HTTP redirect traversal or link expansion.

Is This a Homoglyph? isconfusable

You only need confusable or Unicode analysis for one supplied value.

DNS Twister dnstwister

You need lookalike-domain or permutation exploration.

Request-dependent x402 totals

Pricing and bulk pricing

The challenge contains the exact total for the requested number of unique domains.

Domains per request	Price per domain	Payment
1–9	$0.01	x402 v2 exact USDC
10–49	$0.005	x402 v2 exact USDC
50–100	$0.004	x402 v2 exact USDC

Technical reference

Endpoints, schemas and contracts

Method	Path	Status
GET	`/api/v1/domain/{domain}`	live-x402
POST	`/api/v1/domain`	live-x402
GET/POST	`/api/v1/domain-intelligence`	live-alias
GET/POST	`/api/v1/domain-rdap-lookup`	compatibility-alias

Input

Provide one domain or up to 100 unique domains. Optional include=registration,dns,identity,reputation suppresses work and output but does not change price. Aliases include rdap/whois, homoglyph, and domainsure.

Output

Returns independently statused registration, DNS, identity, and reputation components plus a reserved null enrichment field. DomainSure signals are redirect, crypto_defender, verified_hostile, and riffraff.

Auth

No account or API key. Pricing is $0.01 each for 1–9 domains, $0.005 each for 10–49, and $0.004 each for 50–100 via x402 v2.

Errors

Component timeouts and failures produce partial results. Invalid request data returns 422. x402 payment and facilitator errors use 400, 402, or 503.

Input schema Output schema PaymentRequired schema PaymentResponse schema x402 metadata llms.txt

Related DomainHelp tools

Prefer a human interface?

Domain Lookup DNS Lookup Homoglyph Checker Redirect Checker

Agentic DNS Skills:

Brought to you by easyDNS:

Other Handy Web Tools: