FriendPath API Documentation

// Browser or Node 18+ (uses fetch)
const res = await fetch(
  "https://arbastro.com/api/v1/friendpath/path?from=Builderman&to=david.baszucki",
  { "headers": { "Authorization": "Bearer ak_live_YOUR_KEY" } }
);
const data = await res.json();
// data.result.degrees === 2
// data.result.path === [{id, username}, ...]
console.log(`degrees: ${data.result.degrees}`);

type PathResult = {
  from: { input: string; userId: number };
  to:   { input: string; userId: number };
  result: {
    type: "done" | "not_found" | "error";
    degrees?: number;
    visited?: number;
    path?: { id: number; username: string }[];
  };
};

async function scanPath(from: string, to: string): Promise<PathResult> {
  const u = new URL("https://arbastro.com/api/v1/friendpath/path");
  u.searchParams.set("from", from);
  u.searchParams.set("to", to);
  const r = await fetch(u, {
    headers: { Authorization: `Bearer ${process.env.FRIENDPATH_KEY}` }
  });
  if (!r.ok) throw new Error(`scan failed: ${r.status}`);
  return r.json();
}

import os, requests

def scan_path(a: str, b: str) -> dict:
    key = os.environ["FRIENDPATH_KEY"]
    r = requests.get(
        "https://arbastro.com/api/v1/friendpath/path",
        params={"from": a, "to": b},
        headers={"Authorization": f"Bearer {key}"},
        timeout=60,
    )
    r.raise_for_status()
    return r.json()

data = scan_path("Builderman", "david.baszucki")
print(f"degrees: {data['result']['degrees']}")

--!strict
-- ServerScript — drop in ServerScriptService
-- Game Settings → Security → Allow HTTP Requests must be ON

local HttpService = game:GetService("HttpService")

local FRIENDPATH_KEY: string = "ak_live_YOUR_KEY"
local API_BASE: string = "https://arbastro.com/api/v1/friendpath/path"

type PathNode = { Id: number, Username: string }

type ScanResult = {
    Found: boolean,
    Degrees: number?,
    Path: { PathNode }?,
    Error: string?,
}

local function ScanFriendPath(FromUser: string, ToUser: string): ScanResult
    local Url = API_BASE
        .. "?from=" .. HttpService:UrlEncode(FromUser)
        .. "&to="   .. HttpService:UrlEncode(ToUser)

    local Ok, Response = pcall(function()
        return HttpService:RequestAsync({
            Url = Url,
            Method = "GET",
            Headers = {
                ["Authorization"] = "Bearer " .. FRIENDPATH_KEY,
            },
        })
    end)

    if not Ok or not Response.Success then
        return { Found = false, Error = "http error" } :: ScanResult
    end

    local Body = HttpService:JSONDecode(Response.Body)
    local Result = Body.result

    if Result.type ~= "done" then
        return { Found = false, Error = Result.type } :: ScanResult
    end

    local Path: { PathNode } = {}
    for _, Node in ipairs(Result.path) do
        table.insert(Path, { Id = Node.id, Username = Node.username })
    end

    return {
        Found = true,
        Degrees = Result.degrees,
        Path = Path,
    } :: ScanResult
end

-- Usage:
local Result = ScanFriendPath("Builderman", "david.baszucki")
if Result.Found then
    print("degrees:", Result.Degrees)
end

// discord.js v14 — slash command /friendpath
const { SlashCommandBuilder } = require("discord.js");

module.exports = {
  data: new SlashCommandBuilder()
    .setName("friendpath")
    .setDescription("degrees of separation between two Roblox users")
    .addStringOption(o => o.setName("from").setRequired(true))
    .addStringOption(o => o.setName("to").setRequired(true)),

  async execute(i) {
    await i.deferReply();
    const u = new URL("https://arbastro.com/api/v1/friendpath/path");
    u.searchParams.set("from", i.options.getString("from"));
    u.searchParams.set("to",   i.options.getString("to"));
    const r = await fetch(u, {
      headers: { Authorization: `Bearer ${process.env.FRIENDPATH_KEY}` }
    });
    const data = await r.json();
    if (data.result?.type !== "done") return i.editReply("no path found 😕");
    await i.editReply(
      `**${data.result.degrees} degrees** apart\n` +
      data.result.path.map(n => `• ${n.username}`).join("\n")
    );
  }
};

package friendpath

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

type PathResult struct {
    Result struct {
        Type    string
        Degrees int
        Path    []struct{ Id int64; Username string }
    } `json:"result"`
}

func Scan(from, to string) (*PathResult, error) {
    u, _ := url.Parse("https://arbastro.com/api/v1/friendpath/path")
    q := u.Query()
    q.Set("from", from); q.Set("to", to); u.RawQuery = q.Encode()
    req, _ := http.NewRequest("GET", u.String(), nil)
    req.Header.Set("Authorization", "Bearer "+os.Getenv("FRIENDPATH_KEY"))
    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()
    out := &PathResult{}
    return out, json.NewDecoder(resp.Body).Decode(out)
}

const famous = await fetch("https://friendpath.arbastro.com/api/famous-users")
  .then(r => r.json());
// Pick a random one
const picked = famous[Math.floor(Math.random() * famous.length)];
console.log(`random famous: ${picked.name}`);

import requests, random

famous = requests.get("https://friendpath.arbastro.com/api/famous-users").json()
picked = random.choice(famous)
print(f"random famous: {picked['name']}")

--!strict
local HttpService = game:GetService("HttpService")

type FamousUser = {
    Id: number,
    Name: string,
    DisplayName: string?,
    Followers: number?,
    Friends: number?,
}

local function FetchFamousUsers(): { FamousUser }
    local RawJson: string = HttpService:GetAsync(
        "https://friendpath.arbastro.com/api/famous-users"
    )
    local Decoded = HttpService:JSONDecode(RawJson)
    local List: { FamousUser } = {}
    for _, U in ipairs(Decoded) do
        table.insert(List, {
            Id          = U.id,
            Name        = U.name,
            DisplayName = U.displayName,
            Followers   = U.followers,
            Friends     = U.friends,
        })
    end
    return List
end

-- Usage:
local Famous = FetchFamousUsers()
local Picked = Famous[math.random(#Famous)]
print("random famous:", Picked.Name)