WHOIS Lookup - SimpleWebAPIs

Overview

The WHOIS Lookup API queries domain registration data and returns registrar information, creation and expiration dates, nameservers, domain status, and registrant details. Supports all major TLDs with automatic WHOIS server routing.

Endpoint

POST /api/whoislookup

GET /api/whoislookup/lookup?domain=example.com

Request Parameters

Parameter	Type	Required	Description
domain	string	Yes	The domain name to look up (e.g. example.com)

Response Fields

The response is wrapped in a standard API envelope:

Field	Type	Description
success	boolean	`true` on success
data.domain	string	The queried domain name
data.registrar	string	Domain registrar name
data.createdDate	datetime	Domain registration date (ISO 8601)
data.updatedDate	datetime	Last update date (ISO 8601)
data.expirationDate	datetime	Domain expiration date (ISO 8601)
data.nameservers	array	List of nameserver hostnames
data.status	array	Domain status codes (e.g. clientDeleteProhibited)
data.registrantName	string	Registrant name (may be redacted for privacy)
data.registrantOrganization	string	Registrant organization (may be redacted for privacy)
data.registrantCountry	string	Registrant country code (may be redacted for privacy)
data.dnssec	string	DNSSEC status (e.g. signedDelegation)
data.rawText	string	Full raw WHOIS response text
data.queryTimeMs	int	Total query time in milliseconds

Example

Look up WHOIS data for a domain:

Warning: Passing your API key as a query parameter exposes it in server logs, browser history, and referrer headers. Only use this method in server-to-server or controlled environments.

https://simplewebapis.com/api/whoislookup/lookup?domain=example.com&api_key=swa_your_key

curl -X POST https://simplewebapis.com/api/whoislookup \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: swa_your_key" \
  -d '{"domain": "example.com"}'

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "swa_your_key");

var payload = new { domain = "example.com" };
var json = JsonSerializer.Serialize(payload);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync(
    "https://simplewebapis.com/api/whoislookup", content);
var result = await response.Content
    .ReadFromJsonAsync<WhoisLookupResponse>();
Console.WriteLine(result?.Data?.Registrar);

// -- Response model  --

record WhoisLookupResponse(
    bool Success,
    string? Message,
    WhoisLookupData? Data);

record WhoisLookupData(
    string Domain,
    string? Registrar,
    DateTime? CreatedDate,
    DateTime? UpdatedDate,
    DateTime? ExpirationDate,
    List<string> Nameservers,
    List<string> Status,
    string? RegistrantName,
    string? RegistrantOrganization,
    string? RegistrantCountry,
    string? Dnssec,
    string RawText,
    int QueryTimeMs);

$ch = curl_init('https://simplewebapis.com/api/whoislookup');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'X-Api-Key: swa_your_key',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'domain' => 'example.com',
    ]),
    CURLOPT_RETURNTRANSFER => true,
]);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
echo $data['data']['registrar'];

const response = await fetch('https://simplewebapis.com/api/whoislookup', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Api-Key': 'swa_your_key',
  },
  body: JSON.stringify({
    domain: 'example.com',
  }),
});

const result = await response.json();
console.log(result.data.registrar);

import requests

response = requests.post(
    'https://simplewebapis.com/api/whoislookup',
    headers={
        'Content-Type': 'application/json',
        'X-Api-Key': 'swa_your_key',
    },
    json={'domain': 'example.com'},
)

data = response.json()
print(data['data']['registrar'])

body, _ := json.Marshal(map[string]string{
    "domain": "example.com",
})
req, _ := http.NewRequest("POST",
    "https://simplewebapis.com/api/whoislookup",
    bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-Api-Key", "swa_your_key")

resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var result map[string]any
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result["data"])

require 'net/http'
require 'json'

uri = URI('https://simplewebapis.com/api/whoislookup')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['X-Api-Key'] = 'swa_your_key'
request.body = { domain: 'example.com' }.to_json

response = http.request(request)
data = JSON.parse(response.body)
puts data['data']['registrar']

var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://simplewebapis.com/api/whoislookup"))
    .header("Content-Type", "application/json")
    .header("X-Api-Key", "swa_your_key")
    .POST(HttpRequest.BodyPublishers.ofString(
        "{\"domain\":\"example.com\"}"))
    .build();

var response = client.send(request,
    HttpResponse.BodyHandlers.ofString());
var mapper = new ObjectMapper();
var result = mapper.readTree(response.body());
System.out.println(result.get("data").get("registrar"));

let client = reqwest::blocking::Client::new();
let response = client
    .post("https://simplewebapis.com/api/whoislookup")
    .header("Content-Type", "application/json")
    .header("X-Api-Key", "swa_your_key")
    .json(&serde_json::json!({
        "domain": "example.com",
    }))
    .send()?;

let result: serde_json::Value = response.json()?;
println!("{}", result["data"]["registrar"]);

The response is a JSON object (Content-Type: application/json).

Try it out

Use the Playground to test this API live.