Make Informed Decisions with Comprehensive Domain Intelligence

# WHOIS lookup
curl -X POST https://api.domine.io/whois \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain": "example.com"}'

# DNS lookup
curl -X POST https://api.domine.io/dns \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain": "example.com", "record_type": "A"}'

# SSL certificate check
curl -X POST https://api.domine.io/ssl \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain": "example.com"}'

import requests

# WHOIS lookup
response = requests.post('https://api.domine.io/whois', 
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={'domain': 'example.com'}
)

whois_data = response.json()
print(whois_data['registrant']['organization'])

# WordPress detection
wp_response = requests.post('https://api.domine.io/wordpress', 
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={'domain': 'example.com'}
)

wp_data = wp_response.json()
if wp_data['is_wordpress']:
    print(f"WordPress version: {wp_data['version']}")

<?php
// WHOIS lookup
$data = json_encode(['domain' => 'example.com']);
$options = [
    'http' => [
        'header' => "Authorization: Bearer YOUR_API_KEY\r\n" .
                   "Content-Type: application/json\r\n",
        'method' => 'POST',
        'content' => $data
    ]
];

$context = stream_context_create($options);
$response = file_get_contents('https://api.domine.io/whois', false, $context);
$whoisData = json_decode($response, true);

echo $whoisData['registrant']['organization'];
?>

const axios = require('axios');

// WHOIS lookup with Node.js
async function lookupWhois(domain) {
  try {
    const response = await axios.post('https://api.domine.io/whois', {
      domain: domain
    }, {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      }
    });
    
    return response.data;
  } catch (error) {
    console.error('WHOIS lookup failed:', error);
  }
}

// Usage
lookupWhois('example.com').then(data => {
  console.log('Registrant:', data.registrant.organization);
});

require 'net/http'
require 'json'

# WHOIS lookup with Ruby
def whois_lookup(domain)
  uri = URI('https://api.domine.io/whois')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  
  request = Net::HTTP::Post.new(uri)
  request['Authorization'] = 'Bearer YOUR_API_KEY'
  request['Content-Type'] = 'application/json'
  request.body = { domain: domain }.to_json
  
  response = http.request(request)
  JSON.parse(response.body)
end

# Usage
data = whois_lookup('example.com')
puts "Registrant: #{data['registrant']['organization']}"

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

type WhoisRequest struct {
    Domain string `json:"domain"`
}

func whoisLookup(domain string) error {
    reqBody := WhoisRequest{Domain: domain}
    jsonData, _ := json.Marshal(reqBody)
    
    req, _ := http.NewRequest("POST", "https://api.domine.io/whois", 
                              bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println("Registrant:", result["registrant"])
    
    return nil
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class DomineApiClient
{
    private readonly HttpClient _httpClient;
    
    public DomineApiClient(string apiKey)
    {
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
    }
    
    public async Task WhoisLookup(string domain)
    {
        var requestBody = new { domain = domain };
        var json = JsonConvert.SerializeObject(requestBody);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await _httpClient.PostAsync("https://api.domine.io/whois", content);
        var responseString = await response.Content.ReadAsStringAsync();
        
        return JsonConvert.DeserializeObject(responseString);
    }
}

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

public class DomineApiClient {
    private final HttpClient httpClient;
    private final String apiKey;
    
    public DomineApiClient(String apiKey) {
        this.httpClient = HttpClient.newHttpClient();
        this.apiKey = apiKey;
    }
    
    public String whoisLookup(String domain) throws Exception {
        String jsonBody = String.format("{\"domain\":\"%s\"}", domain);
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.domine.io/whois"))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
            
        HttpResponse response = httpClient.send(request, 
            HttpResponse.BodyHandlers.ofString());
            
        return response.body();
    }
}

use reqwest::Client;
use serde_json::json;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = Client::new();
    
    let response = client
        .post("https://api.domine.io/whois")
        .header("Authorization", "Bearer YOUR_API_KEY")
        .header("Content-Type", "application/json")
        .json(&json!({
            "domain": "example.com"
        }))
        .send()
        .await?;
    
    let whois_data: HashMap = response.json().await?;
    
    if let Some(registrant) = whois_data.get("registrant") {
        println!("Registrant: {:?}", registrant);
    }
    
    Ok(())
}