DNS Resolver

curl "https://www.osintcat.net/api/dns-resolver?query=example.com" \
     -H "X-API-KEY: YOUR_API_KEY"

import requests

url = "https://www.osintcat.net/api/dns-resolver"
params = {"query": "example.com"}
headers = {"X-API-KEY": "YOUR_API_KEY"}

response = requests.get(url, params=params, headers=headers)

if response.ok:
    print(response.json())
else:
    print(f"Error: {response.status_code}")

const url = 'https://www.osintcat.net/api/dns-resolver?query=example.com';

fetch(url, {
    headers: {
        'X-API-KEY': 'YOUR_API_KEY'
    }
})
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:' + err));

<?php

$curl = curl_init();

$url = "https://www.osintcat.net/api/dns-resolver?query=example.com";

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "X-API-KEY: YOUR_API_KEY"
    ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #:" . $err;
} else {
    echo $response;
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    baseURL := "https://www.osintcat.net/api/dns-resolver"
    params := url.Values{}
    params.Add("query", "example.com")
    
    fullURL := baseURL + "?" + params.Encode()
    
    req, _ := http.NewRequest("GET", fullURL, nil)
    req.Header.Set("X-API-KEY", "YOUR_API_KEY")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("%+v\n", result)
}

require 'net/http'
require 'json'
require 'uri'

uri = URI('https://www.osintcat.net/api/dns-resolver')
uri.query = URI.encode_www_form({ query: 'example.com' })

request = Net::HTTP::Get.new(uri)
request['X-API-KEY'] = 'YOUR_API_KEY'

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

if response.is_a?(Net::HTTPSuccess)
    data = JSON.parse(response.body)
    puts JSON.pretty_generate(data)
else
    puts "Error: #{response.code}"
end

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class OsintCatAPI {
    public static void main(String[] args) {
        try {
            String apiUrl = "https://www.osintcat.net/api/dns-resolver?query=example.com";
            URL url = new URL(apiUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("X-API-KEY", "YOUR_API_KEY");
            
            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                System.out.println(response.toString());
            } else {
                System.out.println("Error: " + responseCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using (var client = new HttpClient())
        {
            try
            {
                string url = "https://www.osintcat.net/api/dns-resolver?query=example.com";
                client.DefaultRequestHeaders.Add("X-API-KEY", "YOUR_API_KEY");
                
                var response = await client.GetAsync(url);
                
                if (response.IsSuccessStatusCode)
                {
                    string content = await response.Content.ReadAsStringAsync();
                    Console.WriteLine(content);
                }
                else
                {
                    Console.WriteLine($"Error: {response.StatusCode}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }
    }
}