ForHosting KIT · Web Scraping & Monitoring

WHOIS lookup

Raw WHOIS output is a formatting free-for-all: every registry writes its own dialect of plain text, and no two are quite alike. This endpoint queries the modern RDAP layer underneath and hands back registrar, creation and expiry dates, status codes and nameservers as clean structured fields, so you stop writing regex against a format that was never meant to be parsed.

● StablePer request + per domain$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Why plain-text WHOIS became a liability

For decades, WHOIS answers came back as loosely formatted text with no shared schema across registries — one registrar's 'Registry Expiry Date' is another's 'Expiration Date', and field order shifts without warning. Every team that ever built a scraper against raw WHOIS output has a war story about a registry silently changing its layout and quietly breaking a script that had run fine for years.

RDAP: the fix the industry built for itself

RDAP (Registration Data Access Protocol) was developed specifically to replace that mess with a real, structured, JSON-based protocol governed by a shared standard, and registries have steadily migrated to it. web.whois talks RDAP under the hood and normalizes the response into a consistent shape across registries, so you get the reliability of a modern protocol without needing to track which registries have finished their own migration.

What a request returns

POST /web/whois with a domain name, and the task looks up the registrar name, registration and expiration dates, domain status codes, and the authoritative nameservers, then returns them as structured JSON via signed webhook or a 24-hour signed link. No more splitting on colons and hoping the line order didn't change since last week.

Where it fits in real workflows

Domain brokers use it to verify ownership signals before a sale, security teams use it to trace who registered a suspicious lookalike domain, and dev tooling uses it to auto-fill registrar and nameserver fields in an internal domain inventory instead of asking someone to copy-paste from a registrar dashboard. Because it's async and webhook-driven, it slots into a batch job or an onboarding pipeline without anyone babysitting it.

Simple, predictable pricing

Each lookup costs $0.002, so auditing a list of hundreds of domains costs pennies rather than requiring a negotiated data contract with a registry. Only completed lookups are billed; if a task fails to run on our end it retries automatically up to three times at no charge, so a transient hiccup never shows up on your invoice, and you can budget a bulk audit down to the cent before you run it.

What you can do with it

Due diligence before a domain purchase

A broker checks registrar, registration date and nameservers to confirm a domain's history before negotiating a sale.

Trademark and brand protection

A legal team looks up registrant and registrar details on a suspicious lookalike domain as a first step before sending a takedown request.

Internal domain inventory

An IT team auto-populates a spreadsheet of company-owned domains with registrar and expiry data instead of checking each one by hand.

Nameserver migration audit

A dev ops team verifies that nameservers actually updated across dozens of domains after a bulk DNS provider migration.

FAQ

What fields does the WHOIS API return?

Registrar name, registration and expiration dates, domain status codes, and the authoritative nameservers, returned as structured JSON rather than raw text.

Is this real WHOIS or RDAP?

It queries RDAP, the structured, standardized successor protocol to classic WHOIS, and normalizes results so you get consistent fields across different registries.

Why not just parse WHOIS text myself?

You can, but every registry formats it differently and layouts change without notice; this endpoint absorbs that inconsistency so your integration doesn't break silently.

Is there a free plan or trial?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

Can I look up any TLD?

It covers domains whose registries expose RDAP or public registration data; a small number of legacy or heavily privacy-restricted registries may return limited fields.

How fast is the response?

The task runs asynchronously and typically completes quickly; you get the result via signed webhook or a signed link valid for 24 hours.

Am I charged if the domain is unregistered?

Yes, an 'available' or unregistered result is still a valid, billed lookup. You're only not charged if the task itself fails to execute, which is retried up to three times automatically.

Can I check domains in bulk?

You call the endpoint once per domain, but scripting it across a list is straightforward and stays cheap at $0.002 per lookup.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/web/whois

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/web/whois \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"domain":"ejemplo.com"}'

const res = await fetch("https://api.kit.forhosting.com/web/whois", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "domain": "ejemplo.com"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/web/whois",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "domain": "ejemplo.com"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/whois", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"domain":"ejemplo.com"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"domain":"ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/whois", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "domain": "ejemplo.com"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "web.whois",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`timeout_sec`	30
`max_crawl_pages`	25

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →