Domain Availability API Documentation
Overview
-
Domain Availability API
Domain Availability checker API helps you discover available domains with suggestions. -
Bulk Domain Availability API
This API is useful in situations where you would like to check the availability of multiple domains upto 100 at once.
Authorization
You can make authorized requests to our API by passing API key as a query parameter. To get your API key, login to our billing dashboard and get your API key! If your API key has been compromised, you can change it by clicking on reset button in billing dashboard.
Domain Availability API
API
https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY&domain=google.com

https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY&domain=google.com&sug=true

https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY&domain=google.com&sug=true&count=10

Input parameters: required
apiKey Get your API key on our billing dashboard.
domain The domain to check availability.
Input parameters: optional
sug For getting suggestions. It can be passed with or without count.
count If sug is true then count can be passed for desired number of suggestions. Default value of count is 5.
format Two formats are available JSON, XML. If you don't pass 'format' parameter, default format is JSON.
Code Snippets
curl --location --request GET 'https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY'
var request = require('request');
var options = {
'method': 'GET',
'url': 'https://api.whoisfreaks.com/v1.0/domain/availability?domain=freaks.com&apiKey=API_KEY',
'headers': {
}
};
request(options, function (error, response) {
if (error) throw new Error(error);
console.log(response.body);
});
OkHttpClient client = new OkHttpClient().newBuilder()
.build();
Request request = new Request.Builder()
.url("https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY")
.method("GET", null)
.build();
Response response = client.newCall(request).execute();
import http.client
conn = http.client.HTTPSConnection("api.whoisfreaks.com")
payload = ''
headers = {}
conn.request("GET", "/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
<?php
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;
require "uri"
require "net/http"
url = URI("https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Get.new(url)
response = https.request(request)
puts response.read_body
var requestOptions = {
method: 'GET',
redirect: 'follow'
};
fetch("https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY", requestOptions)
.then(response => response.text())
.then(result => console.log(result))
.catch(error => console.log('error', error));
var client = new RestClient("https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY");
client.Timeout = -1;
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY"
method := "GET"
client := &http.Client {
}
req, err := http.NewRequest(method, url, nil)
if err != nil {
fmt.Println(err)
return
}
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(curl, CURLOPT_URL, "https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
struct curl_slist *headers = NULL;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
res = curl_easy_perform(curl);
}
curl_easy_cleanup(curl);
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
var semaphore = DispatchSemaphore (value: 0)
var request = URLRequest(url: URL(string: "https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY")!,timeoutInterval: Double.infinity)
request.httpMethod = "GET"
let task = URLSession.shared.dataTask(with: request) { data, response, error in
guard let data = data else {
print(String(describing: error))
semaphore.signal()
return
}
print(String(data: data, encoding: .utf8)!)
semaphore.signal()
}
task.resume()
semaphore.wait()
Response
Following is explanation of API response
- DomainAvailability
- true: domain is not registered
- false: domain is already registered
{
"domain": "whoisfreaks.com",
"domainAvailability": false
}
With domain suggestions
{
"domain_available_response": [
{
"domain": "whoisfreaks.net",
"domainAvailability": true
},
{
"domain": "whoisfreaks.info",
"domainAvailability": true
},
{
"domain": "whoisfreaks.dev",
"domainAvailability": true
},
{
"domain": "whoisfreaks.top",
"domainAvailability": true
},
{
"domain": "whoisfreaks.org",
"domainAvailability": true
},
{
"domain": "whoisfreaks.com",
"domainAvailability": false
}
]
}
HTTP Error Codes
Below mentioned possible type of error and desc.
Bulk Domain Availability API
API
https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY

{
"domainNames":[
"google.com",
"google.uk",
"google.us"
]
}
https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY&domain=google.com

{
"tld":[
"com",
"uk",
"us"
]
}
Input parameters: required
apiKey Get your API key on our billing dashboard.
Input parameters: optional
format Two formats are available JSON, XML. If you don't pass 'format' parameter, default format is JSON.
Code Snippet
curl -d '{"domainNames":["google.com", "google.uk", "google.us"]}' -H "Content-Type: application/json" -X POST https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY
var request = require('request');
var requestBody = {"domainNames":["google.com", "google.uk", "google.us"]};
var options = {
'method': 'POST',
json: true,
body: requestBody
'url': 'https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY',
'headers': {
}
};
request(options, function (error, response) {
if (error) throw new Error(error);
console.log(response.body);
});
OkHttpClient client = new OkHttpClient();
MediaType mediaType= MediaType.parse("application/json; charset=utf-8");
List<String> domainsList = new ArrayList<>();
domainsList.add("google.com");
domainsList.add("google.uk");
domainsList.add("google.us");
HashMap<String, List<String>> domainMap = new HashMap<>();
domainMap.put("domainNames", domainsList);
ObjectMapper objectMapper = new ObjectMapper();
String jsonDataString = objectMapper.writeValueAsString(domainMap);
RequestBody requestBody = RequestBody.create (mediaType, jsonDataString);
Request request = new Request.Builder()
.url("https://api.whoisfreaks.com/v1.0/domain/availability?domain=jfreaks.com&apiKey=API_KEY")
.method("POST", requestBody)
.addHeader("content-type", "application/json; charset=utf-8")
.build();
Response response = client.newCall(request).execute();
import http.client
import json
jsonData = {"domainNames":["google.com", "google.uk", "google.us"]}
payload = json.dumps(jsonData)
headers = {"content-type": "application/json"}
conn = http.client.HTTPSConnection("api.whoisfreaks.com")
conn.request("GET", "/v1.0/domain/availability?apiKey=API_KEY", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
<?php
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => true,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS =>'{
"domainNames":
[
"google.com",
"google.us",
"google.uk"
]
}',
CURLOPT_HTTPHEADER => array(
'Content-Type: application/json'
),
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;
require "uri"
require "net/http"
require 'json'
url = URI("https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY")
header = {'Content-Type': 'application/json'}
data= {"domainNames" => ["google.com", "google.us", "google.uk"]}
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url.request_uri, header)
request.body = data.to_json
response = https.request(request)
puts response.read_body
fetch("https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY", {
method: "POST",
body: JSON.stringify({
"domainNames": ["google.com", "google.us", "google.uk"],
}),
headers: {
"Content-type": "application/json; charset=UTF-8"
}
})
.then(response => response.json())
.then(json => console.log(json));
var client = new RestClient("https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY");
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
var body = @"{" + "\n" +
@" ""domainNames"":" + "\n" +
@" [" + "\n" +
@" ""google.com""," + "\n" +
@" ""google.us""," + "\n" +
@" ""google.uk""" + "\n" +
@" ]" + "\n" +
@"}";
request.AddParameter("application/json", body, ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);
package main
import (
"fmt"
"strings"
"net/http"
"io/ioutil"
)
func main() {
url := "https://api.whoisfreaks.com/v1.0/domain/availability?apiKey=API_KEY"
method := "POST"
payload := strings.NewReader(`{
"domainNames":["google.com", "google.us", "google.uk"]
}`)
client := &http.Client {
}
req, err := http.NewRequest(method, url, payload)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Content-Type", "application/json")
res, err := client.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(string(body))
}
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl) {
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(curl, CURLOPT_URL, "https://api.whoisfreaks.com/v1.0/domain/available?apiKey=API_KEY");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_DEFAULT_PROTOCOL, "https");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
const char *data = "{\n \"domainNames\":\n [\n \"google.com\",\n \"google.us\",\n \"google.uk\"\n ]\n}";
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
res = curl_easy_perform(curl);
}
curl_easy_cleanup(curl);
import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif
var semaphore = DispatchSemaphore (value: 0)
let parameters = "{\n \"domainNames\":\n [\n \"google.com\",\n \"google.us\",\n \"google.uk\"\n ]\n}"
let postData = parameters.data(using: .utf8)
var request = URLRequest(url: URL(string: "https://api.whoisfreaks.com/v1.0/domain/available?apiKey=API_KEY")!,timeoutInterval: Double.infinity)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = postData
let task = URLSession.shared.dataTask(with: request) { data, response, error in
guard let data = data else {
print(String(describing: error))
semaphore.signal()
return
}
print(String(data: data, encoding: .utf8)!)
semaphore.signal()
}
task.resume()
semaphore.wait()
Response
Following is explanation of API response
- DomainAvailability
- true: domain is not registered
- false: domain is already registered
- Status
- true: domain data is fetched successfully and its result is correct
- false: domain data cannot be fetched and its result is incorrect. No credits will be charged in this case
{
"bulk_domain_availability_response": [
{
"domain": "google.uk",
"domainAvailability": false,
"status": true
},
{
"domain": "google.us",
"domainAvailability": false,
"status": true
},
{
"domain": "abc.com",
"domainAvailability": false,
"status": true
},
{
"domain": "google.com",
"domainAvailability": false,
"status": true
}
]
}
Bulk Domain Availability with custom TLDs
{
"bulk_domain_availability_response": [
{
"domain": "whoisfreaks.us",
"domainAvailability": true,
"status": true
},
{
"domain": "whoisfreaks.uk",
"domainAvailability": true,
"status": true
},
{
"domain": "whoisfreaks.com",
"domainAvailability": false,
"status": true
}
]
}
HTTP Error Codes
Below mentioned possible type of error and descCredits Usage API
You need credits to use the domain availability API. One credit will be charged for each domain that is returned in bulk operation. Single domain availability query will be charged 1 credit without suggestions.If you enable suggestions, we will charge 1 credit for every 5 suggestions. You can fetch credits usage and remaining credits information through an API.
https://api.whoisfreaks.com/v1.0/whoisapi/usage?apiKey=API_KEY

Input parameters: required
apiKey Get your API key from our billing dashboard.
Input parameters: optional
format Two formats are available JSON, XML. If you don't pass 'format' parameter, default format is JSON.
Response
You can get API key from our billing dashboard.
{
"apiKey": "API_KEY",
"apiCredits": {
"totalCredits": 1020079,
"servedRequest": 1533
},
"apiSubscription": {
"subscriptionStatus": "deactivated",
"requestLimit": 0,
"servedRequests": 18,
"surchargeRequestLimit": 0,
"servedSurchargeRequests": 0
}
}
FAQs
What is Domain Availability API?
Our Domain Availability API checks if a domain is available for registration or not. It also suggests other domains and their availability for registration.
What is criteria for Domain Suggestions?
Domains are suggested based on a GTLDs that are more popular in terms of higher number of domains registered with that particular TLD.
What is Bulk Domain Availability API?
Bulk Domain Availability API allows you to check domain availability of multiple domains in a single request. A maximum of 100 domains can be sent in a single request. Moreover, it generates suggestions based on custom TLDs.
What is the response time for Bulk Domain Availability API?
Bulk Domain Availability API response takes from 16 seconds to 1 minute for 100 domains.
What is the number of free API credits available for new users, and are these credits rate-limited?
We will provide 500 API credits to new users and yes, those credits have a rate-limiting of 10 requests per minute for Live APIs, 5 requests per minute for Bulk Domain Lookup, and 1 request per minute for Reverse/Historical Endpoints.
Do you have rate limiting on number of requests being made on your paid plans?
Yes, we have rate limiting on requests being made on all of our paid plans. The requests limit is shown in the following table.
The Table is divided into three types of plans:
1) API Credits
Credits | live-rpm | bulk-rpm | historical/reverse-rpm |
---|---|---|---|
5000 | 20 | 8 | 3 |
15000 | 35 | 12 | 5 |
50000 | 80 | 20 | 10 |
150000 | 120 | 25 | 15 |
450000 | 150 | 35 | 20 |
1000000 | 200 | 50 | 25 |
3000000 | 300 | 70 | 35 |
2) API Subscription (Monthly)
Credits | live-rpm | bulk-rpm | historical/reverse-rpm |
---|---|---|---|
5000 | 20 | 8 | 3 |
15000 | 35 | 12 | 5 |
50000 | 80 | 20 | 10 |
150,000 | 120 | 25 | 15 |
450,000 | 150 | 35 | 20 |
1,000,000 | 200 | 50 | 25 |
3,000,000 | 300 | 70 | 35 |
3) API Subscription (Yearly)
Credits | live-rpm | bulk-rpm | historical/reverse-rpm |
---|---|---|---|
60,000 | 20 | 8 | 3 |
180,000 | 35 | 12 | 5 |
600,000 | 80 | 20 | 10 |
1,800,000 | 120 | 25 | 15 |
5,400,000 | 150 | 35 | 20 |
12,000,000 | 200 | 50 | 25 |
36,000,000 | 300 | 70 | 35 |
43,200,000 | 500 | 100 | 50 |
- live-rpm: API requests per minute limit for live Whois lookup API, domain availability API, SSL certificate lookup API, and DNS lookup API endpoints.
- bulk-rpm: API requests per minute limit for bulk domain Whois lookup API endpoint.
- historical/reverse-rpm: API requests per minute limit for historical, and reverse Whois API endpoints.
Do you provide any headers in API response regarding rate limiting?
Yes, there are following three header parameters in the response:
- X-RateLimit-Allowed-Requests (Tells the max allowed API requests per minute on a specific plan)
- X-RateLimit-Remaining-Requests (Tells the remaining API requests per minute for that plan)
- X-RateLimit-Remaining-Time (Tells after how much time the API requests per minute will be reset)