> ## Documentation Index
> Fetch the complete documentation index at: https://docs.osintcat.net/llms.txt
> Use this file to discover all available pages before exploring further.

# DNS Resolver

Resolve domain names and hostnames to IP addresses.

## Parameters

<ParamField query="query" type="string" required>
  A domain or hostname
</ParamField>

## Headers

<ParamField header="X-API-KEY" type="string" required>
  Your API key
</ParamField>

## Response

Returns DNS resolution results mapping hostnames to IP addresses.

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/dns-resolver?query=example.com" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  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}")
  ```

  ```javascript Node.js theme={null}
  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 PHP theme={null}
  <?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;
  }
  ```

  ```go Go theme={null}
  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)
  }
  ```

  ```ruby Ruby theme={null}
  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
  ```

  ```java Java theme={null}
  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();
          }
      }
  }
  ```

  ```csharp C# theme={null}
  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}");
              }
          }
      }
  }
  ```
</CodeGroup>