Brand Alert API
Bulk Whois API
DNS Lookup API
Domain Availability API
Email Verification API
Registrant Alert API
Reverse Whois API
Whois API

Making a query to Registrant Alert API web service

Here you’ll find short examples of using www.whoisxmlapi.com Hosted Registrant Alert Web API implemented in multiple languages.

You can view more sample code, incl. dealing with the API’s response formats and more, in the repository.

Please, refer to Registrant Alert API User Guide for request and response formats, usage limits.

using System;
using System.IO;
using System.Net;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

// Note that you need to make sure your Project is set to ".NET Framework 4"
// and NOT ".NET Framework 4 Client Profile". Once that is set, make sure the
// following references are present under the References tree under the
// project: Microsoft.CSharp, System, System.Web.Extensions, and System.XML.

namespace RegistrantAlertApi
{
    public static class RegistrantAlertApiV2Sample
    {
        private const string ApiKey = "Your registrant alert api key";

        private const string Url =
            "https://registrant-alert.whoisxmlapi.com/api/v2";

        private const string SearchParamsAdvanced =
            @"{
                advancedSearchTerms: [
                    {
                        field: 'RegistrantContact.Name',
                        term: 'Test'
                    }
                ],
                sinceDate: '2018-07-12',
                mode: 'purchase',
                apiKey: 'API_KEY'
            }";

        private const string SearchParamsBasic =
            @"{
                basicSearchTerms: {
                    include: [
                        'test',
                        'US'
                    ],
                    exclude: [
                        'Europe',
                        'EU'
                    ]
                },
                sinceDate: '2018-07-12',
                mode: 'purchase',
                apiKey: 'API_KEY'
            }";

        private static void Main()
        {
            var responsePost = SendPostRegistrantAlert();
            PrintResponse(responsePost);

            responsePost = SendPostRegistrantAlert(true);
            PrintResponse(responsePost);

            // Prevent command window from automatically closing
            Console.WriteLine("\nPress any key to continue...");
            Console.ReadKey();
        }

        private static void PrintResponse(string response)
        {
            dynamic responseObject = JsonConvert.DeserializeObject(response);

            if (responseObject != null)
            {
                Console.Write(responseObject);
                Console.WriteLine("--------------------------------");
                return;
            }

            Console.WriteLine(response);
            Console.WriteLine();
        }

        private static string SendPostRegistrantAlert(bool isAdvanced=false)
        {
            Console.Write("Sending request to: " + Url + "\n");

            var httpWebRequest = (HttpWebRequest)WebRequest.Create(Url);
            httpWebRequest.ContentType = "application/json";
            httpWebRequest.Method = "POST";

            var searchParams =
                isAdvanced ? SearchParamsAdvanced : SearchParamsBasic;

            using (var streamWriter =
                        new StreamWriter(httpWebRequest.GetRequestStream()))
            {
                var json = searchParams.Replace("API_KEY", ApiKey);
                var jsonData = JObject.Parse(json).ToString();

                streamWriter.Write(jsonData);
                streamWriter.Flush();
                streamWriter.Close();
            }

            var res = "";

            using (var response=(HttpWebResponse)httpWebRequest.GetResponse())
            using (var responseStream = response.GetResponseStream())
            {
                if (responseStream == null || responseStream == Stream.Null)
                {
                    return res;
                }

                using (var streamReader = new StreamReader(responseStream))
                {
                    res = streamReader.ReadToEnd();
                }

                return res;
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;

import javax.net.ssl.HttpsURLConnection;

import com.google.gson.*;

public class RegistrantAlertV2Sample
{
    private String apiKey;

    public static void main(String[] args) throws Exception
    {
        RegistrantAlertV2Sample query = new RegistrantAlertV2Sample();

        // Fill in your details
        query.setApiKey("Your registrant alert api key");

        try {
            String responseStringPost = query.sendPost();
            query.prettyPrintJson(responseStringPost);

            responseStringPost = query.sendPost(true);
            query.prettyPrintJson(responseStringPost);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getApiKey(boolean quotes)
    {
        if (quotes)
            return "\"" + this.getApiKey() + "\"";
        else
            return this.getApiKey();
    }

    public void setApiKey(String apiKey)
    {
        this.apiKey = apiKey;
    }

    public String sendPost() throws Exception
    {
        return sendPost(false);
    }

    // HTTP POST request
    public String sendPost(boolean isAdvanced) throws Exception
    {
        String userAgent = "Mozilla/5.0";
        String url = "https://registrant-alert.whoisxmlapi.com/api/v2";

        URL obj = new URL(url);
        HttpsURLConnection con = (HttpsURLConnection) obj.openConnection();

        con.setRequestMethod("POST");
        con.setRequestProperty("User-Agent", userAgent);

        String terms = isAdvanced ? getAdvancedTerms() : getBasicTerms();

        // Send POST request
        con.setDoOutput(true);
        DataOutputStream wr = new DataOutputStream(con.getOutputStream());
        wr.writeBytes(terms);
        wr.flush();
        wr.close();

        System.out.println("\nSending 'POST' request to URL : " + url);

        BufferedReader in = new BufferedReader(
                new InputStreamReader(con.getInputStream()));

        String inputLine;
        StringBuilder response = new StringBuilder();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        return response.toString();
    }

    private String getAdvancedTerms()
    {
        String field = "\"field\": \"RegistrantContact.Name\"";
        String term = "\"term\": \"Test\"";
        String options = this.getRequestOptions();
        String searchTerms = "{ " + field + ", " + term + " }";

        String terms =
                "\"advancedSearchTerms\": [" + searchTerms + "]";

        return "{ " + terms + ", "  + options +" }";
    }

    private String getApiKey()
    {
        return this.apiKey;
    }

    private String getBasicTerms()
    {
        String exclude = "\"exclude\": [\"pay\"]";
        String include = "\"include\": [\"test\"]";
        String options = this.getRequestOptions();

        String terms =
                "\"basicSearchTerms\": {" + include + ", " + exclude + "}";

        return "{ " + terms + ", "  + options +" }";
    }

    private String getRequestOptions()
    {
        return "\"sinceDate\": \"2018-07-16\","
                + "\"mode\": \"purchase\","
                + "\"apiKey\": " + this.getApiKey(true);
    }

    private void prettyPrintJson(String jsonString)
    {
        Gson gson = new GsonBuilder().setPrettyPrinting().create();

        JsonParser jp = new JsonParser();
        JsonElement je = jp.parse(jsonString);
        String prettyJsonString = gson.toJson(je);

        System.out.println("\n\n" + prettyJsonString);
        System.out.println("----------------------------------------");
    }
}

<!DOCTYPE html>
<html>
<head>
    <title>Registrant Alert API 2.0 jQuery Search Sample</title>
    <script src="https://code.jquery.com/jquery-3.2.1.min.js"></script>
    <script type="text/javascript">

        var url = "https://registrant-alert.whoisxmlapi.com/api/v2";
        var apiKey = "Your registrant alert api key";

        var post_data_basic = {
            "apiKey": apiKey,
            "sinceDate": "2018-07-15",
            "mode": "purchase",
            "basicSearchTerms": {
                "include": [
                    "cinema",
                ],
                "exclude": [
                    "online"
                ]
            }
        };

        var post_data_advanced = {
            "apiKey": apiKey,
            "sinceDate": "2018-07-15",
            "mode": "purchase",
            "advancedSearchTerms": [
                {
                    "field": "RegistrantContact.Name",
                    "term": "Test"
                }
            ]
        };

        $(function() {
            $.post(
                url,
                JSON.stringify(post_data_basic),
                function(data) {
                    $("body").append("Basic:<br>"
                        + "<pre>" + JSON.stringify(data, null, 2) + "</pre>");
                }
            );
            $.post(
                url,
                JSON.stringify(post_data_advanced),
                function(data) {
                    $("body").append("Advanced:<br>"
                        + "<pre>" + JSON.stringify(data, null, 2) + "</pre>");
                }
            );
        });

    </script>
</head>
<body></body>
</html>

var https = require('https');

// Fill in your details
var api_key = 'Your registrant alert api key';

// Build the post string

var post_data_advanced = {
    advancedSearchTerms: [
        {
            field: 'RegistrantContact.Name',
            term: 'Test'
        }
    ],
    apiKey: api_key,
    mode: 'purchase',
    sinceDate: '2018-07-12'
};

var post_data_basic = {
    basicSearchTerms: {
        include: [
            'test',
            'US'
        ],
        exclude: [
            'Europe',
            'EU'
        ],
    },
    apiKey: api_key,
    mode: 'purchase',
    sinceDate: '2018-07-12'
};

function api_call(data, callback)
{

    var body = '';

    var opts = {
        hostname: 'registrant-alert.whoisxmlapi.com',
        path: '/api/v2',
        method:'POST',
        headers: {
            'Content-Type': 'application/json',
            'Accept': 'application/json',
            'Content-Length': JSON.stringify(data).length
        }
    };

    var req = https.request(opts, function(response) {
        response.on('data', function(chunk) {
            body += chunk;
        });
        response.on('end', function() {
            callback(JSON.parse(body));
        });
    });

    req.on('error', function(e) {
        console.error(e);
        process.exit(1);
    });

    req.write(JSON.stringify(data));
    req.end();
}

// Send requests and log responses

api_call(post_data_basic, function(body) {
    console.log('Basic:');
    console.log(body);

    api_call(post_data_advanced, function(body) {
        console.log('Advanced:');
        console.log(body);
    });
});


<?php

$apiKey = 'Your registrant alert api key';

$termsAdvanced = array(
    'advancedSearchTerms' => array(
        array(
            'field' => 'RegistrantContact.Name',
            'term' => 'Test'
        )
    ),
    'mode' => 'purchase',
    'apiKey' => $apiKey,
    'sinceDate' => '2018-07-15'
);

$termsBasic = array(
    'basicSearchTerms' => array(
        'include' => array(
            'whois',
            'api'
        ),
        'exclude' => array(
            '.tk'
        )
    ),
    'mode' => 'purchase',
    'apiKey' => $apiKey,
    'sinceDate' => '2018-06-15'
);

function registrant_alert_api(array $data=array())
{
    $header ="Content-Type: application/json\r\nAccept: application/json\r\n";

    $url = 'https://registrant-alert.whoisxmlapi.com/api/v2';

    $options = array(
        'http' => array(
            'method' => 'POST',
            'header' => $header,
            'content' => json_encode($data)
        )
    );

    return file_get_contents($url, false, stream_context_create($options));
}

print('Basic:' . PHP_EOL);
print_r(json_decode(registrant_alert_api($termsBasic)));

print('Advanced:' . PHP_EOL);
print_r(json_decode(registrant_alert_api($termsAdvanced)));

#!/usr/bin/perl

use HTTP::Request::Common qw{ POST }; # From CPAN
use JSON qw( decode_json );           # From CPAN
use LWP::UserAgent;                   # From CPAN

use strict;
use warnings;

########################
# Fill in your details #
########################
my $api_key = 'Your registrant alert api key';

my $url = 'https://registrant-alert.whoisxmlapi.com/api/v2';

my $search_params_advanced = '{
    "advancedSearchTerms": [
        {
            "field": "RegistrantContact.Name",
            "term": "Test"
        }
    ],
    "apiKey": "' . $api_key . '",
    "mode": "purchase",
    "sinceDate": "2018-07-12"
}';

my $search_params_basic = '{
    "basicSearchTerms": {
        "include": [
            "whois",
            "api"
        ],
        "exclude": [
            ".ga"
        ]
    },
    "apiKey": "' . $api_key . '",
    "mode": "purchase",
    "sinceDate": "2018-06-15"
}';

#######################
# Basic search        #
#######################

my $response = JSON->new->decode(registrantAlertApiSearch(0));
print "Basic\n---\n";
print JSON->new->pretty->encode($response);

#######################
# Advanced search     #
#######################

$response = JSON->new->decode(registrantAlertApiSearch(1));
print "Advanced\n---\n";
print JSON->new->pretty->encode($response);

#######################
# Getting the data    #
#######################

sub registrantAlertApiSearch {
    my ($isAdvanced) = @_;

    my $ua = LWP::UserAgent->new(ssl_opts => { verify_hostname => 0 });
    my $req = HTTP::Request->new('POST', $url);

    my $search_params =
        $isAdvanced ? $search_params_advanced : $search_params_basic;

    $req->header('Content-Type' => 'application/json');
    $req->header('Accept', 'application/json');
    $req->content($search_params);

    my $result = $ua->request($req);

    return $result->content;
}

########################
# Fill in your details #
########################

$apiKey = 'Your registrant alert api key'

$paramsAdvanced = @{
    advancedSearchTerms = @(
        @{
            field = 'RegistrantContact.Name'
            term = 'Test'
        }
    )
    apiKey = $apiKey
    mode = 'purchase'
    sinceDate = '2018-07-15'
} | ConvertTo-Json

$paramsBasic = @{
    basicSearchTerms = @{
        include = @(
            'whois',
            'api'
        )
        exclude = @(
            '.ml'
        )
    }
    apiKey = $apiKey
    mode = 'purchase'
    sinceDate = '2018-06-15'
} | ConvertTo-Json

#######################
# POST request        #
#######################

$uri = 'https://registrant-alert.whoisxmlapi.com/api/v2'

$response = Invoke-WebRequest -Uri $uri -Method POST -Body $paramsBasic `
            -ContentType 'application/json'

echo 'Basic:'
echo $response.content | convertfrom-json | convertto-json -depth 10

$response = Invoke-WebRequest -Uri $uri -Method POST -Body $paramsAdvanced `
            -ContentType 'application/json'

echo 'Advanced:'
echo $response.content | convertfrom-json | convertto-json -depth 10

try:
    import http.client as http
except ImportError:
    import httplib as http

import json

api_key = 'Your registrant alert api key'

payload_advanced = {
    'advancedSearchTerms': [
        {
            'field': 'RegistrantContact.Name',
            'term': 'Test'
        }
    ],
    'mode': 'purchase',
    'sinceDate': '2018-07-14',
    'apiKey': api_key
}

payload_basic = {
    'basicSearchTerms': {
        'include': [
            'whois',
            'api'
        ],
        'exclude': [
            '.win'
        ]
    },
    'mode': 'purchase',
    'sinceDate': '2018-07-14',
    'apiKey': api_key
}


def print_response(txt):
    response_json = json.loads(txt)
    print(json.dumps(response_json, indent=4, sort_keys=True))


headers = {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
}

conn = http.HTTPSConnection('registrant-alert.whoisxmlapi.com')

conn.request('POST', '/api/v2', json.dumps(payload_basic), headers)
text = conn.getresponse().read().decode('utf8')
print('Basic:')
print_response(text)

conn.request('POST', '/api/v2', json.dumps(payload_advanced), headers)
text = conn.getresponse().read().decode('utf8')
print('Advanced:')
print_response(text)

require 'json'
require 'net/https'
require 'openssl'
require 'uri'
require 'yaml' # only needed to print the returned result in a very pretty way

url = 'https://registrant-alert.whoisxmlapi.com/api/v2'

########################
# Fill in your details #
########################
key = 'Your registrant alert api key'

params_advanced = {
  advancedSearchTerms: [
    {
      field: 'RegistrantContact.Name',
      term: 'Test'
    }
  ],
  mode: 'purchase',
  apiKey: key,
  sinceDate: '2018-07-10'
}

params_basic = {
  basicSearchTerms: {
    include: %w[
      whois
      api
    ],
    exclude: %w[
      online
    ]
  },
  mode: 'purchase',
  apiKey: key,
  sinceDate: '2018-07-10'
}

uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)

# Connect using ssl
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(uri.request_uri)

# Set headers
request.add_field('Content-Type', 'application/json')
request.add_field('Accept', 'application/json')

# Basic search

request.body = params_basic.to_json
response = http.request(request)

# Print pretty parsed json
puts 'Basic:'
puts JSON.parse(response.body).to_yaml

# Advanced search

request.body = params_advanced.to_json
response = http.request(request)

puts "\nAdvanced:"
puts JSON.parse(response.body).to_yaml