DNS Lookup Examples · Example 2 of 3 in Special Answers

A Domain That Is Not Registered

GEThttps://api.deepinfo.com/v1/lookup/dns

An A lookup of a domain that does not exist: rcode NXDOMAIN, with raw and values null.

Param: domain type
Value: no-such-domain-deepinfo-docs.com A

Asks for the A records of no-such-domain-deepinfo-docs.com, a domain that is not registered.

The resolver answers NXDOMAIN (non-existent domain) in rcode, and raw and values are null. The request itself still returns HTTP 200: check rcode to tell a missing name from a name without records.

Only an NXDOMAIN answer proves that a name does not exist. Some DNS providers, among them zones signed with DNSSEC "compact denial of existence", answer NOERROR without records for names that do not exist, so an empty NOERROR answer alone does not prove that a name exists.

Request

curl

curl 'https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A' \
  -H 'apikey: YOUR_API_KEY' \
  -H 'Accept: application/json'

Python

import requests

url = "https://api.deepinfo.com/v1/lookup/dns"

params = {
    "domain": "no-such-domain-deepinfo-docs.com",
    "type": "A"
}

headers = {
    "apikey": "YOUR_API_KEY",
    "Accept": "application/json"
}

response = requests.get(url, params=params, headers=headers)
response.raise_for_status()
print(response.json())

JavaScript

const url = "https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A";

const response = await fetch(url, {
  method: "GET",
  headers: {
    "apikey": "YOUR_API_KEY",
    "Accept": "application/json"
  },
});

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

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("apikey", "YOUR_API_KEY")
	req.Header.Set("Accept", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	body, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(body))
}

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A"))
            .header("apikey", "YOUR_API_KEY")
            .header("Accept", "application/json")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A");
request.Headers.Add("apikey", "YOUR_API_KEY");
request.Headers.Add("Accept", "application/json");

using var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PHP

<?php

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'apikey: YOUR_API_KEY',
        'Accept: application/json',
    ],
]);

$response = curl_exec($curl);

if ($response === false) {
    throw new RuntimeException(curl_error($curl));
}

echo $response . PHP_EOL;

Ruby

require 'net/http'
require 'uri'

uri = URI('https://api.deepinfo.com/v1/lookup/dns?domain=no-such-domain-deepinfo-docs.com&type=A')

request = Net::HTTP::Get.new(uri)
request['apikey'] = 'YOUR_API_KEY'
request['Accept'] = 'application/json'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end

puts response.body

Response

200 OK · application/json

Response Body

{
  "fqdn": "no-such-domain-deepinfo-docs.com",
  "requested_types": [
    "A"
  ],
  "responses": [
    {
      "type": "A",
      "conn_status": "success",
      "rcode": "NXDOMAIN",
      "raw": null,
      "values": null,
      "server": "8.8.8.8"
    }
  ],
  "servers": [
    "8.8.8.8"
  ],
  "check_date": "2026-09-24T07:49:41Z"
}

Content-Type: application/json
ratelimit-limit: 100000
ratelimit-remaining: 99997
ratelimit-reset: 19
x-ratelimit-limit-minute: 100000
x-ratelimit-remaining-minute: 99997
deepinfo-request-id: 5f0c6a8e-1b2d-4c3e-9f4a-7b8c9d0e1f2a

Request

What this example sends. Every parameter is documented on DNS; the exact request is in the code panel.

Parameter	Value
`domain`query	`no-such-domain-deepinfo-docs.com`
`type`query	`A`

Reference updated September 24, 2026

Request

Related Examples