Register a new server session when the Roblox server boots. Must be called before any other /adminlog endpoints.

Mark when the event formally begins. Captures the overseer team at this instant.

Record when the match ends. Does not post the log. That happens on server close via /session/discard.

Called on server close (game:BindToClose). If a match was started, posts the full event log to Discord then destroys the session. If no match was started, silently discards.

Add a player to the overseer team at any point during the session. Idempotent. Safe to call multiple times for the same username.

Record an admin command execution. Call this every time a player runs an Adonis command during the session.

Record when an admin opens the spectate or CXW UI on a target.

Record when the spectate or CXW UI is closed.

Check an event's attendee list against the recording policy flaglist and send Discord DM notifications to any flagged attendees. Called by Google Apps Script when a new event row is logged.

{ ok: true, notified: number, flaggedAttendees: string[], skipped: number }

Returns all mainframe sheet data in one call: weekly and monthly events, activity tracker, officer tracker, honored tracker, departments, and settings. Cached for 10 minutes with stale-while-revalidate. Add ?bust=true to force an immediate refresh.

{ weeklyEvents, monthlyEvents, activity: { members[] }, officers: { officers[] }, honored: { members[] }, departments[], settings }

Returns all rows from the Event Log sheet as structured objects. Cached for 5 minutes.

Array of event objects: { eventId, date, host, eventType, screenshot, attendeeCount, attendeeList, apPoints, opPoints, ... }

Returns current objectives data from the configured Apps Script deployment. Cached for 5 minutes.

Run a specific named read query against the mainframe. Use the fn parameter to select which query to run.

Returns a flat list of Roblox usernames from the GroupMembers sheet tab. Cached for 1 hour.

string[]

Look up a single event log entry by its Event ID (column P). Cached for 1 minute.

{ found: boolean, hostUsername, date, eventType, attendees, screenshot, notes }

Look up how many exemption days a member has used and how many remain.

{ found: boolean, daysUsed: number, daysRemaining: number }

Returns per-attendee rows from the Monthly Events tab, used for DIS sync. Each row includes the Roblox gameId the DIS tile is keyed to.

{ events: [{ date, username, eventType, gameId }] }

Submit a new event log entry. Writes via the Google Form (same path as the /eventlog Discord command) to ensure formula columns (AP, OP, multiplier) are populated correctly. Responds immediately with a locally-generated eventId; sheet confirmation and DM to the submitter happen in the background.

{ success: true, eventId: string }

Notify officers of strike changes after a quota reset. DMs each affected officer and posts a summary to the configured strike log channel. Called by the mainframe Apps Script after quota resets.

{ ok: true, notified: number, failed: number }

Run a named write operation against the mainframe. Use the fn field to select which action to perform.

Edit an existing event log row by its Event ID. Only fields provided in the payload are updated; omitted fields are left unchanged. Busts the event log cache.

{ success: true }

Submit a stats transfer request. Logs to the transfer sheet as Pending, sends a Discord notification with Approve/Deny links.

{ success: true, requestId: string }

Submit a missing AP request. Logs to the Missing AP Log sheet as Pending and sends a Discord notification with Approve/Deny links. Rate limited to 1 request per 5 minutes per username. Evidence must be a direct http(s) screenshot URL. Discord links are rejected.

{ success: true, requestId: string }

Add a member to the Officer Tracker. Inserts at the correct rank-grouped position. Returns 409 if the username is already on the tracker.

{ success: true }

Remove a member from the Officer Tracker by username (column A). Returns 404 if not found.

{ success: true }

Public profile of any Roblox account: its ID, headshot, rank in the Commandos and Ghost groups, Clan Labs XP and medals, every time it joined the division, and what our games have reported for it (gameStats, null if never seen). Clan Labs is only asked about accounts in the Commandos group, so clanLabs is null for anyone else. Returns 404 when no Roblox account has that username.

{ robloxId, username, headshot: string | null, mainRank: { rank, name } | null, ghostRank: { rank, name } | null, clanLabs: { xp, rank, nextRank: { name, xp } | null, medals: string[] } | null, clanLabsUnavailable: boolean, intake: { joinedAt: number (ms), entries: [{ at: number (ms), type, source }] } | null, intakeUnavailable: boolean, gameStats: { sessions, playtimeSeconds, firstSeen, lastSeen (Unix seconds), lastPlace: { placeId, name } | null, stats: [{ name, label, total?, perSession?, best? }], kdr?, winRate?, places: [{ placeId, name, sessions, playtimeSeconds, lastSeen, stats, kdr?, winRate? }] } | null, gameStatsUnavailable: boolean }

Roblox user IDs and headshot image URLs for up to 100 usernames in one call. Keys in the response are the usernames in lower case. A name Roblox does not know comes back with id and url set to null.

{ avatars: { [username]: { id: string | null, url: string | null } } }

The Clan Labs ranks, lowest first, with the XP each needs, plus the roles of the Commandos and Ghost Roblox groups. A part that could not be loaded is null. Ranks that are given rather than earned have xp 0 and locked true.

{ clanLabs: [{ rankId, name, xp, quota, locked }] | null, main: [{ rank, name, memberCount }] | null, ghost: [{ rank, name, memberCount }] | null }

Every medal in the Clan Labs catalogue, with its description.

{ medals: [{ name, description }] }

Rank history, newest first: every rank change the bot has made (rank sets and evaluation passes) and every approved prestige level. Pass a username to get one account's history. Rows include who made the change and why, so only show those two fields to people who should see them.

{ changes: [{ at: number (ms) | null, date, username, robloxId, from, to, group, by, reason }] }

The medals a member can ask for with POST /api/site/requests/medal.

{ medals: [{ name, description }] }

Send a medal request on a member's behalf, the same as /medal request in Discord. It is posted to the medal request channel for staff to approve or deny, and the member is told by DM. A member can send 3 an hour (429 after that). The caller vouches for who is asking: only send the identity of a member you have signed in.

{ ok: true, message: string }

Request the member's next prestige level, the same as /prestige request in Discord. Their Raid/Defense record and Clan Labs XP are checked straight away: Prestige 1 is approved on the spot and levels 2 to 4 go to a vote. Returns 409 with the reason in error when they do not qualify, already have a request open, or a check could not be run.

{ ok: boolean, message: string }

Request an activity exemption for the member, the same as /exemptionrequest in Discord, with the same checks and automatic approval. The end date is moved to the nearest Monday, since exemptions end when a quota week starts.

{ ok: true, message: string }

One member's own requests of every type, newest first (at most 60), including ones made in Discord. A type that could not be read is named in unavailable and the rest are still returned.

{ requests: [{ type, id, summary, status, state: "pending" | "approved" | "denied" | "closed", note: string | null, submittedAt: number (ms) | null, updatedAt: number (ms) | null }], unavailable: string[] }

Post an application review card to the configured Discord channel. Called by Google Apps Script when a form submission is categorised. The card includes an Approve/Deny interface for staff. The applicationType must match a key defined in lib/applicationTypes.js.

{ success: true, flowId: string }

Post an event feedback form response to the Event Feedback Channel with Accept and Deny. Accepting gives the attendee 5 XP on Clan Labs when they are a real Roblox user; either decision is written to the Event Feedback tab (Status, Reviewer, Date Reviewed, XP Added). Sending the same submissionId again does not post a second card.

{ success: true, id: number, duplicate: boolean }

Create a Notion card for an IA form submission and post an interactive notification to the configured ia_channel. Supports misconduct reports, punishment appeals, and clemency requests. The Discord notification includes Create Case / Dismiss buttons for IA staff. History requests create a Notion card only (no Discord buttons). Requires NOTION_IA_DATABASE_ID to be configured.

{ success: true, cardId: string, url: string, caseId: number }

Create intakes for one or more users. The same pipeline as the /intake slash command (RoWifi verification, grace-period + active-intake checks, group-membership routing to officer eval / ghost entrance completion / background check). aep and ot are not supported here. They have their own dedicated flows.

{ success: true, results: [{ userId, status, detail, flowId?, robloxUsername?, tag? }] }: status is one of: processed, skipped, error, not_verified, already_active, grace_period, already_in_division

CreateIntake. Single-user variant for callers that already know BOTH the Roblox ID and Discord ID (no RoWifi lookup happens). Restricted to the three bypass types. Still runs the same active-intake, grace-period, and group-membership checks as the bulk endpoint before submitting the background check.

{ success: true, status, detail, flowId?, robloxUsername? }: status is one of: processed, skipped, error, already_active, grace_period, already_in_division

Report what players did in one server. Send deltas (what happened since the last report), usually when a player leaves, in batches of up to 100. Each report has a reportId, so resending the same report after a timeout is safe and is never counted twice. A facility is registered automatically the first time its placeId reports. Stats named kills + deaths get a K/D ratio and wins + losses get a win rate automatically. Keep the key in a server script or the Secrets store, never on the client.

{ ok: true, recorded, duplicate, invalid, results: [{ index, status: "recorded" | "duplicate" | "invalid", reason? }] }
A 500 means nothing from the request was saved; resend it unchanged.

local HttpService = game:GetService("HttpService")
local API_KEY = HttpService:GetSecret("CIPHER_STATS_KEY")

local function reportSession(player, session)
  local body = HttpService:JSONEncode({
    placeId = game.PlaceId, universeId = game.GameId,
    sessions = {{
      userId = player.UserId, username = player.Name,
      sessionId = session.id, playtime = os.time() - session.joinedAt,
      stats = { kills = session.kills, deaths = session.deaths, captures = session.captures },
      max = { best_streak = session.bestStreak },
    }},
  })
  local ok, res = pcall(HttpService.RequestAsync, HttpService, {
    Url = "https://api.cipherinteractive.dev/api/stats/sessions", Method = "POST",
    Headers = { ["Content-Type"] = "application/json", ["x-api-key"] = API_KEY },
    Body = body,
  })
  if not ok or not res.Success then warn("Stats report failed, will retry:", ok and res.StatusCode or res) end
end

One-off backfill of totals a game already tracked before this API existed. mode "add" adds to what is stored, "set" replaces the stored totals. Does not change session counts or playtime.

{ ok: true, imported }

Every global ban, read live from Imperial Affairs, which updates it the moment someone is banned or unbanned (the Google Sheet is only read here if Imperial Affairs is down; source says which). Never cached, so check it when a player joins rather than keeping a copy.

{ count, bans: [{ robloxId, username, reason, date }], source: "live" | "sheet", checkedAt }

Whether one account is globally banned, and why. The quickest check to run when a player joins.

{ robloxId, banned: boolean, ban: { robloxId, username, reason, date } | null, source, checkedAt }

local HttpService = game:GetService("HttpService")
local res = HttpService:RequestAsync({
  Url = "https://api.cipherinteractive.dev/api/games/bans/" .. player.UserId,
  Method = "GET",
  Headers = { ["x-api-key"] = API_KEY },
})
local data = HttpService:JSONDecode(res.Body)
if data.banned then player:Kick("You are banned: " .. data.ban.reason) end

Everyone on the Recording Policy. Only the Roblox account and the date they were placed on it are given, never the reason.

{ count, members: [{ robloxId, username, since: "YYYY-MM-DD" | null }], source, checkedAt }

Whether one account is on the Recording Policy, for example to announce in chat when they join.

{ robloxId, onPolicy: boolean, username, since, source, checkedAt }

Who holds each perk role (Peak Performance, Top Host, Officer of the Month). The roles are set on the dashboard under Game Perks and matched to Roblox accounts through RoWifi; unlinked counts members with a perk who are not verified. Refreshed every 2 minutes.

{ perks: { peak_performance: [{ robloxId, username }], top_host: [...], officer_of_the_month: [...] }, labels, unlinked, notSet: string[], updatedAt }

The perks one account has, as keys from /api/games/perks.

{ robloxId, perks: ["peak_performance" | "top_host" | "officer_of_the_month"], labels, updatedAt }

Everything recorded for one player: combined totals across every facility plus a per-facility breakdown. Hidden facilities are left out.

{ robloxId, username, global: { sessions, playtimeSeconds, firstSeen, lastSeen, lastPlace, stats: { name: { total?, perSession?, best? } }, derived: { kdr?, winRate? } }, places: [{ placeId, name, sessions, playtimeSeconds, firstSeen, lastSeen, stats, derived }] }
404 when the player has no stats yet.

Top players for one stat, across every facility or for one.

{ stat, kind, placeId, entries: [{ rank, robloxId, username, value }] }

Facilities that have reported stats, busiest first.

{ places: [{ placeId, universeId, name, hidden, players, sessions }] }