# Breach Lookup
Source: https://docs.osintcat.net/api-reference/endpoint/breach

GET https://www.osintcat.net/api/breach

Search for records in data breaches and compilations. This endpoint searches across multiple breach databases to find information associated with your query.

## Parameters

<ParamField type="string">
  The search term (e.g., email, username)
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns breach data found across multiple sources.

<ResponseField name="api" type="string">API identifier</ResponseField>
<ResponseField name="elapsed_ms" type="number">Request processing time in milliseconds</ResponseField>
<ResponseField name="timestamp" type="string">Formatted timestamp of the request</ResponseField>
<ResponseField name="results_count" type="number">Number of breach records found</ResponseField>
<ResponseField name="breach_data" type="array">Array of breach records</ResponseField>
<ResponseField name="_meta" type="object">Metadata about the request</ResponseField>

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/breach"
  params = {"query": "user@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/breach?query=user@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/breach?query=user@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/breach"
      params := url.Values{}
      params.Add("query", "user@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/breach')
  uri.query = URI.encode_www_form({ query: 'user@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/breach?query=user@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/breach?query=user@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>

## Example Response

```json theme={null}
{
  "api": "OsintCat",
  "elapsed_ms": 1234.56,
  "timestamp": "Jan 20th 14:30",
  "results_count": 5,
  "breach_data": [
    {
      "source": "leakcheck",
      "email": "user@example.com",
      "password": "hashed_password",
      "breach_date": "2020-01-15"
    }
  ],
  "_meta": {
    "requests_remaining": 38
  }
}
```


# Chilean Name
Source: https://docs.osintcat.net/api-reference/endpoint/chilean-name

GET https://www.osintcat.net/api/chilean-name

Find information about a Chilean person using their full name.

## Parameters

<ParamField type="string">
  Full name
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns information about the Chilean person matching the provided name.

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/chilean-name?query=Juan%20Perez" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/chilean-name"
  params = {"query": "Juan Perez"}
  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/chilean-name?query=Juan%20Perez';

  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/chilean-name?query=Juan%20Perez";

  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/chilean-name"
      params := url.Values{}
      params.Add("query", "Juan Perez")
      
      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/chilean-name')
  uri.query = URI.encode_www_form({ query: 'Juan Perez' })

  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/chilean-name?query=Juan%20Perez";
              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/chilean-name?query=Juan%20Perez";
                  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>


# Discord Lookup
Source: https://docs.osintcat.net/api-reference/endpoint/discord

GET https://www.osintcat.net/api/discord

Find Discord user information from various database leaks. This endpoint searches for Discord user data including usernames, user IDs, and associated information.

## Parameters

<ParamField type="string">
  Discord User ID, username, or email
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns Discord user information found in various databases.

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/discord"
  params = {"query": "123456789012345678"}
  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/discord?query=123456789012345678';

  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/discord?query=123456789012345678";

  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/discord"
      params := url.Values{}
      params.Add("query", "123456789012345678")
      
      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/discord')
  uri.query = URI.encode_www_form({ query: '123456789012345678' })

  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/discord?query=123456789012345678";
              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/discord?query=123456789012345678";
                  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>


# Discord to Roblox
Source: https://docs.osintcat.net/api-reference/endpoint/discord-to-roblox

GET https://www.osintcat.net/api/discord-to-roblox

Find a linked Roblox account from a Discord User ID.

## Parameters

<ParamField type="string">
  The Discord User ID
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns linked Roblox account information if found.

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/discord-to-roblox?query=123456789012345678" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/discord-to-roblox"
  params = {"query": "123456789012345678"}
  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/discord-to-roblox?query=123456789012345678';

  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/discord-to-roblox?query=123456789012345678";

  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/discord-to-roblox"
      params := url.Values{}
      params.Add("query", "123456789012345678")
      
      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/discord-to-roblox')
  uri.query = URI.encode_www_form({ query: '123456789012345678' })

  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/discord-to-roblox?query=123456789012345678";
              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/discord-to-roblox?query=123456789012345678";
                  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>


# DNS Resolver
Source: https://docs.osintcat.net/api-reference/endpoint/dns-resolver

GET https://www.osintcat.net/api/dns-resolver

Resolve domain names and hostnames to IP addresses.

## Parameters

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

## Headers

<ParamField type="string">
  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>


# Domain Lookup
Source: https://docs.osintcat.net/api-reference/endpoint/domain

GET https://www.osintcat.net/api/domain

Domain stealer lookup. Search for domain-related information in stealer logs and databases.

## Parameters

<ParamField type="string">
  Domain name (example -> example.com)
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns domain-related information found in stealer logs and databases.

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/domain"
  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/domain?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/domain?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/domain"
      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/domain')
  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/domain?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/domain?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>


# Email Footprint
Source: https://docs.osintcat.net/api-reference/endpoint/email-footprint

GET https://www.osintcat.net/api/footprint/create-task
Discover platform registrations for an email address across 100+ services

The Email Footprint API checks whether a specific email address is registered across social media, shopping, and professional platforms.
It returns a summary of stats and a per-platform breakdown including secondary metadata like usernames or account status where available.

The lookup backend is load-balanced, so footprint scans run as **asynchronous tasks**:

1. **Create a task** with `GET /api/footprint/create-task` (this is where one lookup is charged). You receive a `task_id`.
2. **Poll the task** with `GET /api/footprint/get-task?id=<task_id>` until `status` is no longer a running state. Polling is free.

<Note>
  Email and username footprints share the same task endpoints — only the `type` parameter differs (`email` vs `username`).
</Note>

***

## Step 1 — Create Task

```bash theme={null}
GET https://www.osintcat.net/api/footprint/create-task
```

<ParamField type="string">
  The email address to scan (e.g., `user@gmail.com`)
</ParamField>

<ParamField type="string">
  The footprint type. Use `email` for this endpoint.
</ParamField>

<ParamField type="string">
  Your API key
</ParamField>

<Warning>
  Creating a task consumes exactly **one lookup** from your daily quota. Polling `get-task` does not.
</Warning>

**Response Body**

<ResponseField name="task_id" type="string">
  The identifier used to poll for results.
</ResponseField>

<ResponseField name="status" type="string">
  The initial task status (e.g., `running`, `queued`, `pending`).
</ResponseField>

<ResponseField name="_meta" type="object">
  <Expandable title="properties">
    <ResponseField name="plan" type="string">Your current plan.</ResponseField>
    <ResponseField name="lookups_left" type="string">Remaining lookups for the day (`unlimited` on the Max plan).</ResponseField>
  </Expandable>
</ResponseField>

```json theme={null}
{
  "task_id": "f3c8a1e2-9b44-4d51-bd0a-1c2e3f4a5b6c",
  "status": "running",
  "_meta": {
    "plan": "researcher",
    "lookups_left": 4821
  }
}
```

***

## Step 2 — Poll Task

```bash theme={null}
GET https://www.osintcat.net/api/footprint/get-task
```

<ParamField type="string">
  The `task_id` returned by `create-task`.
</ParamField>

<ParamField type="string">
  Your API key
</ParamField>

Poll roughly once per second until `status` is no longer one of the running states
(`running`, `queued`, `pending`, `processing`, `started`). A scan typically completes
within a few seconds and is capped at \~3 minutes.

**Response Body**

<ResponseField name="status" type="string">
  Current task status. While running it is one of `running`, `queued`, `pending`,
  `processing`, `started`. Any other value (e.g., `done`, `finished`) means the scan is complete.
</ResponseField>

<ResponseField name="stats" type="object">
  Live progress / summary counters (populated as the scan runs).

  <Expandable title="properties">
    <ResponseField name="checked" type="number">Number of platforms checked so far.</ResponseField>
    <ResponseField name="total_modules" type="number">Total number of platforms in the scan.</ResponseField>
    <ResponseField name="found" type="number">Number of platforms where the email was found.</ResponseField>
    <ResponseField name="elapsed" type="string">Elapsed scan time.</ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="results" type="array">
  List of platform results (grows as the scan progresses).

  <Expandable title="item properties">
    <ResponseField name="domain" type="string">Platform domain (e.g., `github.com`)</ResponseField>
    <ResponseField name="taken" type="boolean">True if the email is registered on this platform</ResponseField>

    <ResponseField name="ExtraData" type="object">
      Metadata retrieved from the platform (usernames, IDs, status, etc.)
    </ResponseField>
  </Expandable>
</ResponseField>

***

## Example

<CodeGroup>
  ```bash cURL theme={null}
  # 1. Create the task
  curl "https://www.osintcat.net/api/footprint/create-task?query=john@gmail.com&type=email" \
       -H "X-API-KEY: YOUR_API_KEY"

  # 2. Poll until done (replace TASK_ID with the returned task_id)
  curl "https://www.osintcat.net/api/footprint/get-task?id=TASK_ID" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import time
  import requests

  BASE = "https://www.osintcat.net"
  HEADERS = {"X-API-KEY": "YOUR_API_KEY"}
  RUNNING = {"running", "queued", "pending", "processing", "started"}

  # 1. Create the task (charges one lookup)
  task = requests.get(
      f"{BASE}/api/footprint/create-task",
      params={"query": "john@gmail.com", "type": "email"},
      headers=HEADERS,
  ).json()
  task_id = task["task_id"]

  # 2. Poll until the scan finishes
  while True:
      data = requests.get(
          f"{BASE}/api/footprint/get-task",
          params={"id": task_id},
          headers=HEADERS,
      ).json()
      if str(data.get("status", "")).lower() not in RUNNING:
          break
      time.sleep(1)

  print(data)
  ```

  ```javascript Node.js theme={null}
  const BASE = 'https://www.osintcat.net';
  const HEADERS = { 'X-API-KEY': 'YOUR_API_KEY' };
  const RUNNING = ['running', 'queued', 'pending', 'processing', 'started'];
  const sleep = ms => new Promise(r => setTimeout(r, ms));

  (async () => {
    // 1. Create the task (charges one lookup)
    const task = await fetch(
      `${BASE}/api/footprint/create-task?query=john@gmail.com&type=email`,
      { headers: HEADERS }
    ).then(r => r.json());

    // 2. Poll until the scan finishes
    let data;
    do {
      data = await fetch(
        `${BASE}/api/footprint/get-task?id=${encodeURIComponent(task.task_id)}`,
        { headers: HEADERS }
      ).then(r => r.json());
      if (!RUNNING.includes(String(data.status).toLowerCase())) break;
      await sleep(1000);
    } while (true);

    console.log(data);
  })();
  ```

  ```php PHP theme={null}
  <?php

  $base = "https://www.osintcat.net";
  $headers = ["X-API-KEY: YOUR_API_KEY"];
  $running = ["running", "queued", "pending", "processing", "started"];

  function get_json($url, $headers) {
      $curl = curl_init();
      curl_setopt_array($curl, [
          CURLOPT_URL => $url,
          CURLOPT_RETURNTRANSFER => true,
          CURLOPT_HTTPHEADER => $headers,
      ]);
      $response = curl_exec($curl);
      curl_close($curl);
      return json_decode($response, true);
  }

  // 1. Create the task (charges one lookup)
  $task = get_json("$base/api/footprint/create-task?query=john@gmail.com&type=email", $headers);
  $taskId = $task["task_id"];

  // 2. Poll until the scan finishes
  do {
      $data = get_json("$base/api/footprint/get-task?id=" . urlencode($taskId), $headers);
      if (!in_array(strtolower($data["status"]), $running)) break;
      sleep(1);
  } while (true);

  print_r($data);
  ```

  ```go Go theme={null}
  package main

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

  func getJSON(u string) map[string]interface{} {
      req, _ := http.NewRequest("GET", u, nil)
      req.Header.Set("X-API-KEY", "YOUR_API_KEY")
      resp, _ := http.DefaultClient.Do(req)
      defer resp.Body.Close()
      body, _ := io.ReadAll(resp.Body)
      var out map[string]interface{}
      json.Unmarshal(body, &out)
      return out
  }

  func main() {
      base := "https://www.osintcat.net"
      running := map[string]bool{"running": true, "queued": true, "pending": true, "processing": true, "started": true}

      // 1. Create the task (charges one lookup)
      params := url.Values{}
      params.Add("query", "john@gmail.com")
      params.Add("type", "email")
      task := getJSON(base + "/api/footprint/create-task?" + params.Encode())
      taskID, _ := task["task_id"].(string)

      // 2. Poll until the scan finishes
      var data map[string]interface{}
      for {
          data = getJSON(base + "/api/footprint/get-task?id=" + url.QueryEscape(taskID))
          status, _ := data["status"].(string)
          if !running[strings.ToLower(status)] {
              break
          }
          time.Sleep(time.Second)
      }
      fmt.Printf("%+v\n", data)
  }
  ```
</CodeGroup>

**Example Result (completed task)**

```json theme={null}
{
  "status": "done",
  "stats": {
    "checked": 119,
    "total_modules": 119,
    "found": 95,
    "elapsed": "6.4s"
  },
  "results": [
    {
      "domain": "github.com",
      "taken": true,
      "ExtraData": {
        "Username": "johnny123",
        "PublicRepos": 42
      }
    }
  ]
}
```


# Email OSINT
Source: https://docs.osintcat.net/api-reference/endpoint/email-osint

GET https://www.osintcat.net/api/email-osint

Discover which websites an email address is registered on.

<Warning>
  **Purpose Identification Required**: This endpoint requires you to specify the purpose/reason for your OSINT search. You can provide this in 4 different ways (in order of priority):

  1. **Query Parameter**: `?purpose=Your%20Purpose`
  2. **X-Purpose Header**: `X-Purpose: Your Purpose`
  3. **Purpose Header**: `Purpose: Your Purpose`
  4. **User-Agent Header**: Include `Purpose: Your Purpose` within the User-Agent string
</Warning>

<Warning>
  **Credits Required**: This endpoint requires email OSINT credits to perform searches. Credits are deducted only after a successful search. Check your credit balance using the `/api/user` endpoint, which includes email OSINT credit information in its response.
</Warning>

## Parameters

<ParamField type="string">
  Email address to investigate
</ParamField>

<ParamField type="string">
  Purpose/reason for the OSINT search (can also be provided via headers)
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

<ParamField type="string">
  Alternative way to provide the purpose (takes priority over query parameter)
</ParamField>

<ParamField type="string">
  Alternative way to provide the purpose
</ParamField>

<ParamField type="string">
  Can include `Purpose: Your Purpose` within the User-Agent string
</ParamField>

## Credit System

Email OSINT searches require credits to be performed. The cost per search varies by your subscription plan:

| Plan         | Price per Search | Monthly Free Credits |
| ------------ | ---------------- | -------------------- |
| Free         | €0.50            | 5 searches (€2.50)   |
| Starter      | €0.40            | 10 searches (€4.00)  |
| Researcher   | €0.30            | 20 searches (€6.00)  |
| Investigator | €0.20            | 30 searches (€6.00)  |
| Enterprise   | €0.15            | 50 searches (€7.50)  |

<Note>
  **Monthly Credits**: Free credits are automatically awarded on the first of each month based on your plan. Free credits are not stackable - unused credits from previous months do not accumulate.
</Note>

<Note>
  **Credit Deduction**: Credits are deducted only after a successful API response. Failed requests (due to invalid parameters, rate limits, etc.) do not consume credits.
</Note>

## Check Credit Balance

Before making a search request, you can check your current credit balance using the `/api/user` endpoint, which includes email OSINT credit information:

**Endpoint**: `GET /api/user`

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/user"
  headers = {
      "X-API-KEY": "YOUR_API_KEY"
  }

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

  if response.ok:
      data = response.json()
      credits = data.get('email_osint_credits', {})
      print(f"Current credits: €{credits.get('current_balance', 0)}")
      print(f"Price per search: €{credits.get('price_per_search', 0)}")
      print(f"Searches available: {credits.get('searches_available', 0)}")
  else:
      print(f"Error: {response.status_code}")
  ```
</CodeGroup>

The `email_osint_credits` object in the response contains:

* `current_balance`: Current credit balance in EUR
* `price_per_search`: Cost per search based on your plan
* `has_sufficient_credits`: Whether you have enough credits for at least one search
* `searches_available`: Estimated number of searches available with current balance

See the [User Info](/api-reference/endpoint/user) endpoint documentation for the complete response structure.

## Response

Returns information about websites where the email address is registered. Credits are deducted after a successful response.

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  # Using header for API Key and X-Purpose for reason
  curl "https://www.osintcat.net/api/email-osint?query=test@example.com" \
       -H "X-API-KEY: YOUR_API_KEY" \
       -H "X-Purpose: Security Research"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/email-osint"
  params = {
      "query": "test@example.com",
      "purpose": "Security Research"
  }
  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/email-osint?query=test@example.com&purpose=Security%20Research';

  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/email-osint?query=test@example.com&purpose=Security%20Research";

  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/email-osint"
      params := url.Values{}
      params.Add("query", "test@example.com")
      params.Add("purpose", "Security Research")
      
      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/email-osint')
  uri.query = URI.encode_www_form({ 
      query: 'test@example.com', 
      purpose: 'Security Research' 
  })

  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/email-osint?query=test@example.com&purpose=Security%20Research";
              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/email-osint?query=test@example.com&purpose=Security%20Research";
                  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>

## Error Responses

### Insufficient Credits (402 Payment Required)

If you don't have enough credits to perform a search, you'll receive a 402 status code:

```json theme={null}
{
  "error": "INSUFFICIENT_CREDITS",
  "message": "Insufficient credits. You need 0.50€ but have 0.00€. Please purchase credits.",
  "credits_needed": 0.50,
  "credits_available": 0.00
}
```

### Rate Limit Exceeded (429 Too Many Requests)

If you exceed the rate limit of 3 requests per second, you'll receive a 429 status code. This does not consume credits.

### Other Status Codes

* `200 OK` - Success (credits are deducted)
* `400 Bad Request` - Missing or invalid parameters (no credits deducted)
* `403 Forbidden` - Invalid or missing API key (no credits deducted)
* `429 Too Many Requests` - Rate limit exceeded (no credits deducted)
* `500 Internal Server Error` - Server error (no credits deducted)


# GTA Online Players
Source: https://docs.osintcat.net/api-reference/endpoint/gta-players

GET https://www.osintcat.net/api/gta/players

Search tracked GTA Online players by display name or Rockstar ID. Returns platform, last seen timestamp, and full raw data for each match.

## Parameters

<ParamField type="string">
  The search value: a player name (partial match) or Rockstar ID (exact match)
</ParamField>

<ParamField type="string">
  Search mode. `name` for display name lookup, `rid` for Rockstar ID lookup
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

<ResponseField name="results" type="array">
  List of matched player objects

  <Expandable title="Player object">
    <ResponseField name="rid" type="integer">Rockstar ID</ResponseField>
    <ResponseField name="name" type="string">Display name</ResponseField>
    <ResponseField name="platform" type="string">Platform (`pc`, `ps`, `xbox`)</ResponseField>
    <ResponseField name="last_seen" type="integer">Unix timestamp of last recorded presence</ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="results_count" type="integer">Number of results returned</ResponseField>
<ResponseField name="elapsed_ms" type="number">Server-side processing time in milliseconds</ResponseField>

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/gta/players?query=salzling&type=name" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/gta/players"
  params = {
      "query": "salzling",
      "type": "name"
  }
  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/gta/players?query=salzling&type=name';

  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/gta/players?query=salzling&type=name";

  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/gta/players"
      params := url.Values{}
      params.Add("query", "salzling")
      params.Add("type", "name")

      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/gta/players')
  uri.query = URI.encode_www_form({ query: 'salzling', type: 'name' })

  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)
      puts JSON.pretty_generate(JSON.parse(response.body))
  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/gta/players?query=salzling&type=name";
              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())
          {
              client.DefaultRequestHeaders.Add("X-API-KEY", "YOUR_API_KEY");
              var response = await client.GetAsync(
                  "https://www.osintcat.net/api/gta/players?query=salzling&type=name");

              if (response.IsSuccessStatusCode)
                  Console.WriteLine(await response.Content.ReadAsStringAsync());
              else
                  Console.WriteLine($"Error: {response.StatusCode}");
          }
      }
  }
  ```
</CodeGroup>


# GTA Online Spotted
Source: https://docs.osintcat.net/api-reference/endpoint/gta-spotted

GET https://www.osintcat.net/api/gta/spotted

Search the GTA Online sighting history database. Returns every recorded sighting of a player including times seen, first and last spotted timestamps, and platform.

## Parameters

<ParamField type="string">
  The search value: a player name (partial match) or Rockstar ID (exact match)
</ParamField>

<ParamField type="string">
  Search mode. `name` for display name lookup, `rid` for Rockstar ID lookup
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

<ResponseField name="results" type="array">
  List of matched sighting records

  <Expandable title="Spotted object">
    <ResponseField name="rid" type="integer">Rockstar ID</ResponseField>
    <ResponseField name="name" type="string">Display name at time of sighting</ResponseField>
    <ResponseField name="platform" type="string">Platform (`pc`, `ps`, `xbox`)</ResponseField>
    <ResponseField name="times_seen" type="integer">Total number of times this entry was recorded</ResponseField>
    <ResponseField name="first_seen" type="integer">Unix timestamp of first sighting</ResponseField>
    <ResponseField name="last_seen" type="integer">Unix timestamp of most recent sighting</ResponseField>
    <ResponseField name="last_seen_ts" type="string">ISO timestamp of most recent sighting</ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="results_count" type="integer">Number of results returned</ResponseField>
<ResponseField name="elapsed_ms" type="number">Server-side processing time in milliseconds</ResponseField>

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/gta/spotted?query=salzling&type=name" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/gta/spotted"
  params = {
      "query": "salzling",
      "type": "name"
  }
  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/gta/spotted?query=salzling&type=name';

  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/gta/spotted?query=salzling&type=name";

  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/gta/spotted"
      params := url.Values{}
      params.Add("query", "salzling")
      params.Add("type", "name")

      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/gta/spotted')
  uri.query = URI.encode_www_form({ query: 'salzling', type: 'name' })

  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)
      puts JSON.pretty_generate(JSON.parse(response.body))
  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/gta/spotted?query=salzling&type=name";
              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())
          {
              client.DefaultRequestHeaders.Add("X-API-KEY", "YOUR_API_KEY");
              var response = await client.GetAsync(
                  "https://www.osintcat.net/api/gta/spotted?query=salzling&type=name");

              if (response.IsSuccessStatusCode)
                  Console.WriteLine(await response.Content.ReadAsStringAsync());
              else
                  Console.WriteLine($"Error: {response.StatusCode}");
          }
      }
  }
  ```
</CodeGroup>


# Instagram Resolver
Source: https://docs.osintcat.net/api-reference/endpoint/instagram-resolver

GET https://www.osintcat.net/api/instagram-resolver

Resolve an Instagram share link to expose both the **author** of the post and the **sharer** (the user who generated the share link). Pulls the `xig_logged_out_dynamic_dialog_info` payload that Instagram embeds for logged-out viewers.

## Parameters

<ParamField type="string">
  An Instagram share URL, e.g. `https://www.instagram.com/share/p/ABCDEFGHIJ`
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

```json theme={null}
{
  "success": true,
  "author":  { "username": "...", "avatar": "..." },
  "sharer":  { "username": "...", "full_name": "...", "id": "...", "avatar": "..." },
  "entity_id": "...",
  "_meta": { ... }
}
```

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/instagram-resolver?link=https%3A%2F%2Fwww.instagram.com%2Fshare%2Fp%2FABCDEFGHIJ" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/instagram-resolver"
  params = {"link": "https://www.instagram.com/share/p/ABCDEFGHIJ"}
  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/instagram-resolver?link=' + encodeURIComponent('https://www.instagram.com/share/p/ABCDEFGHIJ');

  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();

  $link = urlencode("https://www.instagram.com/share/p/ABCDEFGHIJ");
  $url = "https://www.osintcat.net/api/instagram-resolver?link=$link";

  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/instagram-resolver"
      params := url.Values{}
      params.Add("link", "https://www.instagram.com/share/p/ABCDEFGHIJ")

      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/instagram-resolver')
  uri.query = URI.encode_www_form({ link: 'https://www.instagram.com/share/p/ABCDEFGHIJ' })

  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.net.URLEncoder;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;

  public class OsintCatAPI {
      public static void main(String[] args) {
          try {
              String link = URLEncoder.encode("https://www.instagram.com/share/p/ABCDEFGHIJ", "UTF-8");
              String apiUrl = "https://www.osintcat.net/api/instagram-resolver?link=" + link;
              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;
  using System.Web;

  class Program
  {
      static async Task Main(string[] args)
      {
          using (var client = new HttpClient())
          {
              try
              {
                  string link = HttpUtility.UrlEncode("https://www.instagram.com/share/p/ABCDEFGHIJ");
                  string url = $"https://www.osintcat.net/api/instagram-resolver?link={link}";
                  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>


# IP Info
Source: https://docs.osintcat.net/api-reference/endpoint/ip

GET https://www.osintcat.net/api/ip

Get IP information and IP stealer logs lookup.

## Parameters

<ParamField type="string">
  An IP address
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns IP address information including geolocation, ISP, and stealer log data.

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/ip"
  params = {"query": "8.8.8.8"}
  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/ip?query=8.8.8.8';

  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/ip?query=8.8.8.8";

  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/ip"
      params := url.Values{}
      params.Add("query", "8.8.8.8")
      
      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/ip')
  uri.query = URI.encode_www_form({ query: '8.8.8.8' })

  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/ip?query=8.8.8.8";
              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/ip?query=8.8.8.8";
                  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>


# Machine Viewer
Source: https://docs.osintcat.net/api-reference/endpoint/machine-viewer

GET https://www.osintcat.net/api/machine_viewer/stats
Search and explore infected machine data, file trees, and extracted information via API key

The Machine Viewer module provides access to infected machine records stored in the OsintCat breach database.
Search machines by name, retrieve device details, browse file trees, and download archived logs — all via API key.

<Note>
  All Machine Viewer API endpoints use `X-API-KEY` header authentication.
  Searching machines costs **1 credit** per search.
</Note>

***

## Global Statistics

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/stats
```

Returns total infected machine and file counts.

<ParamField type="string">
  Your API key
</ParamField>

**Response**

```json theme={null}
{
  "total_machines": 412000,
  "total_files": 18500000
}
```

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/machine_viewer/stats" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/machine_viewer/stats"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, headers=headers)
  print(response.json())
  ```

  ```javascript Node.js theme={null}
  fetch('https://www.osintcat.net/api/machine_viewer/stats', {
      headers: { 'X-API-KEY': 'YOUR_API_KEY' }
  }).then(r => r.json()).then(console.log);
  ```
</CodeGroup>

***

## Search Machines

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/search
```

Search for infected machines by hostname or username. Costs **1 credit** per search.

<ParamField type="string">
  The search term (hostname, username, UUID, etc.)
</ParamField>

<ParamField type="string">
  Your API key
</ParamField>

**Response**

```json theme={null}
{
  "query": "ZAEZBCAOHJNF",
  "total": 1,
  "machines": [
    {
      "id": "742e1f66-f449-4a6c-80d5-8f5eb8e9c2b5",
      "name": "ZAEZBCAOHJNF",
      "file_count": 15,
      "total_size": 772597,
      "imported_at": "2026-03-03T00:00:00"
    }
  ]
}
```

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/machine_viewer/search"
  params = {"query": "ZAEZBCAOHJNF"}
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, params=params, headers=headers)
  print(response.json())
  ```

  ```javascript Node.js theme={null}
  fetch('https://www.osintcat.net/api/machine_viewer/search?query=ZAEZBCAOHJNF', {
      headers: { 'X-API-KEY': 'YOUR_API_KEY' }
  }).then(r => r.json()).then(console.log);
  ```
</CodeGroup>

***

## Get Machine Info

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/machines/{machine_id}/info
```

Returns full device identity, extracted email addresses, and Discord tokens.

<ParamField type="string">
  The UUID of the machine (from Search response)
</ParamField>

<ParamField type="string">
  Your API key
</ParamField>

**Response**

```json theme={null}
{
  "machine": {
    "id": "742e1f66-f449-4a6c-80d5-8f5eb8e9c2b5",
    "name": "ZAEZBCAOHJNF",
    "file_count": 15,
    "total_size": 772597,
    "imported_at": "2026-03-03T00:00:00"
  },
  "emails": ["user@example.com", "admin@test.org"],
  "tokens": ["MTA5NDI3MzI2NTQ2NDAyNTYy.XXXXX.YYYYY"]
}
```

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/machine_viewer/machines/742e1f66-.../info" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  machine_id = "742e1f66-f449-4a6c-80d5-8f5eb8e9c2b5"
  url = f"https://www.osintcat.net/api/machine_viewer/machines/{machine_id}/info"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, headers=headers)
  print(response.json())
  ```
</CodeGroup>

***

## Get File Tree

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/machines/{machine_id}/files/treeview
```

Returns a nested directory/file tree for a machine.

<ParamField type="string">
  The UUID of the machine
</ParamField>

**Response**

```json theme={null}
{
  "machine": "ZAEZBCAOHJNF",
  "total_files": 15,
  "tree": [
    {
      "name": "passwords",
      "type": "directory",
      "children": [
        { "name": "chrome.txt", "type": "file", "id": "abc123", "size": 1024 }
      ]
    }
  ]
}
```

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/machine_viewer/machines/742e1f66-.../files/treeview" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  machine_id = "742e1f66-f449-4a6c-80d5-8f5eb8e9c2b5"
  url = f"https://www.osintcat.net/api/machine_viewer/machines/{machine_id}/files/treeview"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, headers=headers)
  print(response.json())
  ```
</CodeGroup>

***

## Get File Info & Content

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/files/{file_id}/info
```

Returns metadata and text content of a single file. The `file_id` comes from the file tree response.

<ParamField type="string">
  The UUID of the file (from File Tree response)
</ParamField>

**Response**

```json theme={null}
{
  "id": "abc123",
  "filename": "chrome.txt",
  "path": "passwords/chrome.txt",
  "size": 1024,
  "content": "URL: https://example.com\nUsername: user@gmail.com\nPassword: ..."
}
```

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/machine_viewer/files/abc123/info" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  file_id = "abc123"
  url = f"https://www.osintcat.net/api/machine_viewer/files/{file_id}/info"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, headers=headers)
  print(response.json())
  ```
</CodeGroup>

***

## Download Single File

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/files/{file_id}/download
```

Downloads the raw content of a single file as `application/octet-stream`.

<ParamField type="string">
  The UUID of the file
</ParamField>

<CodeGroup>
  ```bash cURL theme={null}
  curl -O -J "https://www.osintcat.net/api/machine_viewer/files/abc123/download" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  file_id = "abc123"
  url = f"https://www.osintcat.net/api/machine_viewer/files/{file_id}/download"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, headers=headers)
  with open("file.txt", "wb") as f:
      f.write(response.content)
  ```
</CodeGroup>

***

## Download Machine Archive

```bash theme={null}
GET https://www.osintcat.net/api/machine_viewer/machines/{machine_id}/download
```

Downloads all files for a machine as a `.zip` archive.

<ParamField type="string">
  The UUID of the machine
</ParamField>

Returns `application/zip` named `{machine_name}_export.zip`.

<CodeGroup>
  ```bash cURL theme={null}
  curl -O -J "https://www.osintcat.net/api/machine_viewer/machines/742e1f66-.../download" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  machine_id = "742e1f66-f449-4a6c-80d5-8f5eb8e9c2b5"
  url = f"https://www.osintcat.net/api/machine_viewer/machines/{machine_id}/download"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, headers=headers)
  with open("machine_export.zip", "wb") as f:
      f.write(response.content)
  print(f"Downloaded {len(response.content)} bytes")
  ```

  ```javascript Node.js theme={null}
  const fs = require('fs');
  const https = require('https');

  const machine_id = '742e1f66-f449-4a6c-80d5-8f5eb8e9c2b5';
  const url = `https://www.osintcat.net/api/machine_viewer/machines/${machine_id}/download`;

  const file = fs.createWriteStream('machine_export.zip');
  https.get(url, { headers: { 'X-API-KEY': 'YOUR_API_KEY' } }, res => {
      res.pipe(file);
      file.on('finish', () => file.close(() => console.log('Downloaded!')));
  });
  ```
</CodeGroup>


# Minecraft
Source: https://docs.osintcat.net/api-reference/endpoint/minecraft

GET https://www.osintcat.net/api/minecraft

Minecraft breach data lookup. Search for Minecraft account information including usernames, IPs, passwords, emails, and UUIDs from breach databases.

## Parameters

<ParamField type="string">
  The search query value
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns Minecraft breach data based on the search type specified. The response structure varies depending on the type parameter used.

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/minecraft"
  params = {"query": "Notch"}
  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/minecraft?query=Notch';

  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/minecraft?query=Notch";

  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/minecraft"
      params := url.Values{}
      params.Add("query", "Notch")
      
      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/minecraft')
  uri.query = URI.encode_www_form({ query: 'Notch' })

  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/minecraft?query=Notch";
              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/minecraft?query=Notch";
                  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>


# Minecraft OSINT
Source: https://docs.osintcat.net/api-reference/endpoint/minecraft-osint

GET https://www.osintcat.net/api/minecraft-lookup

Minecraft OSINT lookup. Search for Minecraft account information including usernames, IPs, passwords, emails, and UUIDs from breach databases. Results are cached for improved performance.

## Parameters

<ParamField type="string">
  The search query value
</ParamField>

<ParamField type="string">
  The type of search to perform. Available search types: `username`, `ip`, `password`, `email`, `uuid`
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns Minecraft breach data based on the search type specified. The response structure varies depending on the type parameter used. Results are cached for 30 minutes.

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/minecraft-lookup?query=Notch&type=username" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/minecraft-lookup"
  params = {
      "query": "Notch",
      "type": "username"
  }
  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/minecraft-lookup?query=Notch&type=username';

  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/minecraft-lookup?query=Notch&type=username";

  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/minecraft-lookup"
      params := url.Values{}
      params.Add("query", "Notch")
      params.Add("type", "username")
      
      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/minecraft-lookup')
  uri.query = URI.encode_www_form({ query: 'Notch', type: 'username' })

  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/minecraft-lookup?query=Notch&type=username";
              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/minecraft-lookup?query=Notch&type=username";
                  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>


# Phone OSINT
Source: https://docs.osintcat.net/api-reference/endpoint/phone-osint

GET https://www.osintcat.net/api/phone-osint

Gather intelligence on a phone number, including carrier and associated online profiles.

## Parameters

<ParamField type="string">
  Phone number in international format (e.g., 14155552671)
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns phone number information including carrier details, location data, and associated online profiles.

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/phone-osint"
  params = {"query": "14155552671"}
  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/phone-osint?query=14155552671';

  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/phone-osint?query=14155552671";

  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/phone-osint"
      params := url.Values{}
      params.Add("query", "14155552671")
      
      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/phone-osint')
  uri.query = URI.encode_www_form({ query: '14155552671' })

  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/phone-osint?query=14155552671";
              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/phone-osint?query=14155552671";
                  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>


# Roblox to Discord
Source: https://docs.osintcat.net/api-reference/endpoint/roblox

GET https://www.osintcat.net/api/roblox

Find Discord accounts linked to a Roblox username. Searches our database of scraped Roblox-to-Discord mappings and returns matching profiles with Discord ID, username, and avatar where available.

## Parameters

<ParamField type="string">
  Roblox username. Wildcard `*` is supported:

  * `demon*` — usernames starting with `demon`
  * `*boy` — usernames ending with `boy`
  * `*123*` — usernames containing `123`

  Plain queries (no `*`) match the username exactly (case-insensitive). Up to 50 results are returned.
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns a list of matches from the database. Each result contains the Roblox username and, if a linked Discord account is on file, the Discord ID plus username and avatar URL fetched live from Discord.

```json theme={null}
{
  "query": "demon*",
  "count": 2,
  "results": [
    {
      "roblox_name": "demonboy",
      "discord_id": "123456789012345678",
      "discord_username": "demon",
      "discord_avatar": "https://cdn.discordapp.com/avatars/123456789012345678/abc123.png?size=128"
    },
    {
      "roblox_name": "demon123",
      "discord_id": null
    }
  ]
}
```

If no matches are found, the API returns:

```json theme={null}
{ "error": "No matches found in database." }
```

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/roblox"
  params = {"query": "demon*"}
  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/roblox?query=demon*';

  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/roblox?query=" . urlencode("demon*");

  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/roblox"
      params := url.Values{}
      params.Add("query", "demon*")

      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/roblox')
  uri.query = URI.encode_www_form({ query: 'demon*' })

  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.net.URLEncoder;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;
  import java.nio.charset.StandardCharsets;

  public class OsintCatAPI {
      public static void main(String[] args) {
          try {
              String query = URLEncoder.encode("demon*", StandardCharsets.UTF_8);
              String apiUrl = "https://www.osintcat.net/api/roblox?query=" + query;
              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;
  using System.Web;

  class Program
  {
      static async Task Main(string[] args)
      {
          using (var client = new HttpClient())
          {
              try
              {
                  string query = HttpUtility.UrlEncode("demon*");
                  string url = $"https://www.osintcat.net/api/roblox?query={query}";
                  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>


# Stealer Logs (Legacy)
Source: https://docs.osintcat.net/api-reference/endpoint/stealer-logs

GET https://www.osintcat.net/api/database-search

Search stealer log collections and breach compilations by email or domain.

<Warning>
  This is a legacy endpoint. Use the [Breach Lookup](/api-reference/endpoint/breach) endpoint for newer indexed data.
</Warning>

## Parameters

<ParamField type="string">
  The search term (email address or domain name)
</ParamField>

<ParamField type="string">
  The search type. Accepted values: email, domain.
  If not provided, the type is auto-detected based on the query format (presence of @ = email, otherwise domain).
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns matching records found across the stealer log database collection.

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/database-search"
  params = {"query": "example@email.com", "type": "email"}
  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}
  fetch('https://www.osintcat.net/api/database-search?query=example@email.com&type=email', {
      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_init();
   = "https://www.osintcat.net/api/database-search?query=example@email.com&type=email";

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

   = curl_exec();
   = curl_error();
  curl_close();

  if () {
      echo "cURL Error #:" . ;
  } else {
      echo ;
  }
  ```

  ```go Go theme={null}
  package main

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

  func main() {
      baseURL := "https://www.osintcat.net/api/database-search"
      params := url.Values{}
      params.Add("query", "example@email.com")
      params.Add("type", "email")

      req, _ := http.NewRequest("GET", baseURL+"?"+params.Encode(), 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)
  }
  ```
</CodeGroup>


# TikTok Resolver
Source: https://docs.osintcat.net/api-reference/endpoint/tiktok-resolver

GET https://www.osintcat.net/api/tiktok-resolver

Resolve a TikTok short link (vm.tiktok.com / vt.tiktok.com) to the user who shared it — including username, nickname, region, follower count, total likes, bio and the share timestamp.

## Parameters

<ParamField type="string">
  A TikTok short link, e.g. `https://vm.tiktok.com/ZGdHhUjhW/`
</ParamField>

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns the sharer profile pulled from the redirect target, with `success`, `sharer.{username, nickname, region, follower_count, heart_count, user_id, timestamp, bio, avatar}` and `_meta` usage info.

## Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/tiktok-resolver?link=https%3A%2F%2Fvm.tiktok.com%2FZGdHhUjhW%2F" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/tiktok-resolver"
  params = {"link": "https://vm.tiktok.com/ZGdHhUjhW/"}
  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/tiktok-resolver?link=' + encodeURIComponent('https://vm.tiktok.com/ZGdHhUjhW/');

  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();

  $link = urlencode("https://vm.tiktok.com/ZGdHhUjhW/");
  $url = "https://www.osintcat.net/api/tiktok-resolver?link=$link";

  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/tiktok-resolver"
      params := url.Values{}
      params.Add("link", "https://vm.tiktok.com/ZGdHhUjhW/")

      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/tiktok-resolver')
  uri.query = URI.encode_www_form({ link: 'https://vm.tiktok.com/ZGdHhUjhW/' })

  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.net.URLEncoder;
  import java.io.BufferedReader;
  import java.io.InputStreamReader;

  public class OsintCatAPI {
      public static void main(String[] args) {
          try {
              String link = URLEncoder.encode("https://vm.tiktok.com/ZGdHhUjhW/", "UTF-8");
              String apiUrl = "https://www.osintcat.net/api/tiktok-resolver?link=" + link;
              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;
  using System.Web;

  class Program
  {
      static async Task Main(string[] args)
      {
          using (var client = new HttpClient())
          {
              try
              {
                  string link = HttpUtility.UrlEncode("https://vm.tiktok.com/ZGdHhUjhW/");
                  string url = $"https://www.osintcat.net/api/tiktok-resolver?link={link}";
                  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>


# User Info
Source: https://docs.osintcat.net/api-reference/endpoint/user

GET https://www.osintcat.net/api/user

Retrieve information and usage statistics about your own account, including email OSINT credit information.

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Response

Returns account information including username, email, plan, usage statistics, and email OSINT credit information.

<ResponseField name="account_info" type="object">
  Account information object
  <ResponseField name="username" type="string">Your username</ResponseField>
  <ResponseField name="email" type="string">Your email address</ResponseField>
  <ResponseField name="plan" type="string">Your current plan (Free, Starter, Researcher, Investigator, or Enterprise)</ResponseField>
</ResponseField>

<ResponseField name="usage" type="object">
  Usage statistics object
  <ResponseField name="request_limit_daily" type="number">Daily request limit</ResponseField>
  <ResponseField name="requests_remaining_today" type="number">Remaining requests today</ResponseField>
  <ResponseField name="api_access" type="boolean">Whether API access is enabled</ResponseField>
  <ResponseField name="intelx_access" type="boolean">Whether IntelX access is enabled</ResponseField>
  <ResponseField name="max_ips" type="number">Maximum number of IP addresses allowed</ResponseField>
</ResponseField>

<ResponseField name="email_osint_credits" type="object">
  Email OSINT credit information
  <ResponseField name="current_balance" type="number">Current credit balance in EUR (2 decimal places)</ResponseField>
  <ResponseField name="price_per_search" type="number">Cost per search based on your plan in EUR (2 decimal places)</ResponseField>
  <ResponseField name="has_sufficient_credits" type="boolean">Whether you have enough credits for at least one search</ResponseField>
  <ResponseField name="searches_available" type="number">Estimated number of searches available with current balance (integer)</ResponseField>
</ResponseField>

## Example Request

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

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/user"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

  response = requests.get(url, 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/user';

  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/user";

  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"
  )

  func main() {
      fullURL := "https://www.osintcat.net/api/user"
      
      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/user')

  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/user";
              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/user";
                  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>

## Example Response

```json theme={null}
{
  "account_info": {
    "username": "user123",
    "email": "user@example.com",
    "plan": "Starter"
  },
  "usage": {
    "request_limit_daily": 100,
    "requests_remaining_today": 85,
    "api_access": true,
    "intelx_access": false,
    "max_ips": 3
  },
  "email_osint_credits": {
    "current_balance": 10.50,
    "price_per_search": 0.40,
    "has_sufficient_credits": true,
    "searches_available": 26
  }
}
```


# Username Footprint
Source: https://docs.osintcat.net/api-reference/endpoint/user-footprint

GET https://www.osintcat.net/api/footprint/create-task
Discover platform registrations for a username across 100+ services

The Username Footprint API checks whether a given username is registered across social media, gaming, and community platforms.
It returns a summary and a per-platform breakdown including secondary metadata like profile IDs or account status where available.

The lookup backend is load-balanced, so footprint scans run as **asynchronous tasks**:

1. **Create a task** with `GET /api/footprint/create-task` (this is where one lookup is charged). You receive a `task_id`.
2. **Poll the task** with `GET /api/footprint/get-task?id=<task_id>` until `status` is no longer a running state. Polling is free.

<Note>
  Username and email footprints share the same task endpoints — only the `type` parameter differs (`username` vs `email`).
</Note>

***

## Step 1 — Create Task

```bash theme={null}
GET https://www.osintcat.net/api/footprint/create-task
```

<ParamField type="string">
  The username to scan (e.g., `johndoe`)
</ParamField>

<ParamField type="string">
  The footprint type. Use `username` for this endpoint.
</ParamField>

<ParamField type="string">
  Your API key
</ParamField>

<Warning>
  Creating a task consumes exactly **one lookup** from your daily quota. Polling `get-task` does not.
</Warning>

**Response Body**

<ResponseField name="task_id" type="string">
  The identifier used to poll for results.
</ResponseField>

<ResponseField name="status" type="string">
  The initial task status (e.g., `running`, `queued`, `pending`).
</ResponseField>

<ResponseField name="_meta" type="object">
  <Expandable title="properties">
    <ResponseField name="plan" type="string">Your current plan.</ResponseField>
    <ResponseField name="lookups_left" type="string">Remaining lookups for the day (`unlimited` on the Max plan).</ResponseField>
  </Expandable>
</ResponseField>

```json theme={null}
{
  "task_id": "f3c8a1e2-9b44-4d51-bd0a-1c2e3f4a5b6c",
  "status": "running",
  "_meta": {
    "plan": "researcher",
    "lookups_left": 4821
  }
}
```

***

## Step 2 — Poll Task

```bash theme={null}
GET https://www.osintcat.net/api/footprint/get-task
```

<ParamField type="string">
  The `task_id` returned by `create-task`.
</ParamField>

<ParamField type="string">
  Your API key
</ParamField>

Poll roughly once per second until `status` is no longer one of the running states
(`running`, `queued`, `pending`, `processing`, `started`). A scan typically completes
within a few seconds and is capped at \~3 minutes.

**Response Body**

<ResponseField name="status" type="string">
  Current task status. While running it is one of `running`, `queued`, `pending`,
  `processing`, `started`. Any other value (e.g., `done`, `finished`) means the scan is complete.
</ResponseField>

<ResponseField name="stats" type="object">
  Live progress / summary counters (populated as the scan runs).

  <Expandable title="properties">
    <ResponseField name="checked" type="number">Number of platforms checked so far.</ResponseField>
    <ResponseField name="total_modules" type="number">Total number of platforms in the scan.</ResponseField>
    <ResponseField name="found" type="number">Number of platforms where the username was found.</ResponseField>
    <ResponseField name="elapsed" type="string">Elapsed scan time.</ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="results" type="array">
  List of platform results (grows as the scan progresses).

  <Expandable title="item properties">
    <ResponseField name="domain" type="string">Platform domain (e.g., `github.com`)</ResponseField>
    <ResponseField name="taken" type="boolean">True if the username is registered on this platform</ResponseField>

    <ResponseField name="ExtraData" type="object">
      Metadata retrieved from the platform (profile IDs, avatar URLs, follower counts, etc.)
    </ResponseField>
  </Expandable>
</ResponseField>

***

## Example

<CodeGroup>
  ```bash cURL theme={null}
  # 1. Create the task
  curl "https://www.osintcat.net/api/footprint/create-task?query=johndoe&type=username" \
       -H "X-API-KEY: YOUR_API_KEY"

  # 2. Poll until done (replace TASK_ID with the returned task_id)
  curl "https://www.osintcat.net/api/footprint/get-task?id=TASK_ID" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import time
  import requests

  BASE = "https://www.osintcat.net"
  HEADERS = {"X-API-KEY": "YOUR_API_KEY"}
  RUNNING = {"running", "queued", "pending", "processing", "started"}

  # 1. Create the task (charges one lookup)
  task = requests.get(
      f"{BASE}/api/footprint/create-task",
      params={"query": "johndoe", "type": "username"},
      headers=HEADERS,
  ).json()
  task_id = task["task_id"]

  # 2. Poll until the scan finishes
  while True:
      data = requests.get(
          f"{BASE}/api/footprint/get-task",
          params={"id": task_id},
          headers=HEADERS,
      ).json()
      if str(data.get("status", "")).lower() not in RUNNING:
          break
      time.sleep(1)

  print(data)
  ```

  ```javascript Node.js theme={null}
  const BASE = 'https://www.osintcat.net';
  const HEADERS = { 'X-API-KEY': 'YOUR_API_KEY' };
  const RUNNING = ['running', 'queued', 'pending', 'processing', 'started'];
  const sleep = ms => new Promise(r => setTimeout(r, ms));

  (async () => {
    // 1. Create the task (charges one lookup)
    const task = await fetch(
      `${BASE}/api/footprint/create-task?query=johndoe&type=username`,
      { headers: HEADERS }
    ).then(r => r.json());

    // 2. Poll until the scan finishes
    let data;
    do {
      data = await fetch(
        `${BASE}/api/footprint/get-task?id=${encodeURIComponent(task.task_id)}`,
        { headers: HEADERS }
      ).then(r => r.json());
      if (!RUNNING.includes(String(data.status).toLowerCase())) break;
      await sleep(1000);
    } while (true);

    console.log(data);
  })();
  ```

  ```php PHP theme={null}
  <?php

  $base = "https://www.osintcat.net";
  $headers = ["X-API-KEY: YOUR_API_KEY"];
  $running = ["running", "queued", "pending", "processing", "started"];

  function get_json($url, $headers) {
      $curl = curl_init();
      curl_setopt_array($curl, [
          CURLOPT_URL => $url,
          CURLOPT_RETURNTRANSFER => true,
          CURLOPT_HTTPHEADER => $headers,
      ]);
      $response = curl_exec($curl);
      curl_close($curl);
      return json_decode($response, true);
  }

  // 1. Create the task (charges one lookup)
  $task = get_json("$base/api/footprint/create-task?query=johndoe&type=username", $headers);
  $taskId = $task["task_id"];

  // 2. Poll until the scan finishes
  do {
      $data = get_json("$base/api/footprint/get-task?id=" . urlencode($taskId), $headers);
      if (!in_array(strtolower($data["status"]), $running)) break;
      sleep(1);
  } while (true);

  print_r($data);
  ```

  ```go Go theme={null}
  package main

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

  func getJSON(u string) map[string]interface{} {
      req, _ := http.NewRequest("GET", u, nil)
      req.Header.Set("X-API-KEY", "YOUR_API_KEY")
      resp, _ := http.DefaultClient.Do(req)
      defer resp.Body.Close()
      body, _ := io.ReadAll(resp.Body)
      var out map[string]interface{}
      json.Unmarshal(body, &out)
      return out
  }

  func main() {
      base := "https://www.osintcat.net"
      running := map[string]bool{"running": true, "queued": true, "pending": true, "processing": true, "started": true}

      // 1. Create the task (charges one lookup)
      params := url.Values{}
      params.Add("query", "johndoe")
      params.Add("type", "username")
      task := getJSON(base + "/api/footprint/create-task?" + params.Encode())
      taskID, _ := task["task_id"].(string)

      // 2. Poll until the scan finishes
      var data map[string]interface{}
      for {
          data = getJSON(base + "/api/footprint/get-task?id=" + url.QueryEscape(taskID))
          status, _ := data["status"].(string)
          if !running[strings.ToLower(status)] {
              break
          }
          time.Sleep(time.Second)
      }
      fmt.Printf("%+v\n", data)
  }
  ```
</CodeGroup>

**Example Result (completed task)**

```json theme={null}
{
  "status": "done",
  "stats": {
    "checked": 112,
    "total_modules": 112,
    "found": 34,
    "elapsed": "5.1s"
  },
  "results": [
    {
      "domain": "github.com",
      "taken": true,
      "ExtraData": {
        "ProfileURL": "https://github.com/johndoe",
        "PublicRepos": 17
      }
    },
    {
      "domain": "reddit.com",
      "taken": false,
      "ExtraData": {}
    }
  ]
}
```


# VIN Lookup
Source: https://docs.osintcat.net/api-reference/endpoint/vin

GET https://www.osintcat.net/api/vin

Decode Vehicle Identification Numbers (VINs) and query vehicle data from the NHTSA vPIC API. Supports single/batch VIN decode, WMI decode, makes & models, manufacturers, vehicle variables, and Canadian vehicle specifications.

## Headers

<ParamField type="string">
  Your API key
</ParamField>

## Parameters

All requests require a `type` parameter. Other parameters depend on the operation. Use the fields below in the Try it panel; the tables describe which apply to each `type`.

<ParamField type="string" placeholder="decode | batch | wmi | makes | manufacturers | variables | canadian">
  Operation type
</ParamField>

<ParamField type="string" placeholder="VIN, WMI, or search term (depends on type)">
  VIN (decode/batch), WMI code (wmi), or search term (makes, manufacturers, variables). Not used for canadian.
</ParamField>

<ParamField type="number" placeholder="e.g. 2021">
  Model year 1981+. For type=decode only. Recommended for partial VINs.
</ParamField>

<ParamField type="boolean">
  If true, include extended NHTSA variables. For type=decode only.
</ParamField>

<ParamField type="string" placeholder="all | manufacturer | vehicletype | models | vehicletypes (makes); all | details | wmis | parts (manufacturers); list | values (variables)">
  Sub-operation. Required for type=makes, manufacturers, variables.
</ParamField>

<ParamField type="number" placeholder="e.g. 2023">
  Model year. For type=makes (manufacturer, models) and type=canadian (required).
</ParamField>

<ParamField type="string" placeholder="e.g. Passenger Car, Truck">
  e.g. Passenger Car, Truck. For type=makes (models) and type=manufacturers (wmis).
</ParamField>

<ParamField type="string" placeholder="e.g. Completed Vehicle Manufacturer">
  Manufacturer type filter. For type=manufacturers, search\_type=all.
</ParamField>

<ParamField type="string" placeholder="YYYY-MM-DD">
  Start date. Required for type=manufacturers, search\_type=parts.
</ParamField>

<ParamField type="string" placeholder="YYYY-MM-DD">
  End date. Required for type=manufacturers, search\_type=parts.
</ParamField>

<ParamField type="string" placeholder="565 | 566">
  Parts doc type. For type=manufacturers, search\_type=parts. Default: 565.
</ParamField>

<ParamField type="number" placeholder="1">
  Page number. For type=manufacturers. Default: 1.
</ParamField>

<ParamField type="string" placeholder="e.g. Honda, Toyota">
  Make. Required for type=canadian.
</ParamField>

<ParamField type="string" placeholder="e.g. Civic">
  Model name. For type=canadian.
</ParamField>

<ParamField type="string" placeholder="Metric | Imperial">
  Units for type=canadian. Metric or Imperial (Imperial is sent as US to the API). Default: Metric.
</ParamField>

***

### type: `decode`

Decode a 17-digit VIN or partial VIN (use `*` for missing characters).

| Parameter   | Type   | Required | Description                                            |
| ----------- | ------ | -------- | ------------------------------------------------------ |
| query       | string | Yes      | VIN (6–17 chars) or partial VIN                        |
| model\_year | int    | No       | Model year (1981+). Recommended for pre-1980.          |
| extended    | bool   | No       | `true` for extended NHTSA variables. Default: `false`. |

***

### type: `batch`

Decode up to 50 VINs at once. One per line; optional format: `VIN, model_year`.

| Parameter | Type   | Required | Description                 |
| --------- | ------ | -------- | --------------------------- |
| query     | string | Yes      | VINs, one per line. Max 50. |

***

### type: `wmi`

Decode a World Manufacturer Identifier (3 or 6 characters).

| Parameter | Type   | Required | Description                  |
| --------- | ------ | -------- | ---------------------------- |
| query     | string | Yes      | WMI code (e.g. `1FT`, `JHM`) |

***

### type: `makes`

Search makes, models, and vehicle types.

| Parameter     | Type   | Required | Description                                                                     |
| ------------- | ------ | -------- | ------------------------------------------------------------------------------- |
| search\_type  | string | Yes      | `all`, `manufacturer`, `vehicletype`, `models`, `vehicletypes`                  |
| query         | string | No\*     | Manufacturer/make/vehicle type (see search\_type). \*Required except for `all`. |
| year          | int    | No       | Model year (for `manufacturer`, `models`)                                       |
| vehicle\_type | string | No       | e.g. `Passenger Car`, `Truck` (for `models`)                                    |

***

### type: `manufacturers`

Search manufacturers, WMIs, and parts documentation.

| Parameter     | Type   | Required | Description                                                |
| ------------- | ------ | -------- | ---------------------------------------------------------- |
| search\_type  | string | Yes      | `all`, `details`, `wmis`, `parts`                          |
| query         | string | No\*     | Manufacturer name or ID. \*Required for `details`, `wmis`. |
| mfr\_type     | string | No       | e.g. `Completed Vehicle Manufacturer` (for `all`)          |
| from\_date    | string | No\*     | `YYYY-MM-DD`. \*Required for `parts`.                      |
| to\_date      | string | No\*     | `YYYY-MM-DD`. \*Required for `parts`.                      |
| parts\_type   | string | No       | `565` or `566`. Default: `565`. (for `parts`)              |
| vehicle\_type | string | No       | (for `wmis`)                                               |
| page          | int    | No       | Page number. Default: 1.                                   |

***

### type: `variables`

Get the list of vehicle variables or values for a specific variable.

| Parameter    | Type   | Required | Description                                                           |
| ------------ | ------ | -------- | --------------------------------------------------------------------- |
| search\_type | string | Yes      | `list` (all variables) or `values` (values for one variable)          |
| query        | string | No\*     | Variable name (e.g. `Vehicle Type`, `Make`). \*Required for `values`. |

***

### type: `canadian`

Get Canadian Vehicle Specifications (1971+). Uses `year` and `make`; `query` is not used.

| Parameter | Type   | Required | Description                                                                      |
| --------- | ------ | -------- | -------------------------------------------------------------------------------- |
| year      | int    | Yes      | Model year (1971+)                                                               |
| make      | string | Yes      | Make (e.g. `Honda`, `Toyota`)                                                    |
| model     | string | No       | Model name                                                                       |
| units     | string | No       | `Metric` or `Imperial` (Imperial is sent as `US` to the API). Default: `Metric`. |

***

## Response

Returns JSON. Structure depends on `type` (object for decode/wmi, array for makes/manufacturers/variables/list, etc.).

## Example: Decode VIN

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/vin?type=decode&query=1HGBH41JXMN109186&model_year=2021" \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/vin"
  params = {
      "type": "decode",
      "query": "1HGBH41JXMN109186",
      "model_year": "2021"
  }
  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} - {response.text}")
  ```

  ```javascript Node.js theme={null}
  const params = new URLSearchParams({
    type: 'decode',
    query: '1HGBH41JXMN109186',
    model_year: '2021'
  });

  fetch(`https://www.osintcat.net/api/vin?${params}`, {
    headers: { 'X-API-KEY': 'YOUR_API_KEY' }
  })
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:', err));
  ```
</CodeGroup>

## Example: WMI Decode

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=wmi&query=1FT" \
     -H "X-API-KEY: YOUR_API_KEY"
```

## Example: Get All Makes

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=makes&search_type=all&query=" \
     -H "X-API-KEY: YOUR_API_KEY"
```

Or with a dummy query (some clients omit empty query):

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=makes&search_type=all" \
     -H "X-API-KEY: YOUR_API_KEY"
```

## Example: Models by Make

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=makes&search_type=models&query=Tesla&year=2023" \
     -H "X-API-KEY: YOUR_API_KEY"
```

## Example: Variable List

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=variables&search_type=list" \
     -H "X-API-KEY: YOUR_API_KEY"
```

## Example: Variable Values

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=variables&search_type=values&query=Vehicle%20Type" \
     -H "X-API-KEY: YOUR_API_KEY"
```

## Example: Canadian Vehicle Specifications

```bash theme={null}
curl "https://www.osintcat.net/api/vin?type=canadian&year=2022&make=Honda&model=Civic&units=Metric" \
     -H "X-API-KEY: YOUR_API_KEY"
```

## Example: Batch Decode

```bash theme={null}
# Send VINs as newline-separated in query (URL-encode newlines as %0A)
curl "https://www.osintcat.net/api/vin?type=batch&query=1HGBH41JXMN109186%0A5YJ3E1EA1KF123456" \
     -H "X-API-KEY: YOUR_API_KEY"
```

For batch, `query` can also be sent in the request body as form data or in a POST with a JSON body if your client supports it; the backend reads `query` from `request.args`.

## Error Responses

| Code | Description                                                                                                                                                   |
| ---- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400  | Bad request: missing/invalid `query` (when required), invalid `type` or `search_type`, or validation error (e.g. `from_date`/`to_date` required for `parts`). |
| 403  | Invalid or missing `X-API-KEY`.                                                                                                                               |
| 429  | Rate limit exceeded.                                                                                                                                          |
| 500  | vPIC or internal error.                                                                                                                                       |

Errors return JSON, e.g. `{"error": "query parameter is required"}`.


# API Introduction
Source: https://docs.osintcat.net/api-reference/introduction

OsintCat API documentation - Comprehensive OSINT and data lookup services

## Welcome to OsintCat API

OsintCat provides a powerful REST API for OSINT (Open Source Intelligence) lookups, breach data searches, and public record queries. Our API enables developers to integrate comprehensive data lookup capabilities into their applications.

## Base URL

All API requests should be made to:

```
https://www.osintcat.net/api
```

## Authentication

All API endpoints require authentication using an API key. Include your API key in the header as "X-API-KEY"

<Warning>
  Keep your API key secure and never expose it in client-side code or public repositories.
</Warning>

### Example Request

```bash theme={null}
curl "https://www.osintcat.net/api/user" -H "X-API-KEY: YOUR_API_KEY"
```

## Rate Limits

Our API has a soft rate limit of **3 requests per second**. If you exceed this limit, you will receive a 30-minute timeout.

<Warning>
  **Rate Limit Warning**: Exceeding 3 requests per second will result in a 30-minute timeout. Please implement proper rate limiting in your application.
</Warning>

## Response Format

All API responses are returned in JSON format with proper HTTP status codes:

* `200` - Success
* `400` - Bad Request (missing or invalid parameters)
* `401` - Unauthorized (missing API key)
* `403` - Forbidden (invalid API key)
* `429` - Too Many Requests (rate limit exceeded)
* `500` - Internal Server Error

## API Plans

Different API plans have different request limits:

### Free Plan

* **API Requests**: 0 requests/day
* **Dashboard Requests**: 10 requests/day

### Premium Plan

* **API Requests**: 50 requests/day
* **Dashboard Requests**: Unlimited

### Enterprise Plan

* **API Requests**: Unlimited
* **Dashboard Requests**: Unlimited

<Note>
  Daily limits reset at midnight UTC. You can check your current usage and limits using the `/api/user` endpoint.
</Note>

## Available Endpoints

Our API provides the following endpoints:

### Account Management

* **[User Info](/api-reference/endpoint/user)** - Get account information, usage statistics, and email OSINT credit information

### OSINT Lookups

* **[Breach Lookup](/api-reference/endpoint/breach)** - Search for records in data breaches
* **[Discord Lookup](/api-reference/endpoint/discord)** - Find Discord user information
* **[Roblox to Discord](/api-reference/endpoint/roblox)** - Find Discord accounts linked to a Roblox username (wildcard supported)
* **[Discord to Roblox](/api-reference/endpoint/discord-to-roblox)** - Find linked Roblox accounts
* **[Email OSINT](/api-reference/endpoint/email-osint)** - Discover websites an email is registered on
* **[Phone OSINT](/api-reference/endpoint/phone-osint)** - Gather intelligence on phone numbers
* **[GitHub OSINT](/api-reference/endpoint/github-osint)** - Find GitHub accounts by email
* **[GitHub User Info](/api-reference/endpoint/github-userinfo)** - Get GitHub user information and email from commits
* **[Username Lookup](/api-reference/endpoint/username)** - Find stealer logs and site information
* **[Minecraft Lookup](/api-reference/endpoint/minecraft)** - Minecraft breach data lookup
* **[Minecraft OSINT](/api-reference/endpoint/minecraft-osint)** - Minecraft OSINT lookup with caching

### Network & Domain

* **[IP Info](/api-reference/endpoint/ip)** - Get IP information and stealer logs
* **[DNS Resolver](/api-reference/endpoint/dns-resolver)** - Resolve domain names to IP addresses
* **[Domain Lookup](/api-reference/endpoint/domain)** - Domain stealer lookup

### Public Records

* **[Chilean Name](/api-reference/endpoint/chilean-name)** - Find information about Chilean persons

## Getting Started

1. **[Sign up](https://www.osintcat.net/register)** for an account
2. **[Get your API key](https://www.osintcat.net/dashboard)** from the dashboard
3. Start making requests to our endpoints
4. Check your usage with the `/api/user` endpoint

## Code Examples

We provide code examples in multiple languages for each endpoint. You can find examples in:

* cURL
* Python
* Node.js
* PHP

## Support

If you need help or have questions:

* Check the endpoint-specific documentation
* Review the [Quickstart Guide](/quickstart)
* Contact support through your dashboard


# OsintCat API Documentation
Source: https://docs.osintcat.net/index

Comprehensive API documentation for OsintCat - OSINT and data lookup services

## Welcome to OsintCat API

OsintCat provides a powerful REST API for OSINT (Open Source Intelligence) lookups, breach data searches, and public record queries. Integrate comprehensive data lookup capabilities into your applications.

<Card title="Get Started" icon="rocket" href="/quickstart">
  Follow our quickstart guide to get your API key and make your first request.
</Card>

## Quick Links

<Columns>
  <Card title="API Reference" icon="terminal" href="/api-reference/introduction">
    Browse all available API endpoints and their documentation.
  </Card>

  <Card title="Get API Key" icon="key" href="https://www.osintcat.net/account?tab=api">
    Sign up for an account and get your API key to start making requests.
  </Card>

  <Card title="Dashboard" icon="chart-line" href="https://www.osintcat.net/dashboard">
    View your API usage, manage your account, and monitor your requests.
  </Card>

  <Card title="Pricing" icon="tag" href="https://www.osintcat.net/pricing">
    View our pricing plans and choose the one that fits your needs.
  </Card>
</Columns>

## Features

### Comprehensive OSINT Lookups

* **Breach Data**: Search across multiple breach databases
* **Social Media**: Lookup Discord, Roblox, and more
* **Email & Phone**: Discover where emails and phone numbers are registered
* **Username Search**: Find information across multiple platforms
* **Network Intelligence**: IP and domain lookups with stealer logs

### Developer Friendly

* **RESTful API**: Simple HTTP requests with JSON responses
* **Multiple Languages**: Code examples in cURL, Python, Node.js, and PHP
* **Rate Limiting**: Clear rate limits with automatic timeout protection
* **Comprehensive Docs**: Detailed documentation for every endpoint

### Reliable & Secure

* **API Key Authentication**: Secure access with API keys
* **Error Handling**: Clear error messages and HTTP status codes
* **Usage Tracking**: Monitor your API usage in real-time
* **Plan Flexibility**: Choose from Free, Premium, or Enterprise plans

## Popular Endpoints

<CardGroup>
  <Card title="User Info" icon="user" href="/api-reference/endpoint/user">
    Get account information and usage statistics
  </Card>

  <Card title="Breach Lookup" icon="shield-halved" href="/api-reference/endpoint/breach">
    Search for records in data breaches
  </Card>

  <Card title="Discord Lookup" icon="discord" href="/api-reference/endpoint/discord">
    Find Discord user information
  </Card>

  <Card title="IP Info" icon="network-wired" href="/api-reference/endpoint/ip">
    Get IP information and stealer logs
  </Card>

  <Card title="Username Lookup" icon="at" href="/api-reference/endpoint/username">
    Find information across multiple platforms
  </Card>
</CardGroup>

## Need Help?

<Card title="View API Reference" icon="book" href="/api-reference/introduction">
  Browse our complete API documentation with examples and detailed parameter descriptions.
</Card>


# Quickstart
Source: https://docs.osintcat.net/quickstart

Get started with OsintCat API in minutes

## Get Started in Three Steps

Get your API key and make your first request to the OsintCat API.

### Step 1: Create an Account

<AccordionGroup>
  <Accordion icon="user-plus" title="Sign up for an account">
    1. Visit [https://www.osintcat.net/register](https://www.osintcat.net/register)
    2. Fill in your details and create your account
    3. Verify your email address if required
  </Accordion>

  <Accordion icon="key" title="Get your API key">
    1. Log in to your [dashboard](https://www.osintcat.net/dashboard)
    2. Navigate to your account settings
    3. Copy your API key

    <Warning>
      Keep your API key secure and never expose it in client-side code or public repositories.
    </Warning>
  </Accordion>
</AccordionGroup>

### Step 2: Make Your First Request

Test the API by checking your account information:

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/user" -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/user"
  headers = {"X-API-KEY": "YOUR_API_KEY"}

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

  if response.ok:
      data = response.json()
      print(f"Plan: {data['account_info']['plan']}")
      print(f"API Requests Remaining: {data['usage']['api']['requests_remaining_today']}")
  else:
      print(f"Error: {response.status_code}")
  ```

  ```javascript Node.js theme={null}
  const url = 'https://www.osintcat.net/api/user';

  fetch(url, {
      headers: {
          'X-API-KEY': 'YOUR_API_KEY'
      }
  })
      .then(res => res.json())
      .then(data => {
          console.log(`Plan: ${data.account_info.plan}`);
          console.log(`API Requests Remaining: ${data.usage.api.requests_remaining_today}`);
      })
      .catch(err => console.error('error:' + err));
  ```

  ```php PHP theme={null}
  <?php

  $curl = curl_init();

  $url = "https://www.osintcat.net/api/user";

  curl_setopt($curl, CURLOPT_URL, $url);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($curl, CURLOPT_HTTPHEADER, array(
      'X-API-KEY: YOUR_API_KEY'
  ));

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

  curl_close($curl);

  if ($err) {
      echo "cURL Error #:" . $err;
  } else {
      $data = json_decode($response, true);
      echo "Plan: " . $data['account_info']['plan'] . "\n";
      echo "API Requests Remaining: " . $data['usage']['api']['requests_remaining_today'] . "\n";
  }
  ```

  ```go Go theme={null}
  package main

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

  func main() {
      url := "https://www.osintcat.net/api/user"

      req, err := http.NewRequest("GET", url, nil)
      if err != nil {
          fmt.Printf("Error creating request: %v\n", err)
          return
      }

      req.Header.Add("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, err := io.ReadAll(resp.Body)
      if err != nil {
          fmt.Printf("Error reading response: %v\n", err)
          return
      }

      var result map[string]interface{}
      json.Unmarshal(body, &result)

      accountInfo := result["account_info"].(map[string]interface{})
      usage := result["usage"].(map[string]interface{})
      apiUsage := usage["api"].(map[string]interface{})

      fmt.Printf("Plan: %v\n", accountInfo["plan"])
      fmt.Printf("API Requests Remaining: %v\n", apiUsage["requests_remaining_today"])
  }
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

  uri = URI('https://www.osintcat.net/api/user')

  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 "Plan: #{data['account_info']['plan']}"
      puts "API Requests Remaining: #{data['usage']['api']['requests_remaining_today']}"
  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;
  import org.json.JSONObject;

  public class OsintCatAPI {
      public static void main(String[] args) {
          try {
              String apiUrl = "https://www.osintcat.net/api/user";
              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;
                  StringBuffer response = new StringBuffer();

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

                  JSONObject json = new JSONObject(response.toString());
                  JSONObject accountInfo = json.getJSONObject("account_info");
                  JSONObject usage = json.getJSONObject("usage");
                  JSONObject apiUsage = usage.getJSONObject("api");

                  System.out.println("Plan: " + accountInfo.getString("plan"));
                  System.out.println("API Requests Remaining: " + apiUsage.get("requests_remaining_today"));
              } 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;
  using System.Text.Json;

  class Program
  {
      static async Task Main(string[] args)
      {
          using (var client = new HttpClient())
          {
              try
              {
                  string url = "https://www.osintcat.net/api/user";
                  client.DefaultRequestHeaders.Add("X-API-KEY", "YOUR_API_KEY");

                  var response = await client.GetAsync(url);

                  if (response.IsSuccessStatusCode)
                  {
                      string content = await response.Content.ReadAsStringAsync();
                      var json = JsonDocument.Parse(content);
                      var root = json.RootElement;

                      Console.WriteLine($"Plan: {root.GetProperty("account_info").GetProperty("plan").GetString()}");
                      Console.WriteLine($"API Requests Remaining: {root.GetProperty("usage").GetProperty("api").GetProperty("requests_remaining_today")}");
                  }
                  else
                  {
                      Console.WriteLine($"Error: {response.StatusCode}");
                  }
              }
              catch (Exception ex)
              {
                  Console.WriteLine($"Error: {ex.Message}");
              }
          }
      }
  }
  ```
</CodeGroup>

### Step 3: Try a Lookup Endpoint

Now try a breach lookup:

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://www.osintcat.net/api/breach?query=test@example.com&id=YOUR_API_KEY"
  ```

  ```python Python theme={null}
  import requests

  url = "https://www.osintcat.net/api/breach"
  params = {
      "query": "test@example.com",
      "id": "YOUR_API_KEY"
  }

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

  if response.ok:
      data = response.json()
      print(f"Found {data['results_count']} breach records")
      print(data)
  else:
      print(f"Error: {response.status_code}")
  ```

  ```javascript Node.js theme={null}
  const url = 'https://www.osintcat.net/api/breach?query=test@example.com&id=YOUR_API_KEY';

  fetch(url)
      .then(res => res.json())
      .then(data => {
          console.log(`Found ${data.results_count} breach records`);
          console.log(data);
      })
      .catch(err => console.error('error:' + err));
  ```

  ```php PHP theme={null}
  <?php

  $curl = curl_init();

  $url = "https://www.osintcat.net/api/breach?query=test@example.com&id=YOUR_API_KEY";

  curl_setopt($curl, CURLOPT_URL, $url);
  curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

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

  curl_close($curl);

  if ($err) {
      echo "cURL Error #:" . $err;
  } else {
      $data = json_decode($response, true);
      echo "Found " . $data['results_count'] . " breach records\n";
      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/breach"
      params := url.Values{}
      params.Add("query", "test@example.com")
      params.Add("id", "YOUR_API_KEY")
      
      fullURL := baseURL + "?" + params.Encode()
      
      resp, err := http.Get(fullURL)
      if err != nil {
          fmt.Printf("Error: %v\n", err)
          return
      }
      defer resp.Body.Close()
      
      body, err := io.ReadAll(resp.Body)
      if err != nil {
          fmt.Printf("Error reading response: %v\n", err)
          return
      }
      
      var result map[string]interface{}
      json.Unmarshal(body, &result)
      
      resultsCount := result["results_count"]
      fmt.Printf("Found %v breach records\n", resultsCount)
      fmt.Printf("%+v\n", result)
  }
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

  uri = URI('https://www.osintcat.net/api/breach')
  params = { query: 'test@example.com', id: 'YOUR_API_KEY' }
  uri.query = URI.encode_www_form(params)

  response = Net::HTTP.get_response(uri)

  if response.is_a?(Net::HTTPSuccess)
      data = JSON.parse(response.body)
      puts "Found #{data['results_count']} breach records"
      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;
  import org.json.JSONObject;

  public class OsintCatAPI {
      public static void main(String[] args) {
          try {
              String apiUrl = "https://www.osintcat.net/api/breach?query=test@example.com&id=YOUR_API_KEY";
              URL url = new URL(apiUrl);
              HttpURLConnection conn = (HttpURLConnection) url.openConnection();
              conn.setRequestMethod("GET");
              
              int responseCode = conn.getResponseCode();
              if (responseCode == HttpURLConnection.HTTP_OK) {
                  BufferedReader in = new BufferedReader(
                      new InputStreamReader(conn.getInputStream())
                  );
                  String inputLine;
                  StringBuffer response = new StringBuffer();
                  
                  while ((inputLine = in.readLine()) != null) {
                      response.append(inputLine);
                  }
                  in.close();
                  
                  JSONObject json = new JSONObject(response.toString());
                  System.out.println("Found " + json.getInt("results_count") + " breach records");
                  System.out.println(json.toString(2));
              } 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;
  using System.Text.Json;

  class Program
  {
      static async Task Main(string[] args)
      {
          using (var client = new HttpClient())
          {
              try
              {
                  string url = "https://www.osintcat.net/api/breach?query=test@example.com&id=YOUR_API_KEY";
                  var response = await client.GetAsync(url);
                  
                  if (response.IsSuccessStatusCode)
                  {
                      string content = await response.Content.ReadAsStringAsync();
                      var json = JsonDocument.Parse(content);
                      var root = json.RootElement;
                      
                      Console.WriteLine($"Found {root.GetProperty("results_count").GetInt32()} breach records");
                      Console.WriteLine(content);
                  }
                  else
                  {
                      Console.WriteLine($"Error: {response.StatusCode}");
                  }
              }
              catch (Exception ex)
              {
                  Console.WriteLine($"Error: {ex.Message}");
              }
          }
      }
  }
  ```
</CodeGroup>

## Understanding Rate Limits

<Warning>
  **Important**: Our API has a soft rate limit of **3 requests per second**. Exceeding this limit will result in a 30-minute timeout.
</Warning>

* Implement proper rate limiting in your application
* Use exponential backoff for retries
* Monitor your usage with the `/api/user` endpoint

## API Plans

### Free Plan

* API Requests: 0 requests/day
* Dashboard Requests: 10 requests/day

### Premium Plan

* API Requests: 50 requests/day
* Dashboard Requests: Unlimited

### Enterprise Plan

* API Requests: Unlimited
* Dashboard Requests: Unlimited

<Note>
  Daily limits reset at midnight UTC. Check your usage anytime with the `/api/user` endpoint.
</Note>

## Next Steps

<CardGroup>
  <Card title="Browse API Reference" icon="book" href="/api-reference/introduction">
    Explore all available endpoints and their parameters.
  </Card>

  <Card title="View Examples" icon="code" href="/api-reference/endpoint/breach">
    See code examples for each endpoint in multiple languages.
  </Card>

  <Card title="Check Usage" icon="chart-line" href="/api-reference/endpoint/user">
    Learn how to monitor your API usage and limits.
  </Card>

  <Card title="Get Support" icon="headset" href="https://www.osintcat.net/dashboard">
    Access support through your dashboard.
  </Card>
</CardGroup>

## Common Use Cases

### Security Research

Use breach lookups and email OSINT to investigate security incidents and data leaks.

### Account Verification

Verify user information across multiple platforms using username and email lookups.

### Network Analysis

Analyze IP addresses and domains to understand network infrastructure and potential threats.

### Social Media Intelligence

Gather information from Discord and other platforms for legitimate research purposes.

<Note>
  Always ensure you have proper authorization and comply with applicable laws when using OSINT tools.
</Note>