# Domain Intelligence — RDAP/WHOIS, DNS & DomainSure

Answers “What is this domain?” with normalized RDAP registration data (WHOIS-style domain information), core DNS, SPF/DMARC detection, IDN/confusable analysis, and DomainSure reputation.

## Discovery

- Identifier: `domain.intelligence`
- Version: `v1`
- Category: Domain intelligence
- Status: `live-paid`
- Access: `x402-$0.01-per-domain`
- Human docs: https://dnsskills.md/domain-intelligence
- Agent Markdown: https://dnsskills.md/domain-intelligence.md
- SKILL.md: https://dnsskills.md/domain-intelligence/SKILL.md
- OpenAPI: https://dnsskills.md/openapi.yaml
- Public GitHub mirror: https://github.com/easydns/dns-agent-skills
- Web UI: https://app.domainhelp.com/domain-lookup

- Compatibility aliases: `domain-rdap-lookup`, `domainlookup`, `domain-lookup`, `RDAP lookup`, `WHOIS lookup`

## Domain Intelligence is a Skill

- Skill: `domain.intelligence`
- Question: “What is this domain?”
- Price: $0.01/domain via x402
- Endpoint: `GET https://app.domainhelp.com/api/v1/domain/{domain}`

One x402-paid call returns the bundled snapshot. Callers do not need to invoke every specialist skill separately.

## What is included?

- 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

## When should I use Domain Intelligence?

Use Domain Intelligence 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.

## Just checking whether a domain is available?

Do not buy the full intelligence bundle when the only question is whether a candidate domain can be registered.

- Domain Availability: “Can I register this?” — $0.001/domain
- Domain Intelligence: “What is this domain?” — $0.01/domain
- Domain Availability docs: https://dnsskills.md/domain-availability

## x402 request flow

The first unpaid request returns `402 Payment Required` and a `PAYMENT-REQUIRED` challenge. An x402-aware client signs the requirement, retries the same request with `PAYMENT-SIGNATURE`, and parses the successful JSON response. Do not construct payment headers by hand.

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

```http
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"}
```

### JavaScript

```bash
npm install @x402/fetch @x402/evm viem
```

```javascript
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());
```

### Python

```bash
pip install "x402[requests,evm]"
```

```python
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())
```

Use a dedicated, low-balance Base wallet funded with enough USDC for the request. Keep its private key in an environment variable, never in source control.

## Response example

```json
{
  "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"
}
```

## Give this skill to an agent

Adapt this instruction for 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.

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

## Need to go deeper?

- [SPF Validator](https://dnsskills.md/skills/spf-validator.md): An SPF record needs semantic validation.
- [SPF Flattener](https://dnsskills.md/skills/spf-flattener.md): The task is SPF transformation or flattening, not observation.
- [Is This a Redirect?](https://dnsskills.md/skills/is-this-a-redirect.md): You only need DomainSure redirect or URL-shortener classification.
- [Link Expander / Redirect Chain](https://dnsskills.md/skills/redirect-chain.md): You need active HTTP redirect traversal or link expansion.
- [Is This a Homoglyph?](https://dnsskills.md/skills/is-this-a-homoglyph.md): You only need confusable or Unicode analysis for one supplied value.
- [DNS Twister](https://dnsskills.md/skills/dns-twister.md): You need lookalike-domain or permutation exploration.

## Pricing

- 1–9 domains: $0.01/domain
- 10–49 domains: $0.005/domain
- 50–100 domains: $0.004/domain


## JSON Schemas

- Bundle: https://dnsskills.md/schemas/domain-intelligence.schema.json
- Input: https://dnsskills.md/schemas/domain-intelligence.input.schema.json
- Output: https://dnsskills.md/schemas/domain-intelligence.output.schema.json
- Payment required: https://dnsskills.md/schemas/x402-payment-required.schema.json
- Payment response: https://dnsskills.md/schemas/x402-payment-response.schema.json

## Agent Invocation

Use the execution API endpoints below. Do not post to browser Web UI form routes; those routes are for humans and may require CSRF and reCAPTCHA.

- `GET https://app.domainhelp.com/api/v1/domain/{domain}`
  - Status: `live-x402`
  - Response modes: `json`
- `POST https://app.domainhelp.com/api/v1/domain`
  - Status: `live-x402`
  - Response modes: `json`
- `GET/POST https://app.domainhelp.com/api/v1/domain-intelligence`
  - Status: `live-alias`
  - Response modes: `json`
- `GET/POST https://app.domainhelp.com/api/v1/domain-rdap-lookup`
  - Status: `compatibility-alias`
  - Response modes: `json`

## Input Contract

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 Contract

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.

## Errors

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

## Auth And Limits

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.

Maximum 100 domains per request. Network work is bounded, deadline-limited, and batched.

## Examples

### Requests

```text
GET /api/v1/domain/example.com
```

```text
GET /api/v1/domain/example.com?include=registration,dns
```

```text
POST /api/v1/domain {"domains":["example.com","example.net"]}
```

### Responses

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

```json
{"product":"domain-intelligence","version":"1","domain":"example.com","price_usd":"0.01","status":"ok","registration":{"source_protocol":"rdap"},"dns":{"attributes":{"spf":{"present":true},"dmarc":{"present":true}}},"identity":{"confusable":false},"reputation":{"source":"domainsure","listed":false}}
```

## FAQ

### Is this a WHOIS API?

It includes RDAP registration data in a WHOIS-style normalized form and truthfully reports the protocol that supplied it.

### What is a Domain Intelligence Unit?

One lookup of one domain using the standard bundle. One domain equals one unit and costs $0.01 at the single-request tier.

### Does include= lower the price?

No. Selection reduces latency and response size; it does not change v1 pricing.

## Related Skills

- [Domain Availability](https://dnsskills.md/domain-availability.md)
- [Is This a Redirect?](https://dnsskills.md/skills/is-this-a-redirect.md)
- [Link Expander / Redirect Chain](https://dnsskills.md/skills/redirect-chain.md)
- [DNS Twister](https://dnsskills.md/skills/dns-twister.md)
- [Is This a Homoglyph?](https://dnsskills.md/skills/is-this-a-homoglyph.md)
- [SPF Validator](https://dnsskills.md/skills/spf-validator.md)
- [SPF Flattener](https://dnsskills.md/skills/spf-flattener.md)