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

# Roblox to Discord

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 query="query" type="string" required>
  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 header="X-API-KEY" type="string" required>
  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>