# Age Check Source: https://docs.bloxcord.net/age-check Age Check is BloxCord's built-in age verification system, designed to help your organization confirm users meet your age requirements without staff ever handling personal documents. Users complete a quick verification that combines a guided face scan with AI-powered checks for liveness, consistency, and age estimation, then returns a clear result for administrators to review. Age Check must be enabled before age verification sessions and results can be viewed or managed. Visit the Features tab to get started. Age Check verification page in BloxCord ## How It Works The user opens Age Check and taps **Begin verification**. They're taken to a BloxCord-affiliated site to complete the process on a mobile device with a camera. The user enters their year of birth, allowing BloxCord to compare their claimed age against the estimated age from the verification. They follow simple on-screen prompts, moving their head or making expressions. The scan takes around a minute and is used only to estimate age. BloxCord's AI analyzes the verification for liveness, consistency, and facial matching, comparing the submitted images against age-specific AI models trained for different age groups before returning a result that authorized administrators can review. ## Your Privacy, Our Priority Age Check was built with privacy first. **Your face is never stored, never shown to a human, and never used for anything beyond verifying your age.** ## Frequently Asked Questions Age Check captures a short series of images and processes them through an automated AI age estimation system. The estimated age is compared against the information you provide to verify eligibility. Images and any facial analysis derived from them are used only for age verification, are never stored, and are never used to identify you or for any other purpose. No. Your images are processed entirely by automated systems. They are never viewed or manually reviewed by our staff and are deleted after the verification is complete. Age estimation may be performed using a trusted third-party AI provider that processes images on our behalf to return an age estimate. Where required by law, this processing is based on your consent. If you choose not to use Age Check, some features or access may be unavailable. After an Age Check is completed, authorized Owners and Administrators can view the verification result, the user's declared and estimated age groups (such as 13–14, 15–17, or 18–20), liveness status (Passed or Failed), and the number of devices used during verification. The underlying images are never shared with your organization. The verification site is operated by BloxCord Systems and Starstruck Solutions LLC. It exists solely to perform Age Check verifications and is not used for any other purpose. Read the full policy at [bloxcord.net/privacy](https://bloxcord.net/privacy). # Best Practices Source: https://docs.bloxcord.net/api/best-practices How to use the Game API efficiently and reliably — rate limits, caching, batching, and error handling. The Game API is fast, but every call is a network request that shares a per-server budget. A few habits keep your experience responsive and prevent your calls from being throttled or dropped. Read this once before shipping. ## Respect the rate limits Every operation — single calls, batched calls, and reads — draws from one per-server budget: | Limit | Value | | --------------------------------------------------------- | ------- | | Operations per minute (per server) | **120** | | Operations per [`apiBatch`](/reference/webhooks#apibatch) | **20** | When you exceed the budget, calls start returning `nil`/`false` (HTTP `429`). Some expensive methods also carry their own, tighter limit — for example [`getLeaderboard`](/reference/activity#getleaderboard) allows **one call every 30 seconds** per server. These are noted on the relevant method. Budgets are **per game server**, not per player. In a full 50-player server, "one call per player" can blow the entire minute budget in seconds. Always think in terms of the whole server. ## Don't call the same endpoint repeatedly The single biggest cause of throttling is re-fetching data that hasn't changed. Fetch it once, keep the result, and reuse it. Never put an API call inside a loop that runs every frame or tick — a `RunService.Heartbeat`/`Stepped`/`RenderStepped` connection, a `while true` loop, or a per-hit combat handler. Even a "cheap" read will exhaust the budget and stall the calling thread (every call [yields](/api/concepts#yielding)). Fetch on the event that actually changes the data instead: ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") -- GOOD: fetch a player's permissions once, when they join. game.Players.PlayerAdded:Connect(function(player) local permissions = BloxCord:Invoke("getUserPermissions", player) player:SetAttribute("BC_Loaded", permissions ~= nil) end) ``` ```lua theme={null} -- BAD: re-fetching the same unchanging data on every command. local function onCommand(player) local permissions = BloxCord:Invoke("getUserPermissions", player) -- ❌ every time -- ... end ``` ## Cache reads in your own code For data you read often, keep a small in-memory cache keyed by user id and refresh it only when it matters (on a timer, or after you change the underlying data). ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local cache = {} -- [userId] = { data = ..., expires = os.clock() + ttl } local TTL = 60 -- seconds local function getProfile(userId) local entry = cache[userId] if entry and os.clock() < entry.expires then return entry.data end local profile = BloxCord:Invoke("getUserProfile", userId) if profile then cache[userId] = { data = profile, expires = os.clock() + TTL } end return profile end game.Players.PlayerRemoving:Connect(function(player) cache[player.UserId] = nil -- evict on leave end) ``` A few methods are already cached for you per player for the length of their session — [`getUserPermissions`](/reference/ranking-permissions#getuserpermissions) and [`getUserRoles`](/reference/ranking-permissions#getuserroles). You still shouldn't call them in a loop, but you don't need to build your own cache for them. ## Batch related operations If you need to perform several operations at once, send them together with [`apiBatch`](/reference/webhooks#apibatch) instead of firing many separate calls. One batch of 20 counts the same against the budget as 20 singles, but it's a single round-trip — faster, and far less likely to interleave with other work. ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") -- One request instead of three. local results = BloxCord:Invoke("apiBatch", host, { { op = "points.update", args = { userId = "111", amount = 5, reason = "Attendance" } }, { op = "points.update", args = { userId = "222", amount = 5, reason = "Attendance" } }, { op = "logbook.create", args = { userId = "333", type = "warning", reason = "Late" } }, }) ``` Award end-of-session points, mark attendees, and write logs in a single batch at the end rather than one call per player as things happen. ## Debounce player-triggered actions Any call a player can trigger (a button, a command, a chat trigger) needs a guard, or a single player can spam your budget. Track a per-player timestamp and reject calls that come too fast. ```lua theme={null} local lastUsed = {} -- [userId] = os.clock() local COOLDOWN = 3 -- seconds local function handleRequest(player) local now = os.clock() if lastUsed[player.UserId] and now - lastUsed[player.UserId] < COOLDOWN then return -- ignore spam end lastUsed[player.UserId] = now -- safe to make the call here end ``` ## Handle failures without hammering A `nil` or `false` return can mean a rejection *or* a transient network issue. Always check the result before using it, and if you retry, **back off** — never retry in a tight loop. ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local function withRetry(fn, attempts) for i = 1, attempts do local result = fn() if result ~= nil and result ~= false then return result end task.wait(2 ^ i) -- 2s, 4s, 8s ... exponential backoff end return nil end local balance = withRetry(function() return BloxCord:Invoke("getUserPoints", requester, player) end, 3) ``` Do not retry immediately or in a loop. If you were throttled, retrying instantly keeps you throttled and can starve every other call in the server. ## Run independent calls concurrently — within reason Because each call yields, running several **independent** calls sequentially adds up their wait times. Use `task.spawn` to overlap them — but don't fan out hundreds at once, or you'll hit the budget instantly. ```lua theme={null} -- Overlap a handful of independent lookups. for _, player in ipairs(game.Players:GetPlayers()) do task.spawn(function() local mins = BloxCord:Invoke("getUserMinutes", player.UserId, {}) player:SetAttribute("BC_Minutes", mins and mins.active or 0) end) end ``` For a value you need for *many* users at once, prefer a method that returns them together (e.g. [`getLeaderboard`](/reference/activity#getleaderboard) with a `userIds` list) over one call per user. ## Keep payloads small and reuse identifiers * Each operation's `args` payload is capped at **24 KB**. Send only what the method needs — don't forward large tables or entire data models. * When you start a session, keep the returned `sid` and pass it to every follow-up call rather than fetching the session again to find it. * Remember timestamps are **Unix epoch milliseconds** (see [Core Concepts → Timestamps](/api/concepts#timestamps)); `os.time()` returns seconds, so multiply by `1000`. ## Quick checklist No API calls inside per-frame or `while true` loops. Reads that don't change are cached (or fetched once on join). Multiple operations are grouped into a single `apiBatch`. Player-triggered actions are debounced. Every result is checked for `nil`/`false` before use. Retries use backoff, never a tight loop. ## Next steps Actor object, return conventions, yielding, and the full rate-limit rules. Run several operations in a single request. # Core Concepts Source: https://docs.bloxcord.net/api/concepts These rules apply to every method in the API Reference, including actors, return values, yielding, and rate limits. Read this page first to better understand each method. ## The actor object Most write operations (ranking, logbook, points, sessions, webhooks) require an **actor** — the entity that is credited with performing the action. Actions taken through this API are audit-logged on the dashboard as "via in-game API" and attributed to this actor. You can pass an actor in three forms: Pass a `Player` instance directly. BloxCord reads the player's `UserId`, `Name`, and group rank automatically. ```lua theme={null} BloxCord:Invoke("setRank", targetUserId, "Promotion", 5, actingPlayer) ``` Pass a table when the actor is not currently in the server. ```lua theme={null} local actor = { id = 123456789, -- required, numeric UserId username = "Builderman", rank = 255, role = "Owner", } BloxCord:Invoke("setRank", targetUserId, "Promotion", 5, actor) ``` Pass a bare number or string when you only have an id. ```lua theme={null} BloxCord:Invoke("setRank", targetUserId, "Promotion", 5, 123456789) ``` For every V2 operation (ranking, logbook, points, reputation, sessions, webhooks, batch), the actor **must resolve to a numeric UserId**. A table actor without a valid numeric `id` is rejected with a `400` error and the method returns `nil`. The actor's Roblox `UserId`. Must be numeric (1–20 digits). The actor's display/username. Truncated to 40 characters server-side. The actor's group rank. Re-validated against the live group by the dashboard. The actor's role name. Truncated to 120 characters server-side. ## Return-value conventions The value returned by `:Invoke()` depends on the method, but follows consistent patterns: | Return style | Meaning | | ----------------- | --------------------------------------------------------------------------------- | | `boolean` | `true` = success, `false` = failure or a business-rule rejection (e.g. cooldown). | | `table` / `array` | The requested data. Read-only snapshots. | | `number` | A scalar value such as a points balance. | | `nil` | The backend was unreachable, timed out, or rejected the request. | Because a failed network request generally surfaces as `nil` or `false`, always guard the return value before using it: ```lua theme={null} local balance = BloxCord:Invoke("getUserPoints", actor, player) if balance == nil then warn("Points lookup failed") return end ``` ## Yielding Nearly every method performs an HTTPS request and **yields** the calling thread until the backend responds (or the request times out). Guidelines: * Never call these methods on `RunService.Heartbeat`, `Stepped`, or `RenderStepped`. * Wrap independent calls in `coroutine.wrap` / `task.spawn` if you need concurrency. * Expect occasional `nil` returns during network hiccups and handle them. ## Rate limits V2 Operations share a per-server budget: Combined across single and batch calls, per game server. Exceeding this returns `nil` (HTTP `429`). The maximum number of operations in a single [`apiBatch`](/reference/webhooks-batch#apibatch) call. Some methods add their own limits (for example, [`modcall`](/reference/moderation#modcall) enforces a 10-minute per-player cooldown). These are noted on the relevant method. ## Invalid methods Calling `:Invoke()` with an unknown method name emits a warning to the server console and returns `false`. Double-check spelling and casing — method names are **case-sensitive**. # Introduction Source: https://docs.bloxcord.net/api/introduction Connect your Roblox experience directly to BloxCord with game.BloxCord:Invoke. Access dashboard features like ranks, logbooks, points, sessions, webhooks, and more directly in-game. Every feature is exposed through a single [`BindableFunction`](https://create.roblox.com/docs/reference/engine/classes/BindableFunction) named `BloxCord`, parented to `game`. One entry point, one call signature, zero HTTP boilerplate. ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("methodName", arg1, arg2, ...) ``` The first argument to `:Invoke()` is always the **method name** (a string). The remaining arguments depend on the method and are documented per method in the [API Reference](/reference/ranking). ## What You Can Do Promote, demote, or move users through your group ranks. File warnings, suspensions, demotions, and more with full side effects. Read balances, award points, and pull reputation scores. Host, mark, strike, and progress sessions straight from in-game. Fire configured Discord webhook templates with dynamic data. Bundle up to 20 operations into a single request. ## Requirements The `BloxCord` object **only exists when the Org-Functions API is enabled** for your organization. If it is disabled in the dashboard, the object is never created and `game:WaitForChild("BloxCord")` will yield forever. Before you can use any method: The `BloxCord V3.0 Communications` script and its `BloxCordInternal` package must be present in `ServerScriptService`. Turn on **Org-Functions API** in your organization dashboard. This is the master switch for every method listed in this documentation. The `BloxCord` `BindableFunction` is created asynchronously at startup, so always resolve it with `game:WaitForChild("BloxCord")` rather than indexing `game.BloxCord` directly. ## A First Call Here's the simplest possible use of the API, fetching a player's permissions the moment they join. ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") game.Players.PlayerAdded:Connect(function(player) -- Fetch a player's permissions and print them local permissions = BloxCord:Invoke("getUserPermissions", player) print(player.Name, "has permissions:", permissions) end) ``` ## How It Works Most methods make a network round-trip to the BloxCord backend, so treat every call as **yielding**. Never call them inside tight loops or on the render step, and consider batching related work when you can. Wrap calls that touch the network in `task.spawn` if you need the caller to keep moving, and always check the response shape documented per method before assuming a value exists. # Activity Source: https://docs.bloxcord.net/api/reference/activity Read a user's tracked in-game minutes over a time range, optionally scoped to a place. BloxCord records tracked playtime for every member. These methods let your game read those totals in real time. ## getUserMinutes Returns a user's tracked minutes over a time range, optionally scoped to a single place. ```lua theme={null} local result = BloxCord:Invoke("getUserMinutes", userId, filters) ``` Batchable as the `minutes.get` op with args `{ userId, placeId, timeStart, timeEnd }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). ### Parameters The `UserId` whose minutes to fetch. Optional filters. Restrict the total to minutes earned on this specific place. Omit to count minutes across all of your organization's places. Start of the range, in **unix seconds** (inclusive). Defaults to `0` (the beginning of tracking). End of the range, in **unix seconds** (exclusive). Defaults to now. ### Returns A totals table, or `nil` if the request was rejected or the backend was unreachable. Total tracked minutes (including AFK). Minutes counted as AFK. Active minutes (`minutes` − `afk`). ### Examples ```lua This place, last 7 days theme={null} local BloxCord = game:WaitForChild("BloxCord") local now = os.time() local result = BloxCord:Invoke("getUserMinutes", player.UserId, { placeId = game.PlaceId, timeStart = now - (7 * 24 * 60 * 60), timeEnd = now, }) if result and result.active < 60 then print(player.Name .. " has under an hour of active playtime this week.") end ``` ```lua All places, all time theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("getUserMinutes", player.UserId, {}) if result then print(("%s: %d total, %d active"):format(player.Name, result.minutes, result.active)) end ``` *** ## getLeaderboard Returns a playtime leaderboard over a time range, optionally scoped to specific group ranks or a specific set of users. ```lua theme={null} local result = BloxCord:Invoke("getLeaderboard", filters) ``` Batchable as the `leaderboard.get` op with args `{ timeStart, timeEnd, includeAFK, ranks, userIds }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). ### Parameters Leaderboard options. Start of the range, in **unix seconds** (inclusive). End of the range, in **unix seconds** (exclusive). The range cannot exceed **5 years**. Whether AFK minutes count toward each member's score. Group ranks to include. Ignored when `userIds` is provided. Specific user ids to include. Takes precedence over `ranks`; the response contains exactly these members. ### Returns A leaderboard payload, or `nil` if the request was rejected (e.g. range over 5 years) or the backend was unreachable. Whether AFK minutes were counted. Number of rows returned. Ranked rows. Open (rank/all) queries return the top 100; explicit `userIds` queries return exactly the requested members. 1-based position in the returned list. The member's `UserId`. Their most recent group rank in the range. Total tracked minutes (including AFK). Minutes counted as AFK. Active minutes (`minutes` − `afk`). The scored value (`minutes` when `includeAFK`, else `active`). ### Example ```lua Top players by rank theme={null} local BloxCord = game:WaitForChild("BloxCord") -- Top active players over the last 30 days, limited to two ranks. local now = os.time() local result = BloxCord:Invoke("getLeaderboard", { timeStart = now - (30 * 24 * 60 * 60), timeEnd = now, includeAFK = false, ranks = { 100, 200 }, }) for _, row in ipairs(result and result.leaderboard or {}) do print(row.position, row.id, row.active .. " min") end ``` ```lua Compare a specific set of users theme={null} local BloxCord = game:WaitForChild("BloxCord") local now = os.time() local result = BloxCord:Invoke("getLeaderboard", { timeStart = now - (7 * 24 * 60 * 60), timeEnd = now, includeAFK = true, userIds = { "123456789", "987654321", "111111111" }, }) for _, row in ipairs(result and result.leaderboard or {}) do print(row.position, row.id, row.value .. " min") end ``` # Live Tables Source: https://docs.bloxcord.net/api/reference/live-tables Query and update BloxCord Live Tables (shared, dynamic data lists) from in-game. Live Tables are shared, dynamic data lists managed on the dashboard. Each **list** has an id and contains **items/rows**. Expired and deleted entries are never returned. All three methods are batchable via [`apiBatch`](/reference/webhooks-batch#apibatch): `liveTables.find` (args `{ item }`, result `{ rows }`), `liveTables.items` (args `{ list }`, result `{ items }`), and `liveTables.update` (args `{ id, description, custom_keys }`, result `{ success }`). ## getLiveTableRowsByName Finds all rows whose item name matches a given string, across lists. If you are searching for users, the name should be the user id as a string. ```lua theme={null} local rows = BloxCord:Invoke("getLiveTableRowsByName", itemName) ``` ### Parameters The item name to search for. ### Returns Matching rows. Empty if none match or the request failed. The id of the list the row belongs to. The row's unique id. The user/owner associated with the row. The item name. The row description. Arbitrary custom key/value data. Expiry timestamp (Unix **ms**), or null. Creation time (Unix **ms**). Last-modified time (Unix **ms**). ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local rows = BloxCord:Invoke("getLiveTableRowsByName", "VIP Pass") for _, row in ipairs(rows) do print(row.name, row.description) end ``` *** ## getLiveTableItemsById Returns all items belonging to a specific list. ```lua theme={null} local items = BloxCord:Invoke("getLiveTableItemsById", listId) ``` ### Parameters The id of the list to read. ### Returns The list's items. Same shape as the rows returned by [`getLiveTableRowsByName`](#getlivetablerowsbyname). Empty if the list is empty or the request failed. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local items = BloxCord:Invoke("getLiveTableItemsById", "warnlist") print("List has", #items, "items") ``` *** ## updateLiveTableItem Updates the description and/or custom keys of a single Live Table item. ```lua theme={null} local ok = BloxCord:Invoke("updateLiveTableItem", itemId, description, custom_keys) ``` Only the fields you provide are changed. Pass `nil` for `description` or `custom_keys` to leave that field untouched. ### Parameters The id of the item to update. New description. Only applied when a string is provided. New custom key/value data. Only applied when a table is provided. ### Returns `true` if the item was updated. `false` if the item was not found or the request failed. ### Examples ```lua Update both fields theme={null} local BloxCord = game:WaitForChild("BloxCord") local ok = BloxCord:Invoke("updateLiveTableItem", itemId, "Updated note", { strikes = 2, lastSeen = os.time(), }) ``` ```lua Update only custom keys theme={null} local BloxCord = game:WaitForChild("BloxCord") -- Pass nil for description to leave it unchanged. BloxCord:Invoke("updateLiveTableItem", itemId, nil, { strikes = 3 }) ``` # Logbook Source: https://docs.bloxcord.net/api/reference/logbook Create logbook entries, read a user's history, check rank locks, and attach comments. The logbook is BloxCord's moderation and administration record for each user. These methods let your game read and write it in real time. ## Locked & classified visibility Two fields control who can see a logbook entry: * **`locked`** — an array of **role ids** allowed to unlock the entry. * **`classified`** — an array of **role ids** allowed to view a classified entry. An **empty array** (`{}`) means no restriction. You provide these role ids when [creating an entry](#createlogbookentry), and [`getLogbookEntries`](#getlogbookentries) returns them back as arrays. Legacy entries created before role-scoped visibility stored a plain boolean. When such an entry is read, its `locked` / `classified` value is returned as the single-element array `{ "legacy_role" }` instead of a boolean. Lock and Classify are Enterprise items and should not be used in the lower tiers. ## Entry types The `type` you pass to [`createLogbookEntry`](#createlogbookentry) determines the entry's behaviour. Built-in types: | Type | Description | Supports expiry | Changes rank | | --------------- | ----------------------------------------------------- | --------------- | ------------ | | `comment` | A note on the user's record. | — | — | | `shrnote` | A senior-leadership note. | — | — | | `verbalwarning` | An informal verbal warning. | — | — | | `warning` | A formal staff warning / strike. | ✓ | — | | `mute` | Chat mute. | ✓ | — | | `toolban` | Blocks the user from using tools. | ✓ | — | | `tban` | Game ban. | ✓ | — | | `serverban` | Ban from a specific server. | ✓ | — | | `kick` | Kick from the user's current server. | — | — | | `modcallban` | Blocks the user from creating modcalls. | ✓ | — | | `rlock` | Rank lock — prevents the user from being ranked. | ✓ | — | | `suspension` | Suspends the user (moves them to the suspended rank). | ✓ | ✓ | | `demotion` | Demotes the user one rank. | — | ✓ | | `promotion` | Promotes the user. | — | ✓ | Your organization may also define **custom log types** in the dashboard. Pass their configured id as `type`. Rank-related and duration behaviour follows the custom type's configuration. ## createLogbookEntry Creates a new logbook entry (warning, ban, mute, rank lock, etc.) for a user. ```lua theme={null} local result = BloxCord:Invoke("createLogbookEntry", actor, target, opts) ``` ### Parameters Who is issuing the entry. See [the actor object](/api/concepts#the-actor-object). The user receiving the entry. Accepts a `Player` instance or a raw `UserId`. Entry options. The entry type — one of the [built-in types](#entry-types) (e.g. `"warning"`, `"tban"`, `"mute"`, `"rlock"`) or a custom type id. Human-readable reason for the entry. Optional for every type **except** `comment` and `shrnote`. Unix timestamp (**milliseconds**) at which the entry expires. Omit (or use a past value) for a permanent entry. Only meaningful for duration-based types. Machine ban — extends a `tban` to all of the user's accounts. Only valid on a **permanent** `tban`, and requires the Machine Bans module. Array of **role ids** permitted to view/unlock the entry. Omit or pass an empty array for no restriction. Array of **role ids** permitted to view the entry when classified. Omit or pass an empty array for no restriction. Optional array of rule ids to associate with the entry. ### Returns The created entry on success, or `nil` if the request was rejected or the backend was unreachable. `true` when the entry was created. The new entry's id (use it with [`revertLogbookEntry`](#revertlogbookentry)). The stored entry type. The user's new rank, for rank-changing types. The user's new role name, for rank-changing types. On failure, a human-readable reason. ### Examples ```lua Temporary mute theme={null} local BloxCord = game:WaitForChild("BloxCord") BloxCord:Invoke("createLogbookEntry", moderator, offender, { type = "mute", reason = "Spamming in chat", expiry = os.time() * 1000 + (7 * 24 * 60 * 60 * 1000), -- 7 days from now }) ``` ```lua Permanent game ban (all accounts) theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("createLogbookEntry", moderator, offender, { type = "tban", reason = "Exploiting", mban = true, -- machine ban: applies across the user's accounts (permanent only) }) if result and result.success then print("Banned, entry id:", result.id) end ``` ```lua Restricted-visibility warning theme={null} local BloxCord = game:WaitForChild("BloxCord") BloxCord:Invoke("createLogbookEntry", moderator, offender, { type = "warning", reason = "Insubordination", locked = { "role_seniorstaff", "role_hr" }, -- only these roles can view/unlock }) ``` *** ## revertLogbookEntry Reverts a logbook entry by id, undoing its effects: rank-changing entries (suspensions, demotions, promotions, and custom rank actions) rank the user back, machine bans are lifted, and comment / verbal warning / SHR note entries are deleted outright. Every other type is marked reverted and kept on record. ```lua theme={null} local result = BloxCord:Invoke("revertLogbookEntry", actor, target, opts) ``` Batchable as the `logbook.revert` op with args `{ userId, id, reason }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). ### Parameters Who is reverting the entry. See [the actor object](/api/concepts#the-actor-object). For rank-reverting entries the actor must outrank the rank being restored. The user the entry belongs to. Accepts a `Player` instance or a raw `UserId`. Revert options. The id of the logbook entry to revert (the `id` returned by [`createLogbookEntry`](#createlogbookentry) or [`getLogbookEntries`](#getlogbookentries)). Optional reason recorded with the revert. ### Returns The revert result, or `nil` if the request was rejected (entry not found, already reverted, locked, insufficient rank, etc.) or the backend was unreachable. `true` when the entry was reverted. The reverted entry's id. The entry type that was reverted. On failure, a human-readable reason. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local entries = BloxCord:Invoke("getLogbookEntries", offender.UserId, { type = "tban", active = true, }) if #entries > 0 then BloxCord:Invoke("revertLogbookEntry", moderator, offender, { id = entries[1].id, reason = "Appeal accepted", }) end ``` *** ## getLogbookEntries Fetches a user's logbook entries, optionally filtered by type and active state. ```lua theme={null} local entries = BloxCord:Invoke("getLogbookEntries", userId, filters) ``` Batchable as the `logbook.getEntries` op with args `{ userId, type, active }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). The op result is `{ entries = {...} }`. ### Parameters The `UserId` whose entries to fetch. Optional filters. Only return entries of this type (e.g. `"tban"`, `"rlock"`). When `true`, only return entries that are not reverted and not expired. ### Returns An array of logbook entries. Empty if none match or the request failed. Unique entry id. Entry type. Reason text. Target's rank at time of entry. Target's role at time of entry. New rank (for rank changes). New role (for rank changes). Duration, if applicable. Creation timestamp (ms). Expiry timestamp (ms), or null if permanent. Whether the entry was reverted. Array of role ids allowed to view/unlock the entry. Empty if unrestricted. Legacy entries return `{ "legacy_role" }`. Array of role ids allowed to view the classified entry. Empty if unrestricted. Legacy entries return `{ "legacy_role" }`. The actor who created the entry. The moderator's `UserId`. Their username. Their group rank at the time. Their role name at the time. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local activeBans = BloxCord:Invoke("getLogbookEntries", player.UserId, { type = "tban", active = true, }) if #activeBans > 0 then local ban = activeBans[1] if #ban.locked > 0 then print("Entry is locked to roles:", table.concat(ban.locked, ", ")) end player:Kick("You are banned: " .. ban.reason) end ``` *** ## checkranklock Convenience check for whether a user currently has an active **rank lock** (`rlock`) entry. Equivalent to calling [`getLogbookEntries`](#getlogbookentries) with `type = "rlock"` and `active = true` and testing for results. ```lua theme={null} local locked = BloxCord:Invoke("checkranklock", userId) ``` Batchable as the `logbook.checkRankLock` op with args `{ userId }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). The op result is `{ locked = boolean }`. ### Parameters The `UserId` to check. ### Returns `true` if the user has at least one active rank lock, otherwise `false`. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") if BloxCord:Invoke("checkranklock", targetUserId) then warn("Cannot rank this user — they are rank-locked.") return end ``` # Moderation Source: https://docs.bloxcord.net/api/reference/moderation Raise a moderator call (modcall) from in-game. ## modcall Raises a **moderator call** to notify staff on the dashboard that a player needs assistance. BloxCord automatically attaches the list of players standing near the caller (within 15 studs). ```lua theme={null} local ok = BloxCord:Invoke("modcall", player, reason) ``` This method is rate-limited and gated: * **10-minute cooldown** per player between successful calls. * The `reason` must be **256 characters or fewer**. * Modcalls must be **enabled** for your organization, and the caller must not have an active `modcallban` logbook entry. ### Parameters The player raising the call. Used as the caller and as the center point for the nearby-players scan. Why the call is being raised. Maximum 256 characters. ### Returns `true` if the call was raised. `false` if the player is still on cooldown, the reason exceeds 256 characters, or the call was otherwise rejected. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local function requestHelp(player) local ok = BloxCord:Invoke("modcall", player, "Exploiter in the lobby") if ok then player:SetAttribute("ModcallSent", true) else warn("Modcall rejected — likely on cooldown.") end end ``` *** ## pushCommandLog Records that a staff member ran an admin command. This is a **local, buffered** call — entries are queued and uploaded with the next server report, so it returns instantly without a network round-trip. ```lua theme={null} local ok = BloxCord:Invoke("pushCommandLog", actor, target, command, vanity) ``` ### Parameters The player who ran the command. Its `UserId` and `Name` are recorded. The player the command targeted, if any. Omit for commands with no target. The command string that was executed. An optional display/vanity label for the command. ### Returns Always `true` — the entry is buffered locally and flushed on the next report. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") BloxCord:Invoke("pushCommandLog", staff, targetPlayer, ":kick BadActor spamming", "Kick") ``` # Points & Reputation Source: https://docs.bloxcord.net/api/reference/points Read and update a user's points balance and read their reputation. ## getUserPoints Returns a user's current points balance. ```lua theme={null} local balance = BloxCord:Invoke("getUserPoints", actor, target) ``` ### Parameters The entity requesting the balance. See [the actor object](/api/concepts#the-actor-object). The user whose balance to read. Accepts a `Player` instance or a raw `UserId`. ### Returns The user's points balance, or `nil` if the request failed or the backend was unreachable. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local balance = BloxCord:Invoke("getUserPoints", requester, player) if balance then print(player.Name .. " has " .. balance .. " points") end ``` *** ## updateUserPoints Adds to (or subtracts from) a user's points balance. ```lua theme={null} local result = BloxCord:Invoke("updateUserPoints", actor, target, amount, reason, category) ``` ### Parameters Who is granting/removing the points. See [the actor object](/api/concepts#the-actor-object). The user whose balance to change. Accepts a `Player` instance or a raw `UserId`. A non-zero integer to apply. Positive awards points; negative deducts them. The magnitude cannot exceed **1,000,000** per call. Optional reason recorded with the transaction (shown in the points history). Optional category to group the transaction under. One of `"manual"`, `"system"`, `"event"`, or `"adjustment"`. Any other value falls back to `"manual"`. ### Returns The transaction result on success, or `nil` if the request was rejected (e.g. a zero or out-of-range amount) or the backend was unreachable. `true` when the transaction was applied. The affected user's `UserId`. The signed amount that was applied. The user's new balance after the change. ### Examples ```lua Award points theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("updateUserPoints", host, player, 10, "Attended training", "event") if result and result.success then print(player.Name .. " now has " .. result.balance .. " points") end ``` ```lua Deduct points theme={null} local BloxCord = game:WaitForChild("BloxCord") -- Negative amount removes points. BloxCord:Invoke("updateUserPoints", host, player, -5, "No-show penalty", "adjustment") ``` *** ## getReputation Returns a user's reputation record. ```lua theme={null} local reputation = BloxCord:Invoke("getReputation", actor, target) ``` ### Parameters The entity requesting the reputation. See [the actor object](/api/concepts#the-actor-object). The user whose reputation to read. Accepts a `Player` instance or a raw `UserId`. ### Returns The user's reputation summary on success, or `nil` on failure. The user's `UserId`. The user's net reputation total (can be negative). How many individual reputation entries the user has received. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local rep = BloxCord:Invoke("getReputation", requester, player) if rep then print(("%s: %d reputation across %d entries"):format(player.Name, rep.reputation, rep.count)) end ``` # Profiles Source: https://docs.bloxcord.net/api/reference/profiles Read a member's BloxCord profile and their departments. These methods surface a member's BloxCord profile and the departments they belong to, so your game can display or gate on them in real time. ## getUserProfile Returns a member's profile: their About Me, pronouns, reputation total, the 10 most recent reputations, and whether it is currently their birthday. ```lua theme={null} local profile = BloxCord:Invoke("getUserProfile", userId) ``` Batchable as the `user.getProfile` op with args `{ userId }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). Requires the **Profiles** module; the reputation fields also require the **Reputations** module. ### Parameters The `UserId` whose profile to fetch. ### Returns The profile payload, or `nil` if the request was rejected (e.g. the Profiles module is disabled) or the backend was unreachable. The member's `UserId`. Whether the member has hidden their profile. When `true`, `aboutme`, `pronouns`, `pronounsRaw`, and `birthday` are withheld. The member's About Me text. Display pronouns. The raw pronoun selection. Whether the Reputations module is enabled. The member's total reputation. Up to the 10 most recent reputations received. `{ id, username }` of who gave it. The reputation amount. The attached comment, if any. When it was given (ms). `true` when it is currently the member's birthday, evaluated at local midnight using their last-seen timezone offset. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local profile = BloxCord:Invoke("getUserProfile", player.UserId) if profile then if profile.birthday then print("It's " .. player.Name .. "'s birthday!") end print(player.Name .. " has " .. profile.reputation .. " reputation.") end ``` *** ## getUserDepartments Returns the distinct departments (with color) of a member's assigned roles. ```lua theme={null} local departments = BloxCord:Invoke("getUserDepartments", userId) ``` Batchable as the `user.getDepartments` op with args `{ userId }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). The op result is `{ departments = {...} }`. ### Parameters The `UserId` whose departments to fetch. ### Returns An array of the member's departments. Empty if none (or the member is not in the organization). The department name. The department's role color, if set. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local departments = BloxCord:Invoke("getUserDepartments", player.UserId) for _, dept in ipairs(departments) do print(player.Name .. " is in " .. dept.name) end ``` # Ranking & Permissions Source: https://docs.bloxcord.net/api/reference/ranking-permissions Change a user's group rank and read their BloxCord permissions. ## setRank Changes a user's rank in your Roblox group. The change is applied through BloxCord and recorded in your audit log, attributed to the acting user. ```lua theme={null} local ok = BloxCord:Invoke("setRank", userId, reason, rank, actor) ``` **Authority rules.** Unless the actor is the organization owner, they cannot rank a user who is at or above their own rank, and cannot assign a rank at or above their own. Ranks above the organization's configured maximum rankable rank are also rejected. When a rule blocks the change, the method returns `false`. ### Parameters The `UserId` of the user whose rank will change. The reason recorded in the audit log for the rank change. The target group rank — the **rank number** (0–255), not the role name. It must correspond to an existing role in your group. Who is performing the change. See [the actor object](/api/concepts#the-actor-object). ### Returns `true` if the rank change was accepted and applied. `false` if a rule blocked it (see authority rules above), the target rank does not exist, or the backend was unreachable. ### Examples ```lua Promote an in-server player theme={null} local BloxCord = game:WaitForChild("BloxCord") local ok = BloxCord:Invoke("setRank", 123456789, "Field promotion", 5, actingPlayer) if ok then print("Promoted") else warn("Promotion failed or was not permitted") end ``` ```lua Set a specific rank with a table actor theme={null} local BloxCord = game:WaitForChild("BloxCord") -- Actor is not in the server, so describe them with a table. local ok = BloxCord:Invoke("setRank", 123456789, "Automated demotion", 2, { id = 987654321, username = "HR_System", rank = 254, role = "HR Director", }) ``` *** ## getUserPermissions Returns the list of BloxCord permission strings a **player currently in the server** holds, based on their roles and group rank. Results are cached per player for the duration of their session. ```lua theme={null} local permissions = BloxCord:Invoke("getUserPermissions", player) ``` Unlike most methods, this takes a live `Player` instance (not a `UserId`), because it caches the result against the player. Batchable as the `permissions.get` op with args `{ userId, rank }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). The op result is `{ permissions = {...} }` (uncached). ### Parameters The player whose permissions to fetch. Must be an in-server `Player` instance. ### Returns An array of permission identifiers the player holds. May be empty if the player has no special permissions. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local function canModerate(player) local permissions = BloxCord:Invoke("getUserPermissions", player) for _, perm in ipairs(permissions or {}) do if perm == "moderation.kick" then -- You need to get the true permission strings via the dashboard network tab, unless they have been added to docs. return true end end return false end ``` *** ## getUserRoles Returns the BloxCord **dashboard roles** a **player currently in the server** holds, resolved from their manually-assigned roles plus any rank-bound roles their group rank qualifies for (bind-managed roles they don't qualify for are excluded). Results are cached per player for the duration of their session. Discord binds on BC roles are not resolved here due to Discord API limits. ```lua theme={null} local roles = BloxCord:Invoke("getUserRoles", player) ``` Unlike most methods, this takes a live `Player` instance (not a `UserId`), because it caches the result against the player. Batchable as the `roles.get` op with args `{ userId, rank }` — see [`apiBatch`](/reference/webhooks-batch#apibatch). The op result is `{ roles = {...} }` (uncached). The `rank` is the user's group rank, used to resolve rank-bound roles. ### Parameters The player whose roles to fetch. Must be an in-server `Player` instance. ### Returns An array of the dashboard roles the player holds. May be empty. The role id. The role's display name. The role color, if set. The role's department, if set. Whether the role is rank-bound (auto-assigned by group rank). ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local roles = BloxCord:Invoke("getUserRoles", player) for _, role in ipairs(roles or {}) do print(player.Name .. " has role: " .. (role.name or role.id)) end ``` # Sessions Source: https://docs.bloxcord.net/api/reference/sessions Host and manage BloxCord training/session events from in-game. Session methods let a host start and run a session (training, raid, shift, tryout, etc.) end to end from inside your experience — recruiting administration, marking attendees, running phases, issuing strikes, and closing the session out. Every session method takes an **actor** as the first argument (the person acting, almost always the host) and, for writes, an **opts** table as the second. A session is identified by its **session id** (`sid`) — a string that starts with `s`, returned when you [start a session](#startsession). Pass that same `sid` to every subsequent session method. ### Session lifecycle A session moves through a fixed set of states. You advance it with [`sessionUpdateSession`](#sessionupdatesession). | State | Meaning | | ----------- | ----------------------------------------------------------------------- | | `awaiting` | Created and gathering administration/attendees; phases not yet running. | | `active` | Running. Attendees can be marked and phases started/stopped. | | `ending` | Wrapping up (e.g. grading). Marks can still be adjusted. | | `ended` | Closed and finalized. No further edits. | | `cancelled` | Called off. Can be reached from any non-final state. | ### Phases Each session has an ordered list of **phases**, each with a stable `id` and a `name`. A phase is either a work phase (`kind: "phase"` — one you start and stop, and mark attendees against) or an outcome marker (`kind: "outcome"`). Attendee pass/fail marks are keyed by phase `id` (see `cells` on an attendee), so a phase can be renamed without losing its marks. ## getSessionReservations Returns the upcoming reserved/scheduled session slots for your organization — useful for showing hosts what they can pick up right now. To host one, pass its `rid` as the `mode` to [`startSession`](#startsession). ```lua theme={null} local reservations = BloxCord:Invoke("getSessionReservations", actor) ``` ### Parameters The requesting host. See [the actor object](/api/concepts#the-actor-object). ### Returns An array of reservation records, soonest first. Empty if there are none or the request failed. The reservation id. Pass this as `mode` to [`startSession`](#startsession) to host it. The session type id this slot is for. The human-readable session type name. The scheduled start time (Unix epoch **milliseconds**). Either `"open"` (anyone eligible may host) or `"reserved"` (locked to a specific host). Whether this is an exclusive slot (blocks other sessions scheduled too close to it). `{ id, username }` of the host it is reserved for, or `null` when open. An optional note attached to the reservation. `true` when the slot is within its hostable window right now. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local reservations = BloxCord:Invoke("getSessionReservations", host) for _, r in ipairs(reservations or {}) do if r.hostableNow then print(("%s at %d (%s)"):format(r.typeName or r.sessionType, r.time, r.status)) end end ``` *** ## getSession Fetches the full record of a single session by id — its phases, administration (including the host), attendees with their per-phase marks and strikes, the phases that have been started/ended, the scheduled time, and a summary once it has ended. ```lua theme={null} local session = BloxCord:Invoke("getSession", actor, sessionId) ``` ### Parameters The requesting user. See [the actor object](/api/concepts#the-actor-object). The session's `sid` (e.g. `"s5f3a1c9d2e4b6a8c"`). ### Returns The full session record, or `nil` if the session was not found or the request failed. The session id. The session's display name. The session type id. Lifecycle state — one of `awaiting`, `active`, `ending`, `ended`, `cancelled`. Whether the session counts toward competitive scoring. Whether it holds an exclusive time slot. The scheduled start time (Unix epoch milliseconds), or `null` for a purely on-demand session. When the session was created (ms). When it entered `active` (ms), or `null`. When it closed (ms), or `null`. Ordered phases. Stable phase id (starts with `p`). Phase name. `"phase"` (a startable/markable phase) or `"outcome"` (a result marker). Zero-based position in the list. Admin roster, including the host. `"host"` or a role key from the session type. The member's `UserId`. Their username. Their group rank. Their role name. The attendee roster. The attendee's `UserId`. Their username. Their group rank at join time. Map of phase `id` → `boolean` pass/fail mark. Strikes as `{ id, reason, by, time }`. When they were added (ms). Phase start/end marks as `{ phaseId, type: "start" | "end", time, by }`. The final summary once the session has ended, otherwise `null`. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local session = BloxCord:Invoke("getSession", host, "s5f3a1c9d2e4b6a8c") if session then print(("%s — %s, %d attendee(s)"):format(session.name, session.state, #session.attendees)) -- Count who passed the first work phase. local firstPhase = session.phases[1] if firstPhase then local passed = 0 for _, a in ipairs(session.attendees) do if a.cells[firstPhase.id] then passed = passed + 1 end end print(passed .. " passed " .. firstPhase.name) end end ``` *** ## getRunningServers Returns your organization's currently-running game servers, the players in each (with their ranks), and any ongoing sessions taking place in them. ```lua theme={null} local servers = BloxCord:Invoke("getRunningServers", actor) ``` ### Parameters The requesting user. See [the actor object](/api/concepts#the-actor-object). ### Returns An array of running servers. Empty if none are active or the request failed. The server id, formatted as `placeId_jobId` (e.g. `"606849621_9a8b..."`). The place id. The Roblox job id (matches `game.JobId`). When the server last reported in (Unix epoch milliseconds). Number of players currently present. Present players. The player's `UserId`. Their username. Their group rank. Ongoing sessions in this server. The session id. The session name. Lifecycle state. `{ userId, username }` of the host. Admin slots as `{ slotType, id, username, rank, role }`. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") for _, server in ipairs(BloxCord:Invoke("getRunningServers", host) or {}) do print(("%s — %d player(s), %d session(s)"):format( server.serverId, server.playerCount, #server.sessions)) end ``` *** ## startSession Starts hosting a session in the **current** server. The actor becomes the host, and must meet the host requirements configured for the chosen session type. You can host on demand (right now) or pick up a scheduled reservation returned by [`getSessionReservations`](#getsessionreservations). ```lua theme={null} local result = BloxCord:Invoke("startSession", actor, opts) ``` ### Parameters The host starting the session. See [the actor object](/api/concepts#the-actor-object). Session options. The id of the session type to host (as configured in your dashboard, e.g. `"training"` or `"raid"`). Either `"on-demand"` to start immediately, or a reservation `rid` (from [`getSessionReservations`](#getsessionreservations)) to host that scheduled slot. The session's start time as a Unix epoch **milliseconds** value. Optional for on-demand sessions (defaults to now); ignored when hosting a reservation (the reservation's time is used). Request an exclusive time slot (blocks other sessions scheduled too close). Only granted if the actor has permission to schedule exclusive sessions; otherwise silently ignored. Co-administration to add alongside the host. Each entry fills one role slot defined by the session type, and each member must qualify for that role. The member's `UserId`. The session type role slot to fill (e.g. `"co_host"`, `"supervisor"`). The member's group rank (used to validate they qualify for the role). The member's username, for display. ### Returns The result of the host attempt, or `nil` if the request failed or the backend was unreachable. `true` when the session was created. The new session id (present on success). Use it for every follow-up call. The initial state (`"awaiting"`). On failure, a human-readable reason (e.g. not qualified to host, server already has a session). ### Examples ```lua On-demand theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("startSession", host, { typeId = "training", mode = "on-demand", exclusive = false, administration = { { id = 123456789, roleKey = "co_host", rank = 200, username = "Builderman" }, { id = 987654321, roleKey = "supervisor", rank = 250, username = "Shedletsky" }, }, }) if result and result.success then local sid = result.sid print("Hosting session", sid) else warn("Could not host:", result and result.message or "request failed") end ``` ```lua From a reservation theme={null} local BloxCord = game:WaitForChild("BloxCord") local reservations = BloxCord:Invoke("getSessionReservations", host) local slot = reservations and reservations[1] if slot and slot.hostableNow then local result = BloxCord:Invoke("startSession", host, { typeId = slot.sessionType, mode = slot.rid, -- host this specific reservation }) print(result and result.sid) end ``` *** ## sessionUpdateAttendees Adds or removes attendees on a running session. You can add and remove in the same call. Duplicate, invalid, or already-present ids (and anyone in administration) are skipped automatically. ```lua theme={null} local result = BloxCord:Invoke("sessionUpdateAttendees", actor, opts) ``` ### Parameters The administrator performing the update. See [the actor object](/api/concepts#the-actor-object). The session id. Attendees to add (up to 60 per call). The attendee's `UserId`. Their username, for display. Their group rank. An array of `UserId`s to remove (e.g. `{ 111, 222 }`). ### Returns `true` when at least one change was applied. How many attendees were added. How many attendees were removed. On failure, the reason (e.g. attendees locked after phases begin). ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("sessionUpdateAttendees", host, { sid = sid, add = { { id = 111111111, username = "trainee_a", rank = 10 }, { id = 222222222, username = "trainee_b", rank = 10 }, }, remove = { 333333333 }, }) if result and result.success then print(("Added %d, removed %d"):format(result.added, result.removed)) end ``` *** ## sessionUpdateMark Sets or clears a single attendee's pass/fail mark for a work phase (e.g. ticking them off for passing a checkpoint). The phase must already be started. ```lua theme={null} local result = BloxCord:Invoke("sessionUpdateMark", actor, opts) ``` ### Parameters The administrator performing the mark. See [the actor object](/api/concepts#the-actor-object). The session id. The attendee's `UserId`. The phase `id` to mark (from the session's `phases`). `true` to mark as passed, `false` to clear the mark. ### Returns `true` when the mark was applied. On failure, the reason (e.g. phase not started, unknown attendee). ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") -- Mark trainee 111 as passing phase "p1a2b3c4". BloxCord:Invoke("sessionUpdateMark", host, { sid = sid, attendeeId = 111111111, phaseId = "p1a2b3c4", value = true, }) ``` *** ## sessionUpdateStrike Adds a strike against an attendee (with a reason) or removes an existing one. ```lua theme={null} local result = BloxCord:Invoke("sessionUpdateStrike", actor, opts) ``` ### Parameters The administrator issuing/removing the strike. See [the actor object](/api/concepts#the-actor-object). The session id. The attendee's `UserId`. Either `"add"` or `"remove"`. The reason for the strike. **Required when adding**; up to 300 characters. The id of the strike to remove. **Required when removing** (available as `strike.id` from the add result or an attendee's `strikes`). ### Returns `true` on success. The created strike `{ id, reason, by, time }` (only when adding). On failure, the reason (e.g. missing reason, strike not found). ### Examples ```lua Add a strike theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("sessionUpdateStrike", host, { sid = sid, attendeeId = 111111111, action = "add", reason = "Left the formation without permission", }) local strikeId = result and result.strike and result.strike.id ``` ```lua Remove a strike theme={null} local BloxCord = game:WaitForChild("BloxCord") BloxCord:Invoke("sessionUpdateStrike", host, { sid = sid, attendeeId = 111111111, action = "remove", strikeId = strikeId, }) ``` *** ## sessionUpdatePhase Controls a session's phases. Use it to **start**/**stop** a work phase during the session, or to **add**/**rename**/**delete** phases. ```lua theme={null} local result = BloxCord:Invoke("sessionUpdatePhase", actor, opts) ``` Only one work phase can be running at a time — end the current phase before starting the next. Outcome markers cannot be deleted. ### Parameters The administrator performing the action. See [the actor object](/api/concepts#the-actor-object). The session id. One of: * `"start"` — begin a work phase * `"stop"` — end the currently-running work phase * `"add"` — add a new phase * `"rename"` — rename a phase * `"delete"` — remove a phase The target phase `id`. Required for `start`, `stop`, `rename`, and `delete`. The phase name. Required for `add` and `rename`. ### Returns `true` on success. The created phase `{ id, name, kind, order }` (only for `add`). The new name (only for `rename`). On failure, the reason (e.g. a phase is already running). ### Examples ```lua Start then stop a phase theme={null} local BloxCord = game:WaitForChild("BloxCord") BloxCord:Invoke("sessionUpdatePhase", host, { sid = sid, action = "start", phaseId = "p1a2b3c4" }) -- ... run the phase, mark attendees ... BloxCord:Invoke("sessionUpdatePhase", host, { sid = sid, action = "stop", phaseId = "p1a2b3c4" }) ``` ```lua Add, rename, delete theme={null} local BloxCord = game:WaitForChild("BloxCord") local added = BloxCord:Invoke("sessionUpdatePhase", host, { sid = sid, action = "add", name = "Obstacle Course" }) local newPhaseId = added and added.phase and added.phase.id BloxCord:Invoke("sessionUpdatePhase", host, { sid = sid, action = "rename", phaseId = newPhaseId, name = "Final Course" }) BloxCord:Invoke("sessionUpdatePhase", host, { sid = sid, action = "delete", phaseId = newPhaseId }) ``` *** ## sessionUpdateSession Advances the session through its [lifecycle](#session-lifecycle) — activating it, moving it to ending, closing it out, or cancelling it. ```lua theme={null} local result = BloxCord:Invoke("sessionUpdateSession", actor, opts) ``` ### Parameters The administrator performing the transition. See [the actor object](/api/concepts#the-actor-object). The session id. The target state. Transitions are ordered: * `"active"` — from `awaiting` * `"ending"` — from `active` * `"ended"` — from `ending` * `"cancelled"` — from any non-final state An optional reason, recorded with the transition. ### Returns `true` when the transition was applied. On failure, the reason (e.g. an invalid transition for the current state). ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") -- A full run: activate, begin wrap-up, then close out. BloxCord:Invoke("sessionUpdateSession", host, { sid = sid, to = "active" }) BloxCord:Invoke("sessionUpdateSession", host, { sid = sid, to = "ending" }) BloxCord:Invoke("sessionUpdateSession", host, { sid = sid, to = "ended", reason = "Training complete", }) ``` # Webhooks & Batch Source: https://docs.bloxcord.net/api/reference/webhooks Fire configured webhook templates and run multiple operations in a single call. ## fireWebhook Fires a webhook using a template configured on the dashboard, optionally passing data to populate it. ```lua theme={null} local result = BloxCord:Invoke("fireWebhook", actor, templateId, data, wait) ``` ### Parameters Who is firing the webhook. See [the actor object](/api/concepts#the-actor-object). The id of the webhook template to fire. Key/value data used to populate the template's placeholders. Pass an empty table `{}` if the template needs no data. Values can be strings, numbers, or nested tables, matching the placeholders configured on the template. When `true`, waits for the message to be delivered before returning (so you can read back the `messageId`). When `false`, the call returns as soon as the request is accepted. ### Returns The delivery result on success, or `nil` if the request was rejected or the backend was unreachable. `true` when the webhook was accepted/sent. The template that was fired. The delivered message id (present when `wait` is `true`). Any non-fatal warnings raised while rendering/sending. On failure, `true` if the template is currently disabled. On failure, a human-readable reason. ### Examples ```lua Fire and forget theme={null} local BloxCord = game:WaitForChild("BloxCord") BloxCord:Invoke("fireWebhook", host, "shift-started", { host = host.Name, players = #game.Players:GetPlayers(), }) ``` ```lua Wait for delivery theme={null} local BloxCord = game:WaitForChild("BloxCord") local result = BloxCord:Invoke("fireWebhook", host, "raid-result", { outcome = "Victory", duration = "42 minutes", }, true) if result and result.success then print("Sent message:", result.messageId) end ``` *** ## apiBatch Runs multiple operations in a single request. All operations share one actor and are executed sequentially on the backend. This is the most efficient way to perform several writes at once. ```lua theme={null} local results = BloxCord:Invoke("apiBatch", actor, operations) ``` A batch may contain at most **20 operations**. Duplicate operations within the same batch are rejected. Each operation's `args` payload is capped at 24 KB. ### Parameters The actor applied to every operation in the batch. See [the actor object](/api/concepts#the-actor-object). An array of operation objects to execute in order. The operation name. Allowed values: `setRank`, `logbook.create`, `logbook.revert`, `logbook.getEntries`, `logbook.checkRankLock`, `permissions.get`, `minutes.get`, `leaderboard.get`, `user.getDepartments`, `user.getProfile`, `roles.get`, `liveTables.find`, `liveTables.items`, `liveTables.update`, `points.get`, `points.update`, `reputation.get`, `webhook.fire`, `session.getReservations`, `session.getSession`, `session.startHosting`, `session.updateAttendees`, `session.updateMark`, `session.updateStrike`, `session.updatePhase`, `session.updateSession`, `servers.getRunning`. The arguments for that operation. ### Returns The per-operation results, in the same order as `operations`. A failed individual operation yields `{ error = "message" }` in its slot. `nil` if the whole batch was rejected or the backend was unreachable. ### Example ```lua theme={null} local BloxCord = game:WaitForChild("BloxCord") local results = BloxCord:Invoke("apiBatch", host, { { op = "points.update", args = { userId = "123456789", amount = 5, reason = "Attendance" }, }, { op = "logbook.create", args = { userId = "123456789", type = "warning", reason = "Late" }, }, }) ``` # Creating Your Organization Source: https://docs.bloxcord.net/creating-your-organization Bring your Roblox community to BloxCord in three simple steps: create an organization, connect your Roblox group, and install the in-game SDK. Once your account is linked, your organizations will appear on the home screen, where you can also create a new one using the plus button. BloxCord home screen with add organization button ## Before You Start To prevent unauthorized users from claiming a community, we run a few eligibility checks before letting you create an organization. Your rank in the Roblox group must be **ID 253 or higher**. The community can't already exist as an organization on BloxCord. Add your organization flow: paste group link and confirm Paste your Roblox group link or ID. We'll pull the group details and, if you're eligible, you'll see a green confirmation with a **Create organization** button. If an **unauthorized user** has created an organization for your community, please [**contact us**](#need-a-hand), preferably through our **Discord server**, and our team will assist you. We may ask for additional information to **verify that you are the rightful owner** of the Roblox community. ## The Four-Step Setup After you claim the community, we walk you through four quick steps before opening up your dashboard. Head to the [Roblox Creator Hub](https://create.roblox.com/dashboard/credentials) and create an API key **under your user**. BloxCord guides you through the exact permissions to enable so we only request what we need, nothing more. Next we make sure the BloxCord SDK is installed in your experience. Most of the time it isn't yet, so we walk you through it. Install BloxCord in your game step Click **Download the Script**, follow the instructions to add it to `ServerScriptService`, and enable `HttpService` and `LoadstringEnabled`. Your **Place ID** is the number in your game's URL. For example, in `https://www.roblox.com/games/3421472751/Stateview-Prison`, the Place ID is `3421472751`. To verify the connection, **join your game** and ensure it has been published. Restart your server to ensure you're running the latest version, then join the game. It may take a few moments for BloxCord to detect the connection. ## Need a hand? If anything goes sideways during setup, we're here to help. Reach out to our team directly. Get real-time help from the community and our staff. # Forms Source: https://docs.bloxcord.net/forms Your workflow doesn't end with reports. Create forms, collect responses, and analyze the results, all without leaving BloxCord. Forms must be enabled before forms can be created, submitted, or managed. Visit the Features tab to get started. Forms dashboard showing a published form with question count, response count, and quick action buttons ## Build At Ease, See Responses At Ease Build forms your way. Add multiple choice, checkboxes, text, linear scales, dropdowns, and more, then publish in seconds. Responses stream in with live summaries and per-question insights, no spreadsheets required. Form builder with tabs for Build, Responses, Summary, Settings, and Access Add questions, choose types, mark them required. Every change autosaves. Review individual submissions and export when you need the raw data. Live aggregate view of every question, updated as responses come in. Publishing, quiz mode, respondent requirements, and analytics toggles. ## Configure Every Detail Tune each form to fit exactly how you want it to behave. Toggle **Published** to open or close the form, flip **Accepting responses** to stop new submissions without unpublishing, and share the **Public link** with respondents. Auto-score submissions. Mark correct answers on choice questions and assign point values, then let responses grade themselves as they roll in. Flip on **Require login** to force respondents to sign in with BloxCord before they can submit. Optionally collect respondent country and age group to enrich your results. Enable correlation insights to discover how different demographics and segments respond to each question. Customize what respondents see the moment they hit submit. Permanently delete the form and every response submitted to it. This one is final. ## Permissions That Fit Your Workflow Decide exactly who can view, respond to, edit, configure, or analyze each form. Grant permissions to individual members or roles, while form owners and organization form administrators always retain full access. Access control tab with role and user grant options Change the form itself, questions, options, and structure. View and export individual submissions. See the aggregate analytics and summary. Manage settings and access grants. # Leaderboard Source: https://docs.bloxcord.net/leaderboard The Leaderboard is where activity gets its recognition. Once your organization is linked to your game, instantly see who's putting in the most time across your organization. Filter by rank, choose a time period, and include or exclude AFK minutes to get the insights you need. Guest Features and Gameservers must be configured before activity can be tracked and displayed. Visit the Features tab to get started. Leaderboard page Focus on a single rank to compare activity among members at the same level. This week, this month, or the last three months. Choose your time period and compare activity over time. Include or exclude AFK minutes for a truer picture of active playtime. Every row is a live link. Tap any member to jump into their full activity history. # Linking Your Account Source: https://docs.bloxcord.net/linking-your-account Sign in to BloxCord by securely connecting your Discord and Roblox accounts. Once linked, you'll have access to your organizations, profile, and everything BloxCord has to offer. ## Step 1: Go to the BloxCord app Head to [app.bloxcord.net](https://app.bloxcord.net/) in your browser. You'll be greeted by the login screen. BloxCord login screen ## Step 2: Link your account If you don't have an account linked yet, click **Link** or the **+** button on the login screen. This starts the OAuth2 flow. Sign in to Discord and authorize BloxCord to access your account. This is how we identify you across servers. Next, sign in to Roblox and authorize BloxCord. This links your Roblox identity to your Discord account. If you have multiple Roblox accounts linked, pick the one you want to use. You can link multiple Roblox accounts to a single Discord account and switch between them any time from the login screen. ## Step 3: Access your organizations Once linked, you'll be taken to the **Organizations** screen. Here you'll see every organization you own or belong to, ready to manage. You're all set. Head into an organization to start using BloxCord. ## Troubleshooting Make sure the Roblox account you linked is a member of the group tied to that organization. You can add another Roblox account from the login screen using the **+** button. Disable browser extensions that block third-party cookies or popups, then try again. If the issue persists, reach out in our Discord. Ensure you have linked the correct Discord and/or Roblox account. If the wrong account is linked, your roles may not be assigned or your account may not link properly. # Live Tables Source: https://docs.bloxcord.net/live-tables Why go in-game to make simple changes? Live Tables let you grant, revoke, and manage game data directly from your BloxCord dashboard. Live Tables must be enabled before shared tables can be viewed or managed. Visit the Features tab to get started. Live Tables do not connect directly to Roblox DataStores. To fetch or update Live Table data in-game, use the BloxCord API methods available in the [Live Tables reference](/api/reference/live-tables). Live Tables Organize your lists however you want, item givers, permission grants, custom overheads, you name it. Control exactly who can view, edit, or manage each list. Different lists, different access levels. See who added, edited, or removed every single entry. Complete accountability, always. ## Set Expiry Dates on Anything Temporary permissions? Trial weapons? Time-limited access? Just set an expiration date and let BloxCord handle the rest. When time runs out, the entry is automatically removed. ## Flexible Data Types Everything starts with a key. Whether you're storing users, strings, numbers, or something custom, Live Tables adapt to your data. # Live View Source: https://docs.bloxcord.net/live-view Live View gives you a real-time overview of your organization. Monitor active sessions, game servers, and logbook activity as everything happens. Image ## Sessions View ongoing and upcoming sessions at a glance. Live sessions and those starting soon are posted, so you never miss what's happening. See what's running right now, who's hosting, and how many are attending. Know what's scheduled next so you're never caught off guard. ## Running Servers View every active server, exactly how many staff are inside, and jump in with a single click. No hunting through Roblox, no server hopping. Just pick one and go. See who's in each server with real-time avatars and counts. Teleport straight into any running server without leaving the dashboard. ## Recent Logbook See who performed each action, what authority they used, which rule was applied, and how long the action lasts when applicable. Color-coded entries make warnings, bans, and other moderation actions easy to identify at a glance. Moderator, action, target, and reason all in one clean row. Warnings, tool bans, and full bans each stand out with their own color. Timed punishments show length right alongside the reason. The freshest actions rise to the top so you always see what just happened. # Leave of Absence Source: https://docs.bloxcord.net/loa Life doesn't stop for your organization. Whether it's vacations, exams, burnout, or simply needing a break, BloxCord makes requesting leave effortless for members and managing it effortless for administrators. Leave of Absence must be enabled before leave requests can be submitted, reviewed, or managed. Visit the Features tab to get started. Personal Leave of Absence view showing user's own active, pending, and past leaves Always know where you stand. Members can track every leave request from submission to decision, eliminating the need to chase administrators for updates. A clean, guided form with dates and a reason. That's it. Pending, approved, denied, or active. Members always know exactly where they stand. ## Active Leave at a Glance See everyone currently on leave, who's leaving soon, who's recently returned, and get a real-time snapshot of staffing across your organization. Leave of Absence overview showing active leaves, pending requests, and history ## Manage Every Request in One Place No more searching. Every leave request is automatically organized into one dashboard, making approvals and reviews fast and effortless. Manage LOA requests dashboard with approve, deny, and detail views Review the reason, dates, and requester in one view. Make the call with a single click. Every approved, denied, and expired leave stays on the record so you always know who was away and when. See who is currently on leave at a glance, along with when they're expected back. Only the roles you trust can review or decide on leave requests. Everyone else stays out. # Members Source: https://docs.bloxcord.net/members Browse everyone in your organization and manage them with a single right-click. Members tab with right-click context menu open on a member Type a username or paste a Discord ID to instantly narrow down the list. Only see members with a specific role, perfect for staff-only views. Every member in your organization is loaded and browsable, page by page. See at a glance when each member was last active. ## Right-Click to Take Action Right-click any member card to open the quick-action menu. Update a member's roles without leaving the page. Jump straight to their full dashboard profile. Pull up their full Player Audit in one click. Remove a member from your organization when needed. Grab their exact username for pasting anywhere. Copy their numeric Roblox ID in a single click. # ModCalls Source: https://docs.bloxcord.net/modcalls ModCalls is your moderator hotline. When a player requests staff in-game, the call appears instantly in BloxCord (and optionally Discord), where your team can claim it, join the session, replay what happened, and resolve the call all in one place. Gameservers and Mod Calls must be enabled before moderation calls can be received or managed. Visit the Features tab to get started. ModCalls must be connected to an in-game command or system that players can use to request a moderator. Use the BloxCord API to trigger ModCalls from your game, as outlined in the [Moderation reference](/api/reference/moderation). ModCalls live feed showing incoming and handled moderator calls Members trigger a modcall in-game using the command you set up. A reason is attached so your team knows what they are walking into. The call appears on the ModCalls tab live and (optionally) pings your Discord through a webhook so nobody misses it. Authorized users can claim the call as the responder or join as an assistant. One click, no coordinating in DMs. Every call is tied to a session replay. Jump straight into the moment it was made to see exactly what happened. ## Mod Call Details Click any call to view its details, review what happened, respond or join as an assistant, and track its current status. Mod Call Details showing caller, reason, server, nearby users, and moderator note Open any call to see everything you need to respond quickly, including: See who made the call, their rank, and the reason they submitted, no guessing. The exact server ID plus a list of players nearby so you know where to go and who to ask. Log the resolution or add context for the rest of the team once the call is handled. Recent infractions or actions tied to the caller or involved users, surfaced automatically. ## Settings Head to ModCall Settings to customize how calls are submitted, routed, and managed across your organization. ModCall Settings configuration page Toggle **Send a webhook on new mod calls** to notify your team in Discord whenever a player requests a moderator. * **Webhook**: Pick from the webhooks you've created in **Settings › Webhooks**. * **Message** (optional, max 500 chars): Add a custom message like `@here a moderator is needed` to make sure the right people see it. Choose who can claim ModCalls. Leave this empty to allow anyone with ModCalls Access to claim calls, or require a specific Roblox rank or BloxCord role so only designated staff can take ownership. Choose who can join a ModCall as an assistant. Leave this empty to allow anyone with ModCalls Access to assist, or require a specific Roblox rank or BloxCord role so only designated staff can join. Set how many assistants can join a single ModCall. Use `0` for no limit, or set a maximum to keep responses focused and avoid overcrowding. Set how many minutes an unclaimed ModCall remains open before it expires. Use `0` to disable expiration. Expired calls can no longer be claimed, but calls that have already been claimed are unaffected. # Actions Source: https://docs.bloxcord.net/player-audit/actions The Actions tab shows every moderation action the player has taken on others, from warnings to game bans. Filter by action type, review who was affected, and see who authorized each action. Logbook must be enabled before moderation entries can be created, viewed, or managed. Visit the Features tab to get started. Image ## Filter Every Action Quickly find the actions you're looking for with filters and live search. Filter by action type or search by target username to review everything the player has done to a specific user. Filter by punishment type with one-click chips for warnings, mutes, kicks, bans, and more. Each filter displays a live count, so you know exactly how many actions match. Search by target username or keyword to instantly narrow the list to the actions you're looking for. ## Know the Status at a Glance Every action includes a status indicator, so you can instantly see whether it's active, expired, or reverted. ## Full Context on Every Entry Expand any action to see the full story behind it, from who authorized it to the exact reason it was issued. See the target player, their role at the time, and the exact reason attached to the action. Every entry shows who the action was carried out under, whether it was self-authorized or approved by a department. Every action includes a status indicator, so you can instantly see whether it's active, expired, or reverted. Duration, category, and any additional notes attached to the entry, so there's no ambiguity about what was issued. # Activity Source: https://docs.bloxcord.net/player-audit/activity Understand exactly when a player is active, how long they play, and where they spend their time. Filter activity by segment, include or exclude AFK time, and open any individual game join for a complete session breakdown. Gameservers must be enabled before live game server data can be viewed or managed. Visit the Features tab to get started. Playtime minutes for the selected segment with real, total, AFK, and average per join stats Actual time in-game with the AFK time stripped out. Every minute they were connected, AFK included. How much of their session was spent idle. Average length of each game join across the segment. ## Playtime Heatmap Below the activity breakdown is a heatmap of the player's complete history with your organization. Each square represents a day, with darker colors indicating more time played, making it easy to spot consistent activity, weekend-only players, long breaks, and sudden returns at a glance. Beneath the heatmap, you'll also find a quick summary showing total hours played, active days, and the exact date range currently being displayed. Full playtime heatmap covering more than a year of activity with hosting and cooldown summaries below Toggle the **AFK** pill in the top right to include or exclude AFK time from the heatmap. Great for telling the difference between someone who's genuinely active and someone who just leaves the game open. ## Hosting & Attendance Summary The **Hosting Summary** card gives you a quick overview of the player's hosting activity. See how many sessions they've hosted, how often they host, and how the community has rated their performance, all in one place. Beneath the summary, you'll find a breakdown by session type, such as Shifts, Trainings, Inspections, or any other event your organization hosts, complete with individual host counts and average ratings so you can quickly identify where they excel. See the total number of sessions the player has hosted for your organization. See how many participants successfully passed the player's hosted sessions. Average rating from peers across all rated sessions. On the right, the **Attendance Summary** shows the player's performance as a participant instead of a host. Review how many sessions they've attended, the different session types they've participated in, their overall pass rate, and a per-type breakdown showing exactly how many sessions they passed and failed. ## Cooldown Summary See at a glance whether the player is currently affected by any promotion or rank cooldowns. If they're eligible, BloxCord displays **No Active Cooldown**. Otherwise, you'll see exactly which cooldown is active, when it expires, and what's preventing their next promotion. You'll also find their current rank, the date of their most recent rank change, and a complete history of every promotion, demotion, and transfer they've received. ## Recent Game Joins The Game Joins list displays every recent session for the selected activity segment, including the server, join and leave times, total playtime, and AFK time for each session. Select any entry to expand a detailed session breakdown with everything BloxCord recorded during that individual game join. Recent game joins with an expanded session showing FPS, ping, presence percentage, and team timeline Live FPS graph across the entire session with the average marked. Network latency over time, so you can tell lag from AFK. How much of the session they were actually present versus AFK. Timeline of what team they were on and when they moved between them. # Chatlogs Source: https://docs.bloxcord.net/player-audit/chatlogs Need proof for a punishment but weren't in-game to see it? Search recent and historical chat logs in seconds, with full message context, timestamps, and built-in grammar insights to help you understand what was actually said. Gameservers must be enabled before chat logs can be tracked and displayed. Visit the Features tab to get started. Player Audit Chatlogs tab showing messages with grammar issue tags and an overall grammar percentage ## Search and Expand for Full Context Every message the player has sent is searchable and grouped by conversation. Search by keyword to jump straight to the messages you're looking for, then expand the conversation to see exactly what was said before and after. No endless scrolling required. Search across every chatlog the player has sent. Names, phrases, single words, whatever you remember from the report. Select any message to instantly view the surrounding conversation. BloxCord shows the messages sent before and after it, giving you the context you need to understand what happened instead of relying on a single line. ## Grammar Insights, Built In BloxCord automatically flags messages with grammar issues, helping you spot communication patterns at a glance. Each flagged message is clearly marked, and an overall grammar score at the top of the page provides a quick snapshot of how the player communicates in-game. ## Jump Straight into [BloxCord Replay](/player-audit/replay) Need more than the chat log? Every message includes its server ID and exact timestamp, so you can open the moment in BloxCord Replay and see everything that was happening before, during, and after the message was sent. # Devices Source: https://docs.bloxcord.net/player-audit/devices See every device a player has used to access your game, along with when it was last seen, Roblox-provided device details, BloxCord insights like country and resolution, and warnings for anything unusual. Devices tab showing a user's identified devices with fingerprint details See the player's device type, including Desktop, Phone, Tablet, or Console, along with the detected operating system such as Windows, macOS, Android, or iOS. Every device is timestamped with the last time it joined your game, so you can tell active hardware from long-forgotten sessions. View Roblox-reported device details, including graphics quality, sensitivity, average load, locale, and supported input methods such as mouse, keyboard, touch, gyro, and accelerometer. See the detected country and screen resolution for each device, providing additional geographic and device context at a glance. ## Automatic Warnings BloxCord automatically flags suspicious devices, making it easy for staff to spot potential issues without digging through the details. When a device's connection profile matches known VPN, proxy, or anonymizer patterns, it's tagged so you can factor that into moderation decisions. If a device's timezone doesn't match its detected country or expected activity, BloxCord flags it as a potential anomaly for staff to review. # General Source: https://docs.bloxcord.net/player-audit/general Once you've found the right player, everything starts here. The General tab brings together their identity, activity, account details, and any information your organization has access to, all in one place. General tab of a player's profile showing their avatar, roles, reputation, geolocation, and quick actions Not every section is available to every user. What you see depends on your organization's configuration and the permissions assigned to your role. ## The Header The top of the page gives you a quick snapshot of the player at a glance. See their avatar, display name, username, highest role, and current local time, so you immediately know who you're looking at and whether they're likely online or asleep. Grab their numeric Roblox ID for scripts, bans, or reports in one click. Copy the exact username, no typos, no case mistakes. Jump straight to their BloxCord profile or their Roblox profile in a new tab. ## Identity & Reputation Everything you need to identify the player is right at your fingertips. See their role, employee ID, reputation score, and current status message at a glance. The **Recent Reputation** card highlights their latest feedback, including who left it, when it was submitted, and how it affected their score. If you need the complete picture, select **View BloxCord Profile** to open their full profile with additional details beyond the audit view. ## Geolocation Where in the world are they actually playing from? The **Geolocation** card breaks it down: See the player's detected country, ISO country codes, and an interactive map pin for a quick visual reference of where they're connecting from. View the player's IANA time zone, current UTC offset, and whether daylight saving time (DST) is currently in effect. See exactly how far ahead or behind their local time is compared to yours. If you're both in the same time zone, BloxCord simply displays "Same time as you." See the player’s current local time and date, updated live so you always know what time it is on their end. ## Linked Discord Accounts View every Discord account the player has ever linked to BloxCord, along with the date each account was connected. Previous usernames, renamed accounts, and unlinked accounts remain in the history, making it easy to investigate alternate accounts and review a player's account history. Need to find the account? Copy the Discord ID with one click or jump directly to the profile on Discord. ## Owned Gamepasses View every game pass the player owns in your experience, with each pass ID displayed for easy reference. Quickly verify donor perks, VIP access, and other purchases, or confirm whether a player actually owns the game pass they're claiming. ## LoA Status See the player's current leave status at a glance. If they have an active or pending Leave of Absence, it will be displayed here. Otherwise, BloxCord clearly shows **Not On Leave**, so you know they're expected to be active. ## Points Balance Their current points balance plus a 30-day breakdown: Every point they've earned in the last 30 days. Every point they've lost in the last 30 days. ## Social Connections See who the player actually spends their time with. BloxCord automatically identifies the people they regularly join in-game, making it easy to spot friend groups, alternate accounts, recurring teammates, or players who frequently appear together during investigations. Their full friends list with the last time each friend was seen in your group. Players this user has joined recently, and how long ago. Players who joined this user, with a timeline going back months. # Live Tables Source: https://docs.bloxcord.net/player-audit/live-table Live Tables show every specialized permission a player has been granted through BloxCord. View custom admin levels, temporary overrides, elevated command access, and more, along with when each permission was granted and whether it expires. Live Tables must be enabled before tables can be viewed or managed. Visit the Features tab to get started. Live Tables tab showing a user's active in-game permissions Each entry represents a permission the player currently has in-game. If BloxCord is enforcing it, you'll see it here in real time. See the exact level or value assigned to each permission, making it easy to tell whether a player has basic access or elevated privileges. Quickly see whether each permission is permanent or temporary, so you know at a glance if it will expire. Whether it's a custom admin tier, a temporary override, or a completely bespoke permission set, every permission enforced through BloxCord appears here in one place. # LoA Source: https://docs.bloxcord.net/player-audit/loa Review a user's Leave of Absence status, quota eligibility, and leave history in one place to quickly determine whether a request meets your organization's requirements. Leave of Absence must be enabled before leave requests can be submitted, reviewed, or managed. Visit the Features tab to get started. LOA tab on Player Audit showing current leave status, quota status, and leave history See instantly whether the user is currently on leave, has a pending request, or is fully active. No digging through requests to figure out who's available. Review the user's quota for the current period so you know if they've met the requirements before approving time away. Every past request, whether approved or denied, with dates, length, and the reason it was decided that way. Skip the request flow entirely and place a user on leave directly from their profile when circumstances call for it. # Logbook Source: https://docs.bloxcord.net/player-audit/logbook The Logbook is a complete history of the player's time with your organization. Every promotion, warning, suspension, and infraction is recorded in one place, whether it's active, expired, or reverted. Logbook must be enabled before moderation entries can be created, viewed, or managed. Visit the Features tab to get started. Logbook tab on a player's profile showing entries, filters, and classification status ## Filter to Exactly What You Need Quickly narrow the logbook to the entries that matter most. Filter by promotions, demotions, warnings, suspensions, bans, and more, with live counts for each category. You can also search by keyword and instantly see how many entries are active or reverted. ## Powerful Actions, Permission Controlled Depending on your role and permissions, the Logbook lets you do much more than view history: Undo a punishment when it was issued in error or no longer applies. The entry stays on the record, clearly marked as reverted. Mark sensitive entries as classified so only authorized staff can view them, or remove the classification when they no longer need to be restricted. Restrict an entry so only selected staff or roles can view it, perfect for HR records, sensitive infractions, or ongoing investigations. Update the reason, description, or other details on any entry your permissions allow. Whether you're correcting a mistake or adding missing context, every change is recorded for accountability. ## Full Context on Every Entry Every logbook entry includes everything you need to understand what happened at a glance: * Entry type and outcome, such as promotions, demotions, warnings, suspensions, bans, and more, with clear visual indicators. * Who issued and received the entry, including each person's role at the time it was recorded. * Complete timestamps for when the entry was created, classified, reverted, or otherwise updated. * Duration, expiration, and current status, including whether the entry is active, expired, classified, or reverted. ## Log an Infraction Your Way Creating a Logbook entry is quick and flexible. Choose a rule from your handbook to automatically populate the details, or create a fully custom entry from scratch. Log an infraction dialog with New Entry, With Rule, and quick-select punishment types Step 2 of 5 entry details with reason field, optional rules selector, and Start after join toggle Create As selector showing personal identity and available authorities like Dashboard Admin, SVGA, SVIA Search your entire rulebook and select the exact rule that applies. BloxCord auto-selects the correct punishment based on the player's prior active infractions, so escalation happens the right way, every time. Skip the rulebook and create a fully custom entry. Set your own reason, punishment type, and duration. Perfect for situations that don't fit neatly into a written rule. Want the best of both worlds? Customize the punishment however you need, but still attach the relevant rules. Next time that rule is triggered, BloxCord automatically elevates the punishment based on the modified history. Log entries under yourself, or under any role or department you have permission to represent. Every entry clearly records the authority it was issued under, so accountability is never lost. ## **Evidence, All in One Place** Add screenshots, videos, and supporting files alongside your report. Drag, drop, or paste your evidence in seconds to give reviewers everything they need. Logbook and Upload Images/Videos must be enabled before media can be attached to moderation entries. Visit the Features tab to get started. Attatchments ## Break Glass Access Protect sensitive moderation records with a built-in Break Glass workflow. Player Audit Seals let administrators seal a member's logbook so anyone attempting to access it must provide a reason before breaking the seal, creating a complete audit trail of who viewed the records, when they did, and why. Player Audit Seals must be enabled before audit seals and protected logbook entries can be managed. Visit the Features tab to get started. Image # Quota Source: https://docs.bloxcord.net/player-audit/quota Track every quota assigned to the player in one place. See what's complete, what's still outstanding, and filter by activity segment to review progress over time. Activity Quotas must be enabled before quota progress and statistics can be displayed. Visit the Features tab to get started. Quota tab on a player's profile showing quota status, met count, and progress bar At a glance you'll see: * **Quota status** for the selected segment, including how many quotas have been met out of the total assigned. * **Each individual quota**, its type, current progress, target, and whether it's marked **Met** or not. * **Segment filter** in the top right, so you can review this segment, past segments, or whatever range that matters to you. # Replay Source: https://docs.bloxcord.net/player-audit/replay Enter a Server ID along with a date and time, and BloxCord generates a replay of that moment. It automatically searches a ±6-hour window around the selected time to find the correct session, so there's no guesswork. BloxCord Replay requires **BloxCord Replay Systems** to be enabled and a valid **Organization Cookie** to be configured before it can be used. Learn more about setting one up [here](/settings/roblox-integration). Player Audit Replay tab with Server ID and date & time inputs, plus Command Logs section below Paste in a Server ID from Chat Logs, the Logbook, or anywhere else in Player Audit, choose a date and time, then hit Search to generate the replay. BloxCord automatically searches a ±6-hour window around your selected time, so you don't need to know exactly when the session started to find the right replay. ## Command Logs, Right Below Right below the replay search, you'll find the player's recent in-game command history. Every entry shows who ran the command, who it targeted, and exactly what happened, making it easy to tell whether the command was used on themselves or another player. See the exact command that was run, who executed it, and who it targeted, with a one-click shortcut to open the target player's profile. Every command displays the admin level it was executed with, making it easy to spot potential misuse of elevated permissions. Every command includes its Server ID, so you can jump straight into BloxCord Replay and review everything that happened around it. See which team the player was on when the command was used, so you know exactly what role they were acting in. ## Understanding the Replay BloxCord recreates the game's layout and every player in the server without textures, allowing replays to load quickly while keeping the focus on player movement and interactions. Drag to rotate the camera, scroll to zoom, and follow the action from any angle. Replay Viewer showing the untextured game structure, player figures, and the playback settings menu Open the settings menu to fine-tune the replay: adjust playback speed, toggle Highlight Player to keep your target in focus, and switch on Load All Parts for extra scene detail. Turn on Integrated Playback to see exactly where each player is facing, along with their movement and interactions, giving you the full picture of what happened. Click the camera icon to drop into freecam mode. Fly anywhere in the scene to inspect angles, walls, and hidden spots that the default view can't reach. Use your mouse to change the camera angle and your scroll wheel to zoom in or out, so you can frame every moment exactly how you want it. # Search Page Source: https://docs.bloxcord.net/player-audit/search-page Find any player in seconds. Search by Roblox username, Roblox ID, or Discord ID, view who you've played with, and review previous users in your sessions with a single click. Player Audit landing page showing a search bar and a Recently Seen panel with your latest session and the players who were in it Your latest session and everyone next to you in it. Forgot that one username? We remember it for you. Full session info and server ID on every recent entry, ready to hand straight to **BloxCord Replay**. Roblox username, Roblox ID, or Discord ID. Throw anything at the search bar and we'll find the right player. ## Pick Up Where You Left Off Every recent session shows who you played with, when it happened, and the server it took place in. If you need a closer look, open the session in **BloxCord Replay** using the server ID and review exactly what happened. ## Find Anyone, Any Way No matter what information you start with, Player Audit helps you track down the right player. Search by Roblox username, Roblox ID, or Discord ID in one place. # Points Source: https://docs.bloxcord.net/points The Points page keeps your balance and transaction history in one place. See your current balance at a glance, then review every point earned or spent with a complete history of transactions, including what changed, when it happened, and who made the adjustment. Points must be enabled before points can be be viewed or managed. Visit the Features tab to get started. Points overview and history Always up to date, always accurate. Every add and deduction is timestamped and tied to who made it. ## Organization Point Activity Every transaction is displayed in a complete activity feed, including who received points, the amount awarded, why it happened, who made the adjustment, and when it occurred. Awarding points based on activity ## Managing Points If you have permission, the Manage section gives you complete control over your organization's points. Transact points to individual members with the click of a button. Managing points for users ### Manage Individual Points Grant, take, or set a member's points in seconds. Include an optional reason, and every change is automatically logged for complete transparency. Points transaction details ## Build Your Own Rewards Points don't have to come from BloxCord alone. Use the [BloxCord API](/settings/api-integration) to award or remove points from your own applications, whether you're tracking Discord activity, rewarding completed jobs or assignments, or creating entirely custom reward systems. You can also manage points manually at any time directly from the dashboard. # Organization Plans Source: https://docs.bloxcord.net/pricing/organization-plans BloxCord organizations run on one of four plans. Each plan includes everything from the plans below it, plus additional features, tools, and higher limits. The essentials to run your community. Guest profiles, live servers, forms, and more. Sessions, shifts, automations, and advanced control. Maximum scale, media proof, and dedicated support. ## How Plans Work Whatever plan your organization is on decides which features are available to everyone in it. As long as your subscription is active, every feature included in your plan is fully available. If a subscription ends, is cancelled, or a payment fails, your organization returns to the Free experience. Your data is kept safe. Paid features simply pause until you're back on a plan. Anything not listed under Pro, Diamond, or Enterprise is included on **Free**, and therefore on every plan. *** ## Free Everything you need to get your community up and running. ### Core Tools Rank members in your Roblox group directly from the dashboard, with your organization's max, staff, and suspended ranks respected everywhere. Log, revert, and manage moderation actions on your players in one place. ### Roles & Insights Organize your staff with up to five roles, using the full set of standard staff permissions. Customizable core moderation, activity, and info widgets on every player profile. ### Everyone Gets In Free organizations support up to **15 members active at once**. Extras wait briefly in a friendly waiting room with a live spot in line. Members with **BloxCord Plus or Premium** always skip the waiting room. Upgrade to **Pro** to remove it entirely. *** ## Pro Everything in **Free**, plus a full suite of community and moderation tools, starting at **\$7.99/month**. ### New Tools Let members request time off and let staff review and manage active leaves, with configurable cooldowns and duration limits. Public-facing member pages, including the Leaderboard and Friends tabs. Rich member profiles with roles, an About Me, pronouns, and birthdays, plus optional birthday announcements. Let staff give and track reputation on member profiles, with daily and weekly limits. *Builds on Member Profiles.* Build shareable forms with a drag-and-drop editor, auto-scored quizzes, live responses, and respondent analytics. **Coming soon:** Roblox Application Centers and Rank Centers. Send Discord webhook messages with custom templates for your audit log, sessions, and shifts. See your live servers, stream their console, run scripts, and teleport players, powered by the BloxCord Game SDK. Remove the concurrent-member cap entirely so unlimited members can use the dashboard at once. ### Roles, Permissions & Membership Twice as much room to structure your staff. Group roles into departments so one department can't mess with another's roles or permissions. A permission that lets staff update member roles across departments. A permission that lets staff edit the permissions of any department's roles. Automatically invite qualifying Roblox group members based on their group rank. No more manual invites. ### New Widgets *** ## Diamond Everything in **Pro**, plus advanced tools for established communities, starting at **\$15.99/month**. ### New Tools Host, schedule, and archive sessions complete with leaderboards and replays. Run shift groups with claims, clock-ins, worker management, and reports. Set activity requirements and track each member's progress toward them. Customize your weekly segment, too. Enforce waiting periods before members can be promoted again. Track member point balances and grant, deduct, or set them at any time. A no-code automation builder: when something happens on your dashboard, run actions like sending webhooks, creating logbook entries, or adjusting points. Build a structured rulebook and attach rules to logbook entries. Pre-define punishment steps to simplify moderation. Share access-controlled handbooks with personalized watermarking and read logs. Create shared lists with their own per-list access permissions. Fetch these lists from in-game. Surface in-game moderation calls and let your staff respond to them. *Builds on Live Game Servers.* Ban a player across all of their accounts, not just one. *Builds on the Moderation Logbook.* Aggregate and visualize player activity data in shareable, access-controlled views. Classify and declassify entries, and lock them to freeze any further reverts or changes. *Builds on the Moderation Logbook.* ### Roles & Permissions Room for a full multi-department staff structure. Roles that act as an entity inside the logbook, e.g. "Locked to Board of Directors" or "Classified to \[Entity]". Automatically keep members' Discord roles in sync with their organization roles. Set per-role rate limits on sensitive actions. *** ## Enterprise Everything in **Diamond**, plus maximum scale, control, and support. Organizations interested in upgrading to **Enterprise** should contact the BloxCord team via [email](mailto:help@starsol.io) or our [Support Server](https://discord.gg/ewBeYh2ANy) to discuss options and pricing. Enterprise organizations receive **priority, dedicated support** from the BloxCord team. ### New Tools Create and manage API keys for secure external access to your organization, with full request logs. Record and play back BloxCord replays from your game servers. *Builds on Live Game Servers.* Attach images and videos as proof directly on logbook entries, with a media library to review and manage them. *Builds on the Moderation Logbook.* Role-based audit protection with Glass-Break access rules and sealed logbook entries. Define up to **five** of your own logbook entry types, each with its own name, icon, color, and optional automatic rank action. *Builds on the Moderation Logbook.* Verify member ages and manage age-check sessions and their results. Move your organization's members onto BloxCord Priority Servers. Extra safeguards for sensitive handbooks, including restricted viewing and leak detection. ### Roles Enough headroom for the largest, most compartmentalized organizations. ### New Widgets Device history with VPN and location flags, client settings, and potentially associated accounts. See mutual friend and join relationships between two players. Predict when a member is most likely to be online, with prior-period comparison. *** ## Limits at a Glance **Free** 5  ·  **Pro** 10  ·  **Diamond** 20  ·  **Enterprise** 100 **Free** 15, then waiting room  ·  **Pro and above** unlimited ### Image & Video Proof Available on **Enterprise**. As your plan grows, so do your upload and storage limits. | Plan | Max per file | Kept for | Storage | | ---------- | ------------ | -------- | -------------------- | | Free | 25 MB | 1 year | 5 GB | | Pro | 50 MB | 3 years | 25 GB | | Diamond | 100 MB | 5 years | 100 GB | | Enterprise | 100 MB | 10 years | 1 TB (or contact us) | *** ## Everything by Plan | Feature | Included in | | ------------------------- | ----------- | | Group Ranking | Free | | Moderation Logbook | Free | | Leave of Absence | Pro | | Guest Features | Pro | | Member Profiles | Pro | | Reputations | Pro | | Forms & Surveys | Pro | | Webhooks | Pro | | Live Game Servers | Pro | | No Waiting Room | Pro | | Sessions | Diamond | | Shifts | Diamond | | Activity Quotas | Diamond | | Promotion Cooldowns | Diamond | | Points | Diamond | | Actions Automation | Diamond | | Group Rules | Diamond | | Handbooks | Diamond | | Live Tables | Diamond | | Mod Calls | Diamond | | Machine Bans | Diamond | | Views | Diamond | | Advanced Logbook Controls | Diamond | | Organization API Access | Enterprise | | Replay Systems | Enterprise | | Image & Video Proof | Enterprise | | Player Audit Seals | Enterprise | | Custom Log Types | Enterprise | | Age Check | Enterprise | | Priority Servers | Enterprise | | Capability | Included in | | --------------------------- | ----------- | | 5 roles | Free | | 10 roles | Pro | | 20 roles | Diamond | | 100 roles | Enterprise | | Departments | Pro | | Manage Other Departments | Pro | | Change Any Role Permissions | Pro | | Auto-Invite Members | Pro | | Entity Roles | Diamond | | Discord Role Sync | Diamond | | Role Rate Limits | Diamond | | Handbook Leak Protection | Enterprise | | Widget | Included in | | ------------------------- | ----------- | | Geolocation Map | Pro | | Geolocation Card | Pro | | Friends List | Pro | | They Joined | Pro | | Joined Them | Pro | | Owned Gamepasses | Pro | | Actions Taken | Pro | | Title | Pro | | Light | Pro | | User Devices | Enterprise | | Mutual Social Connections | Enterprise | | Online Probability | Enterprise | # Personal Plans Source: https://docs.bloxcord.net/pricing/personal-plans Get more out of BloxCord with Plus or Premium. Unlock exclusive customization options, premium features, faster cloud performance, priority support, and other perks available only to subscribers. ## User Billing Personal plans that follow you across every organization you're part of. **\$6.49** · one-time purchase Own it forever. Great for casual users who want the essentials. * Simple Dark Theme * Shiny Nameplate 1,3 * Bypass Waiting Room * Support the BloxCord Team [Get Plus →](https://app.bloxcord.net/billing) **\$19.99** · per month * Glass Mode Theme * Server Priority * Custom Banners 1 * Custom Nameplate Gradient 1 * Priority Support * Everything in Plus 2 [Subscribe →](https://app.bloxcord.net/billing) 1 Available across organizations with BloxCord Profiles enabled. 2 Plus features are not granted permanently during the Premium trial. 3 Shown in Profiles, Reputations, Player Audit, and Hover Card. # Profiles Source: https://docs.bloxcord.net/profiles The Profiles page is your organization's social hub. Search for any member, view their roles and reputation, or personalize your own profile with pronouns, an About Me, and all the premium features available to your account. Dashboard Profiles must be enabled before profile information can be displayed or changed. Visit the Features tab to get started. Profiles page showing online users and personal profile Your profile, front and center. View your roles, reputation, and personal details, then customize them to reflect who you are. On the right, an online members panel lets you instantly see who's active and jump straight to their profile with a single click. See who's online right now, updated in real time. Tap any online member to open their full profile instantly. ## Look Up Anyone Search for any member of your organization to pull up their profile, roles, and reputation with you. ## Your Profile, Your Way Customize your profile with personal details, preferences, and exclusive cosmetic features. Edit Profile modal with fields for pronouns, birthday, and about me Let your team know how to address you. Add your birthday so your organization can celebrate with you when the day comes. Share a bit of yourself in your own words. Quickly spot members who have upgraded their profiles with premium-exclusive customization. # Quota Source: https://docs.bloxcord.net/quota Know exactly where you stand at all times. View your rank, hosting, and department quotas side by side, complete with live progress, current status, and everything you need to stay on track. Activity Quotas must be enabled before quota progress and statistics can be displayed. Visit the Features tab to get started. My Quota dashboard showing rank quota and department quota requirements with progress bars and an active bypass The baseline your rank is expected to meet. Active minutes, sessions, or whatever your group defines. Always visible, always current. Training hosts, shift hosts, event hosts. If your role requires you to run things, this is where you'll see it tracked. Belong to a special department? Your department's unique requirements show up here right next to everything else, no extra clicks. Requirements that have been waived or bypassed are clearly labeled, making it easy to see which ones no longer count against you. ## Explore Past Segments Need to review a previous segment? Use the segment filter in the top right to jump back in time and see exactly where you stood. Every requirement, logged minute, and approved bypass is preserved for a complete history. Jump between "This Segment" and any past window with a single dropdown. Great for reviewing where you fell short so it doesn't happen twice. Each segment preserves its progress, totals, and quota requirements, so your history stays accurate even if your quotas changes later. ## Segment Reset Never lose track of a deadline. The footer beneath your requirements shows exactly when the current segment resets and how much time remains, so you always know how long you have left. ## Set the Standard Quotas aren't just something members complete, they're something your leadership defines. Members with the appropriate organization permissions can configure rank, department, and hosting quotas, giving your organization complete control over what it means to stay active. Manage Quota dashboard listing CP Minutes, CP Sessions, FD Minutes, FD Sessions, CAC Minutes, CAC Supervision, PC Minutes, and PC Supervision with edit and delete controls, alongside an Organization Segment card that resets every 7 days Requirements change over time. Update thresholds, rename quotas, or delete ones you no longer need, all without leaving BloxCord. Define one quota schedule for your entire organization. Set weekly, biweekly, or monthly resets and choose the anchor date that works best for your team. ### Built Around Your Organization Create custom quotas for any part of your organization. Choose what to track, set the requirement, and assign it to one or more ranks, departments, or BloxCord roles. New Quota modal with fields for Name, Type set to Active Minutes, Required minutes, and an Assign to section with Ranks and BloxCord Roles tabs showing checkboxes for Member, Low Security Inmate, Suspended Security Inmate, Respected Inmate, and Cadet Officer Give your quota a clear name, choose what to measure, and set the required amount. Members automatically see the updated requirements as soon as you save. Assign quotas by rank, department, or BloxCord role. Multi-select support lets you apply a single requirement to multiple groups without creating duplicate quotas. AFK time is automatically excluded from activity tracking, ensuring members are only credited for time they're actively participating. Whether you measure active minutes, sessions, hosting, messages, punishments, or something entirely unique, BloxCord lets you build a quota system around what matters to your organization. ## Grant Bypasses in One Click When a member shouldn't be held to a requirement, simply waive it. No manual tracking or messy spreadsheets required. Image Hit **Add Bypass**, pick a member, and they're excused. No forms to fill out, no approvals to chase, no manual tracking. Just a clean way to say "you're covered." Grant a bypass for a set window with start and end dates, or make it indefinite for permanent exemptions like retired members or special roles. Bypass one quota, several, or all of them. Full control, per member. Changed your mind or the situation changed? Revoke any bypass with one click and the member is back on the standard immediately. # Ranking Source: https://docs.bloxcord.net/ranking Ranking cannot be used until Rank Changes are enabled and your Roblox Cookie or Open Cloud API has been configured. Visit the Features tab to complete the setup. Ranking is one of the most important parts of running your organization. Whether you're promoting, demoting, or reviewing a member, everything you need is right here, with a workflow built to make every rank change fast, accurate, and effortless. Ranking search for a member Type a username or Discord ID and the right member surfaces in seconds. Rank, cooldown, and history load side by side, no extra clicks. See whether a member is on promotion cooldown, when it expires, and why before making a rank change. If your permissions allow it, you'll also see whether the cooldown can be bypassed. View a member's complete rank history, including every previous rank and when each change occurred. ## Change Rank Click **Change Rank** to choose a new rank, provide an optional reason, and confirm the change. BloxCord updates your Roblox group instantly and automatically records the action for a complete audit trail. Change Rank modal Changes push straight to your group, no side trips required. Every rank action needs a reason, so the audit trail stays useful. Every rank change is automatically recorded in the member's history, giving you a complete record of their progression through your organization. The system respects cooldowns by default, protecting you from mistakes. # Reputations Source: https://docs.bloxcord.net/reputations See who's earned the strongest reputation across your organization. Compare all-time standings or use the segment filter to view reputation changes over different time periods. Reputations must be enabled before reputations can be be viewed or managed. Visit the Features tab to get started. Reputations page with segment filter Track recent reputation changes across your organization to see who's gaining or losing reputation. View every member's reputation across their entire time in the organization, not only recent changes. ## Modify from a Profile Reputations are managed from member profiles, not the Reputations page, ensuring every rating is tied to the right context. To leave or update a reputation, visit a member's profile. Learn more in the [Profiles](/profiles) documentation. Modifying reputation from a member profile Upvote or downvote a member with a single click. No forms, no friction. Add an optional note to explain why. A quick sentence turns a vote into real, useful feedback the member can actually learn from. # Rules Source: https://docs.bloxcord.net/rules A consistent team starts with consistent rules. Build your rulebook once, categorize it however you like, and ensure every moderator handles situations the same way. Group Rules must be enabled before rules can be created, managed, or enforced. Visit the Features tab to get started. Rules landing page with categorized rule groups and severity tags ## Categorize Your Way Organize your rulebook however your organization operates. Create categories for in-game offenses, Discord conduct, department-specific policies, staff standards, or anything else your team needs. Every category includes its own icon, description, and labels, making it easy for moderators to find the right rule in seconds. Create Category modal with name, description, icon picker, and label options Name, describe, and icon each category so the rulebook mirrors how your team actually thinks about offenses. Tag rules with labels like In-Game, Discord, Department, Staff, and more to help moderators quickly find the guidance they need. Refine your rulebook even further. Apply tags to individual rules so moderators can quickly filter down to the exact offense they're looking for.Permission-locked Categories respect your permission tree. If a member cannot moderate a scope, they cannot view or edit the rules inside it. ## Every Rule, Fully Defined Open any rule to see exactly what it covers, who created it, and the disciplinary ladder your moderators are expected to follow. No more guessing whether an offense starts with a tool ban or goes straight to a game ban. Rule detail view showing description, punishment steps, severity, labels, and last modified author Verbal Warning, Staff Warning, Suspension, Termination, or any custom ladder. Steps escalate automatically as offenses stack. Assign every rule a severity level, from Very Low to Critical. A color-coded tag helps moderators instantly understand how seriously each offense should be treated. Every rule shows who last modified it and when, making it easy to track changes and maintain accountability across your team. Tag rules with labels like Staff, Department, In-Game, Discord, and more. Search and filter your rulebook in seconds. ## Build Rules Your Way Build a rule from a single streamlined form. Give it a name and description, assign a severity, define each disciplinary step with its type and duration, and add the labels that organize it. Every action is clearly documented, so moderators always know exactly how to enforce it. Create Rule modal with name, description, severity selector, punishment steps, and label chips Write a rule once, and every moderator sees the same guidance whenever they open it. Choose the action, such as Ban, Warning, or Suspension, then set its duration and time unit. Add as many disciplinary steps as your organization requires. Assign the appropriate severity to every rule so moderators can quickly recognize the right response for the offense. Assign labels like In-Game, Discord, and Staff to scope each rule to the appropriate moderation area. ## Attach Rules When You Punish The rulebook does more than document your policies. When a moderator issues a punishment, they can attach the matching rule to the log, and BloxCord automatically applies the next step in the disciplinary ladder. If a member reaches their third offense under the same rule, BloxCord already knows to escalate the punishment to whatever **you** decided. Choose a rule during the punishment workflow, and BloxCord automatically fills in its disciplinary ladder. BloxCord tracks prior offenses for every rule and automatically applies the next step in the disciplinary ladder. No manual tracking or counting required. # Servers Source: https://docs.bloxcord.net/servers Why stop at Discord when your operations don't? Take control of your game servers, monitor live activity, and run scripts, all without leaving BloxCord. Gameservers must be enabled before live game server data can be viewed or managed. Visit the Features tab to get started. Image Every running server for your group games, always up to date, always one click away. Dive into any server to see who's in game, current activity, and everything happening inside. Real-time logs from inside your servers so you always know what's happening the moment it happens. Find the exact server you need in seconds, no matter how many are running. ## Execute Scripts on the Fly Need something done in-game right now? Execute scripts directly from your BloxCord dashboard and see the results instantly. No developer tools or in-game commands required. Execute custom scripts on any running server with a single click. Save the scripts you use often and fire them off in seconds. No more digging through notes or retyping the same code. # Configuration Source: https://docs.bloxcord.net/session-management/configuration This is where BloxCord Sessions stops feeling like a tool and starts feeling like your tool. Every tab in Session Settings unlocks another layer of control. ### General Turn on sessions with a single toggle, optionally restrict them to a specific Roblox place ID, and create recurring reservation slots that automatically fill your calendar with your organization's regular session schedule. Recurring slots appear on the calendar for members to reserve, so you don't have to recreate the same sessions every week. Set them to repeat as often or as little as you need, and create as many recurring slots as your organization requires. Session Settings General tab with sessions toggle, place ID, and recurring slot chips ### Session Types The heart of Sessions. Create unlimited session types, each with its own attendee requirements, phase flow, reservation rules, and leaderboard weight. Every knob in the editor exists so you can shape a type to match exactly how your organization actually runs it. Image #### Attendee Settings Set the minimum and maximum number of attendees for this session type, and choose how attendees are managed once the session begins. The minimum number of attendees required before this session can begin. Hosts cannot start the session until this requirement is met. The maximum number of attendees allowed for this session type. Once the limit is reached, no additional attendees can join. Prevent attendees from being added or removed once the session begins. Ideal for tryouts, exams, certifications, or any session where the roster should remain fixed after it starts. Automatically pre-select players near the host in the Add Attendees menu, making it easy to add everyone nearby with a single click instead of searching through the full player list. Marks this session type as competitive. Competitive sessions contribute to leaderboard rankings using the scoring rules you configure later. Leave this disabled for casual, training, or non-scored events. Allow eligible hosts to reserve future sessions of this type on the calendar. Disable this for on-demand session types that should only be created when needed and never scheduled in advance. Prevent administrators, co-hosts, and other staff from being added or removed once the session begins. Ideal for sessions where the staff roster should remain fixed after the session goes live. #### Phases & Outcomes Every session type follows a customizable flow. Drag and drop phases into any order, assign their purpose, and mix built-in results with your own custom phases. A phase is a step in the session workflow. Phases represent the stages hosts move through, such as Warmup, Drill 1, Drill 2, or Interview. Add as many phases as needed and arrange them in any order. A result is the outcome assigned to an attendee when the session ends. Passed is built in and is automatically applied to attendees who complete the session successfully. Create additional results like Failed, Excused, No Show, Reserved, or any other outcome your organization needs. #### Host Requirements Control who is eligible to host this session type. Combine any number of Roblox rank and BloxCord role requirements, and a user can host as long as they satisfy the rules you define. Require a minimum Roblox group rank to host this session type. Use `≥` to allow anyone at or above the selected rank, such as Prison Commissioner (#17) or higher. Require one or more BloxCord roles to host this session type. Use role requirements on their own or combine them with Roblox rank requirements for more precise access control. #### Administration Roles Staff roles define the team that assists the host during a session. Create roles like Manager, Supervisor, Observer, or any others your organization uses, then configure how many are needed and who qualifies for each one. Set the minimum and maximum number of people who can fill this staff role for a session. Sessions cannot begin until the minimum requirement for every administration role has been met. Allow members in this role to manage the session. Managers can start and end sessions, control session state, and edit phases, while non-manager roles can assist without having those permissions. Use the same qualification system as Host Requirements to control who can fill this administration role. Require a Roblox group rank, BloxCord role, or any combination of both. Create as many administration roles as your organization needs. Every role has its own minimum and maximum staffing, manager permission, and qualification requirements. #### Requirement Overrides Override the default staffing requirements for qualified hosts. If a host matches an override, the lowest minimum and highest maximum from all matching overrides are used, allowing staffing requirements to be relaxed without ever making them stricter. Choose which hosts this override applies to. Require a Roblox group rank, BloxCord role, or both. Leave the requirements empty to apply the override to every host. Override the minimum and maximum staffing for individual administration roles. Relax requirements for qualified hosts by lowering minimums, raising maximums, or both, on a role-by-role basis. Add as many role adjustments as needed to a single override. One override can relax the staffing requirements for multiple administration roles at the same time. Create as many override rules as your organization needs. Different groups of hosts can each have their own staffing relaxations, and BloxCord automatically applies the most generous minimum and maximum values from every matching rule. #### Promotions Automatically promote attendees who achieve a qualifying result when the session ends. Promotions are applied directly through BloxCord with no manual rank changes required. Automatically promote attendees who achieve a qualifying result when the session ends. Disabled by default to prevent accidental promotions. Set the highest Roblox group rank BloxCord can promote attendees to for this session type. Promotions will never go beyond this limit, even if an attendee would otherwise qualify for a higher rank. Control who is allowed to promote attendees for this session type. Combine any number of Roblox rank and BloxCord role requirements, and a host can promote as long as they satisfy the rules you define. Only attendees who finish the session with a qualifying result are eligible for promotion. Everyone else is automatically skipped. ### Scheduling Decide how far ahead members can reserve, how many reservations each host can hold, and how much breathing room to leave between exclusive sessions. Or turn on on-demand and let hosts start whenever they want. Scheduling settings with horizon, max per user, and exclusive radius inputs ### Leaderboard Weights This is the setting that separates BloxCord from every other session system. Tune the exact signals that define a great host for *your* organization. Presence, professionalism, responsiveness, peer grades, phase completion, pass rate. Slide the weights until they match your standards. Leaderboard signal weight sliders across presence, professionalism, responsiveness, peer grades, phase completion, and pass rate ### Notifications Post a live status message to Discord and keep it updated as the session progresses. Attach an auto-generated session image, use a fully customizable webhook template, and choose whether the message sticks around or cleans itself up when the session ends. Session notification settings with webhook template selector and BC Render toggle # Sessions Source: https://docs.bloxcord.net/session-management/sessions Sessions are the heartbeat of your organization. From trainings and tryouts to shifts, BloxCord gives you a fully customizable system to host, schedule, and review sessions with ease. Sessions must be enabled before you can view, manage, or customize sessions. Visit the Features tab to get started. ## The Overview Anyone with permission lands on a clean overview of everything that matters. See what's happening right now, what's coming up, and what just wrapped up, all at a glance. Sessions overview showing ongoing, upcoming, and recent sessions A live feed of recently completed sessions, complete with hosts, timestamps, and outcomes. See every upcoming session at a glance, so members know when to show up and staff know what's coming next. Host a session with a single click. Pick a session type, and BloxCord automatically verifies you're in-game before starting, preventing ghost hosts and empty sessions. Claim a calendar slot ahead of time so no two hosts step on each other and members can plan around it. ## The Calendar Switch to the calendar view for a week-at-a-glance look at every open slot, reservation, and exclusive block. Reserve a time that works, add an optional note, and you're all set. Sessions calendar view See exactly when you can host without overlap. Block nearby session times when you need the spotlight, like for high-attendance sessions. ## The Leaderboard Every organization has a host who never stops hosting. The leaderboard celebrates their dedication and fuels a little friendly competition. Session hosts leaderboard with score breakdowns across presence, professionalism, responsiveness, peer grades, phase completion, and pass rate Slice by session type, timeframe, host, and more. Answer any question in a couple of clicks. See who's carrying the load this week, this month, or over the past several months. Track attendance, hosting activity, and growth over time to see how each host is performing. Reward the hosts putting in the work with data you can point to. ## Reviewing Completed Sessions Once a session wraps, staff get the full picture. Not just "who showed up," but what actually happened. Detailed session review with phases, attendees, and administration breakdown Every attendee, when they joined, when they left, and how long they stuck around. Who actually engaged versus who just stood in the corner. In-game movement, actions, and events tied back to each participant. Receive feedback based on what actually happened during the session. ## [BloxCord Replay](/player-audit/replay) Most platforms stop at logs. BloxCord doesn't. Replay lets your staff step back into any completed session and watch it unfold exactly as it happened. Review host performance, uncover opportunities for improvement, and help every host grow using what actually happened during the session. BloxCord Replay Systems must be enabled before you can view or use replay data. Visit the Features tab to get started. Image # API Integration Source: https://docs.bloxcord.net/settings/api-integration Connect your game and everything around it. Game Keys power BloxCord's Roblox integrations, while Auth Keys let external applications securely connect to the platform. Every request made with either key is automatically logged, giving you complete visibility into how they're being used. ## Game Keys **The Game Key is the bridge between your game and BloxCord.** Add it to your Roblox game once, and BloxCord can power features like activity tracking, logbook enforcement, replay recording, and more. Every Game Key is fully configurable. Enable only the features you need and restrict the key to specific Roblox places, ensuring it can only be used where you intend. Game Keys configuration Toggle Activity Tracking, Logbook Enforcement, Organization Functions, Script Execution, Replay Recording, and more on a per-key basis. Restrict each key to up to 5 Roblox places. Requests from anywhere else are rejected. Game Keys are shown **only once** at creation. Copy it, store it somewhere safe, and never share it. ## Auth Keys **Auth Keys connect your applications to BloxCord.** Whether you're building a companion website, a Discord bot, or an internal tool, Auth Keys let your applications securely access BloxCord's features without rebuilding them from scratch. Every Auth Key is linked to a Roblox account, known as the actor, and inherits the roles you assign. Any request made with the key acts on behalf of that account and is limited to its permissions, nothing more. Organization API Access must be enabled before Auth Keys can be created or managed. Visit the Features tab to get started. For your security, Auth Keys **automatically expire** after 365 days (1 year). New Auth Key dialog Bind the key to a linked Roblox account and assign the roles that determine what it's allowed to do. Lock a key to specific IP addresses so only your servers can use it. Leave it open if you need flexibility. Just like Game Keys, Auth Keys are shown **only once**. Save it the moment it's created, or you'll need to generate a new one. ## Request Logs Every request leaves a trail. The **Request Logs** tab records every request made with your Game Keys and Auth Keys, including what was called, when it happened, which key made the request, and whether it succeeded. Whether you're debugging an integration or investigating suspicious activity, everything you need is in one place. # Billing Source: https://docs.bloxcord.net/settings/billing Take your organization to the next level. Upgrade your plan, review your current subscription, and explore some of the features included with each tier, all in one place. Billing settings showing plan tiers and features Each plan gives you a quick look at what's included, from **Free** to **Enterprise**. For a complete breakdown of every feature, limit, and benefit, visit [Organization Plans](/pricing/organization-plans). # Cooldowns Source: https://docs.bloxcord.net/settings/cooldowns Set how long members must wait between promotions for each Roblox rank. When Promotion Cooldowns are enabled, you can configure a cooldown in days for every rank, choose how it's calculated, and let BloxCord enforce it automatically. Promotion Cooldowns must be enabled before this tab can be displayed. Visit the Features tab to get started. Promotion Cooldowns settings Counts the cooldown from the last time the member was seen in-game at a different rank. Counts the cooldown from the most recent promotion recorded in the logbook. Set a rank to `0` to remove its cooldown entirely. # Discord Bot Source: https://docs.bloxcord.net/settings/discord-bot Integrate the BloxCord bot with your organization and manage everything it can do from one place. When linking a Discord server, BloxCord automatically discovers every server you have access to, so there's no need to copy or hunt down server IDs. Discord Bot linked servers ## Linked Servers Every Discord server connected to your organization appears here. When linking a new server, BloxCord automatically finds every Discord server you have access to, so there's no need to copy IDs. Just pick a server, confirm, and you're ready to configure exactly how the BloxCord bot behaves within it. ## Configure to Your Liking Open any linked server to fine-tune every module the bot offers, from group ranking to Discord moderation to verification. Discord Bot per-server configuration Toggle in-Discord ranking on or off and pick the channel that catches every rank change. Enable commands like `/warn` and route every action to a dedicated moderation log channel. Let members link their Roblox account and pull group ranks and roles straight into Discord. Automatically hand out Discord roles when users verify, mapped to your group ranks. ## Nickname Templates Shape how verified members appear in your server. Use placeholders like `*us`, `*id`, `*rank`, and `*role` to build a nickname format that matches your organization's style. # Features Source: https://docs.bloxcord.net/settings/features Enable only what your organization needs. Toggle any of BloxCord's 28 features on or off with a single click. Some features go even further, letting you configure permissions, customize their behavior, or limit access to specific roles or members, so every feature works exactly the way you want it to. Features settings Turn a feature on to make it available across your organization. Fine-tune the feature, toggle sub-permissions, or scope it to specific roles and members. Turn it off anytime. Your configuration is preserved for when you turn it back on. Features are organized by category such as User Experience, Staffing & Organization, Game Management, and more, making it easy to find exactly what you're looking for. # General Source: https://docs.bloxcord.net/settings/general The heart of your organization. Configure your organization's name, icon, and essential settings from one place, making it easy to keep everything up to date. General settings page showing organization profile and auto invite members Upload a custom PNG, JPG, WEBP, or GIF up to 6 MB. Remove it anytime to fall back to your Roblox group icon. Rename your organization whenever it evolves. Changes are instant across BloxCord. ## Roblox Group ID Your Roblox Group ID is permanently linked to your organization and cannot be changed from the dashboard. This keeps your members, ranks, and permissions tied to the right group with zero risk of accidental swaps. Need to move your organization to a different Roblox group? Reach out to support and we'll handle the migration for you. ## Auto Invite Members Skip the manual onboarding. Turn on **Auto Invite Members** and BloxCord will automatically send invitations to anyone in your Roblox group who meets the minimum rank you set. Choose a minimum group rank between 0 and 255. Enter **0** to invite everyone in the group. Invited members receive an invitation in their organizations list and can choose when to accept. No one is added without their approval. # Notifications Source: https://docs.bloxcord.net/settings/notifications Choose exactly which events send direct messages to your members. Enable or disable individual notifications with a single toggle, giving you complete control over what BloxCord communicates, no code or setup required. Notifications settings DMs a member when their leave request is approved or denied. DMs a member when their leave begins and when it ends, including early ends. DMs a member when a reputation point is added or removed from their profile. DMs a member when their points balance changes. DMs a member when they're punished. The moderator is never shown, only the type, reason, and duration. # Permissions Source: https://docs.bloxcord.net/settings/permissions Build roles that fit your organization. Create up to 50 roles, give each one a name and color, organize them into departments, and define exactly what they can do. Roles can be linked directly to your Roblox group or Discord, making permission management simple and centralized. Roles and Permissions general tab Every role gets its own name and hex color. Colors show up next to members across the dashboard and logbook, so at a glance you know who's who. Group roles into departments to compartmentalize permissions, quotas, and entities. Perfect for keeping Moderation, Admin, and Staff cleanly separated. ## Permissions On, Permissions Off Every permission at your fingertips. Enable or disable permissions with a single click, and use search to instantly find exactly what you're looking for. **Permission Highlights** gives you a live summary of everything the role can do, including a running count of granted permissions and clear warnings for **Dangerous** permissions, so you always know when a role has elevated access. Permissions tab with dangerous permission highlights ## Bind Roles Your Way Head to the **Rank Binds** tab and connect each role to the source that makes sense for your community: Bind a role directly to a Roblox group rank. When someone hits that rank, they get the role automatically. Prefer Discord? Bind straight to a Discord role and let your server handle who gets what. ## Stop the Spam with Ratelimits Worried about someone spamming sensitive actions? The **Ratelimits** tab lets you control how often members with a role can perform high-impact actions, helping prevent abuse before it becomes a problem. Set limits for actions such as: * Rank Changes * Creating, Editing, Reverting, or Deleting Logbook Entries * Revoking Game Bans Whether it's preventing accidental misuse or slowing down malicious activity, rate limits add an extra layer of protection to your organization without getting in the way of day-to-day operations. Ratelimits tab for sensitive actions ## Simulate Any Role Not sure what a role can see? Use **Simulate** on the top right to preview BloxCord exactly as that role would. No guessing, no second-guessing permissions, just confidence before you publish. # Roblox Integration Source: https://docs.bloxcord.net/settings/roblox-integration Connect your Roblox group and let BloxCord do the rest. With an Open Cloud API key and an organization cookie, BloxCord can rank members, manage bans, detect alternate accounts, and perform actions on your behalf, all without leaving the dashboard. Roblox Integration settings ## Open Cloud API Key Your Open Cloud API key is BloxCord's direct connection to Roblox. It allows BloxCord to securely communicate with Roblox through the Creator Hub, unlocking core features across the platform. We recommend configuring one even if you don't plan on ranking members, as it's the safest and most reliable way to authenticate. Create the key in the [Roblox Creator Hub](https://create.roblox.com/dashboard/credentials) with **Groups** and **User Restrictions** set to **Read & Write**. It's verified with Roblox before we store it, and it's encrypted at rest. **What Open Cloud unlocks:** Promote, demote, suspend, and set member ranks directly in your Roblox group from anywhere in BloxCord. Ban a player across every alt account they own straight from the logbook, powered by Roblox's Alt Bans API. ## Organization Cookie Not everything is available through Open Cloud yet. For those features, BloxCord uses a **.ROBLOSECURITY** cookie from a dedicated bot account that you control. Configure it once alongside your Open Cloud API key, and every Roblox integration in BloxCord is ready to go. Use a dedicated bot account with only the ranking permissions it needs, never your main. The cookie is encrypted and never shown again after you save it. # Configuration Source: https://docs.bloxcord.net/shift-management/configuration Manage every aspect of your shift system, from scheduling and staffing to clock-ins and settings. ## Create a Shift in One Click Need a one-off shift? Click **New Shift**, enter a name, start and end time, and capacity, then publish it instantly. No spreadsheets or back-and-forth required. New shift creation modal Creating a shift only takes a few fields. Add a name, define the schedule, set the capacity, and you're done. Choose exactly how many members can claim a shift before it's full. Capacity is enforced automatically as members claim their spots. ## Recurring Templates For shifts that repeat, create a recurring template once and let BloxCord generate every future shift automatically. Recurring shift templates Choose the days, start and end times, and capacity. BloxCord automatically creates every recurring shift on schedule. Update timing or capacity on a template and future shifts follow instantly. ## Reports The **Reports** tab turns every clock-in into meaningful insights. Track attendance, shift completion, and hours worked for every member over a rolling time period. GA Shifts reports view Key metrics are always front and center. Instantly see total shifts, unique workers, hours logged, and average hours per worker for the selected reporting period. Every worker ranked by hours, with **Attendance** and **Completion** bars showing exactly how reliable they've been over the selected period. ## Group Settings Click **Settings** at the top of any shift group to fine-tune how it operates. Every rule, limit, and reward for the group lives here. Rename the group, update its description, and set worker limits like **max claims per day and per week**, the **late clock-in window**, and how many days ahead workers can claim shifts. Require workers to request coverage before unclaiming, so nobody bails right before a shift starts. They stay on the shift until someone else claims it or an admin steps in. Choose your own coverage window in minutes. Let clocked-in workers pause their active time when they step away. Break time is subtracted from active time in reports, so hours logged stay honest. Reward workers automatically when they clock out, based on their active shift time. Set your **points-per-hour** rate and a **minimum active time** so short shifts don't get rounded up to a full reward. Connect your Discord webhook templates to shift events. Fire notifications on **Clock In**, **Clock Out**, **Shift Completion**, and **Coverage Requested**, all with your own template through BloxCord. The header keeps your group's rules within easy reach. Instantly see the late clock-in window, daily and weekly claim limits, and how far in advance shifts can be claimed. ## Access Control Every shift group has its own access controls. Open the **Access** tab to decide exactly who can view, claim, manage, and modify shifts within that group. Access Control panel for a shift group Control **View shifts**, **Self-claim shifts**, **Manage workers**, **View reports**, and **Modify schedule** independently, so people only get what they need. Every action is a three-state toggle. Inherit from your organization defaults, explicitly Allow, or hard Deny for tight control. Assign permissions on a role-by-role basis. Override the default access for any role, making it easy to give administrators full control while keeping members limited to claiming shifts. Access Control builds on your organization's existing permissions. Members must already have the `tab.shifts.view` permission before any role-specific overrides can take effect. # Shifts Source: https://docs.bloxcord.net/shift-management/shifts Shifts keeps your organization running on time. Schedule shifts, claim openings, clock in and out, and keep every hour accounted for, all from one place. Shifts must be enabled before shift data can be tracked and displayed. Visit the Features tab to get started. Shifts landing page with groups list Start on the **Groups** tab to see every shift group you have access to. Pick a group to view its schedule, or jump straight to **My Shifts** to focus on your own. All the shift groups you can view sit right here, whether it's your department, a specialized unit, or organization-wide coverage. With the right permissions, launch a brand new shift group in seconds with the **New** button. ## Your Personal Schedule **My Shifts** gives you a complete view of your schedule. Keep track of your upcoming shifts, claimed shifts, and shift history, all in one place. My Shifts view showing in progress, upcoming, and recent shifts See your active shift the moment you clock in, so you always know the clock is running. Every shift you've claimed, ready when you are. **Unclaim** or request coverage in a single click if plans change. Your full history at a glance. Review past shifts, times worked, and total durations. ## Inside a Shift Group Open any group to view its full schedule. See every upcoming shift, who's already claimed one, and which openings are still available. GA Shifts group schedule view Claim any available shift in seconds. Live capacity counters show exactly how many spots remain before a shift fills up. Select a shift to view everyone who's on it. The full roster is always available before your shift begins. Members with the appropriate permissions can cancel any shift when plans change, keeping schedules accurate and everyone informed. **In progress**, **Upcoming**, and **You** tags make it obvious what's live, what's next, and what's yours. # Troubleshooting Source: https://docs.bloxcord.net/troubleshooting Running into something unexpected? You're in the right place. Below are answers to the most common questions and issues you may encounter while using BloxCord. If you can't find what you're looking for, join our Support Server and our team will be happy to help. ## Roblox & Usernames Some behavior in BloxCord depends on data we fetch from Roblox. Because Roblox enforces strict rate limits on their public APIs, certain information may take time to appear or update. Due to rate limits enforced by Roblox, we sometimes can't immediately identify a Roblox account's username. The username should come up eventually, as it is queued in our internal systems and will be resolved as capacity frees up. We strive to abide by Roblox's Acceptable Use Policy, which involves respecting their rate limits. Due to rate limits set by Roblox, we're unable to constantly fetch your username from Roblox. Usernames are stored in a cache with a high, variable TTL (time to live), so an updated username can take a while to propagate through BloxCord. If it has been more than 3 days and your username has not been updated, you can usually trigger a refresh by contacting us in our Support Server. We will invalidate your cache if conditions permit.  A **cache** is a temporary store of data that lets us serve information quickly without asking Roblox for it every time. Instead of making a fresh request on every page load, BloxCord keeps a copy of the data for a period of time known as the **TTL** (time to live). > In simple terms, Roblox does not allow us to constantly get information from them, so we have to save information each time we get it and reuse it for a while before asking them for it again. * **Short TTL:** data refreshes often, but uses more of our Roblox rate limit budget. * **Long TTL:** data stays cached longer, which is faster and safer for rate limits, but changes on Roblox may take a while to show up in BloxCord. For values like usernames, we use a long, variable TTL to stay well within Roblox's limits, which is why occasional delays are expected. ## Still Stuck? Our team and community are ready to help. Drop a message and we'll get you sorted. # Handbooks Source: https://docs.bloxcord.net/untitled-page BloxCord keeps your entire organization organized. From forms and rules to handbooks and operational documents, everything lives in one secure place. Organize documents by department and give your team a single, trusted source for policies, procedures, and everything they need. Handbooks must be enabled before handbooks can be created, viewed, or managed. Visit the Features tab to get started. Handbooks dashboard showing documents grouped by department ## Locked Down by Default Every handbook is locked to the people who are supposed to see it. Access is tied directly to your permission groups, so the right team members get in and everyone else stays out. No accidental leaks, no wondering who can read what. Restrict each handbook to specific groups or roles. If they don't have access, they don't even know it exists. Separate documents by category to keep information organized, accessible, and easy to manage. ## Advanced Access Logs Nothing happens without a trail. Every document open, view, and screenshot is automatically logged, giving administrators complete visibility into how sensitive documentation is accessed. See exactly which user opened the document and when, right down to the timestamp. Track whether they actually inspected the page or just skimmed and closed it. BloxCord detects when a screenshot is taken on a protected handbook and logs the event. Every time a document is viewed, BloxCord generates a unique fingerprint tied to that viewing session. If anything is leaked, administrators can easily trace it back to the exact user and specific viewing instance. ## Built to Prevent Leaks Sensitive documents deserve more than basic access controls. BloxCord includes built-in protections to help keep your handbooks and internal documentation where they belong. Invisible identifiers are embedded into every document view, allowing administrators to trace leaked screenshots back to the user who captured them. Copying, text selection, and right-click actions are disabled to help protect sensitive documentation from casual sharing. # Views Source: https://docs.bloxcord.net/views Views turn your organization's data into answers. Build custom reports for any group of members, choose exactly what to display, and share them only with the people who need access. Every view is fully customizable, permission-controlled, and updates automatically as your data changes. Views must be enabled before custom views can be displayed. Activity Quotas must also be enabled to generate quota views. Visit the Features tab to get started. Views dashboard showing an Organization Quota aggregation report with compliance widgets, LoA overview, and a per-player table ## Anything You Want, For Whoever You Want Every view is built around four simple decisions: who to include, which columns to display, which widgets to summarize the data, and who can access it. Create as many views as you need, switch between them in seconds, and get the insights you're looking for without digging through raw data. Build reports for exactly the members you care about. Target a single rank, a range of ranks, a custom BloxCord role, or your entire organization. Views only open for the people you explicitly allow. Sensitive reports stay invisible to everyone else, no exceptions. Track compliance, activity, leave of absence status, sessions, punishments, and more across the entire group, all refreshed on demand. The same view, different time periods. Instantly switch between the current segment, last segment, or a custom date range to compare trends over time. ## Configure Every Detail Open **View settings** to shape a view exactly the way you want it. Four tabs, four areas of control. ### General Name the view, pick an icon, and choose an accent color so it stands out in the switcher. Small touches that make your dashboard feel like yours. View settings General tab with title field, icon picker, and accent color palette ### Audience **Choose exactly who belongs in the report**. Combine BloxCord roles with Roblox group ranks, from Member all the way to Owner, and every matching member is included automatically. View settings Audience tab showing BloxCord roles and Roblox group ranks that define the target group ### Columns Build a table that fits your workflow. Choose up to 25 columns, arrange them in any order, and pull from categories like Identity, Status, Activity, Sessions, Moderation, and more. View settings Columns tab with ordered columns for Rank, Quota, LoA Status, Active Minutes, Sessions Hosted, and Punishments Received ### Widgets Summarize your data before you dive into the details. Add up to 10 widgets above the table, including Quota Compliance, Leave of Absence Overview, Activity Overview, Country Distribution, Online Hours, Logbook Summary, Leaderboard, and more. Resize each widget to show as much or as little detail as you need by clicking the width. View settings Widgets tab with Quota Compliance and LoA Overview widgets configured above the table ## Deep Dives, Not Data Dumps Every view is designed to answer real questions fast: See every member behind the numbers. Ready to click into. The LoA Overview shows current absences and upcoming return dates for the whole group. Sort by active minutes, sessions hosted, or peak hour to surface your highest performers instantly. No two organizations work the same way, and your reports shouldn't either. Build as many views as you need, customize every detail, and create reports that answer the questions your team actually asks. # Webhooks Source: https://docs.bloxcord.net/webhooks Stop copying webhook URLs into a dozen different places. Link your Discord channels to BloxCord once, create reusable message templates, and send perfectly formatted logs, notifications, and updates from one dashboard. Webhooks must be enabled before webhook notifications can be sent or managed. Visit the Features tab to get started. Discord webhooks linked in BloxCord Keep every webhook organized. Every webhook you connect appears in one clean dashboard, showing the Discord server, channel, purpose, and when it was last used. Whether it's for shift completions, ModCalls, coverage requests, or anything else, you'll always know exactly what each webhook is responsible for. BloxCord can also power its own features through these webhooks. Route shift logs, session updates, moderation actions, and other events to any connected webhook, ensuring every notification is delivered to the right Discord channel automatically. ## Reusable Templates, Zero Repeat Work Why build the same message twice? Design a template once and reuse it anywhere in BloxCord. Create fully formatted Discord messages with embeds, colors, timestamps, variables, and more, then send them with a single click. Whether it's a Shift Completion, Coverage Requested, or Session Notification, your templates are always ready to go. Reusable message templates ## Craft It. Preview It. Ship It. Create messages with confidence. Write your message, add up to 10 embeds, customize every detail, and watch a live preview update as you type. What you see is exactly what Discord receives. Webhook template editor with live preview Titles, descriptions, colors, URLs, timestamps. Design embeds that actually look good. See your message render in real time as you build it. No test sends required. Override the webhook's username or avatar per template for extra polish. Stack up to 10 embeds in a single message for complex, structured notifications. ## Variables That Do the Annoying Work Need your messages to include live data? Variables let you automatically insert information into any message or embed, so you never have to type the same details twice. Whether it's user information, shift details, session data, moderation records, or organization information, BloxCord fills everything in when the message is sent. Simply type `{` in any field to browse available variables with autocomplete. Every variable includes a description, making it easy to find exactly what you need without memorizing names. Since variables are context-aware, you'll only see the ones that are available for the template you're editing. # Welcome Home Source: https://docs.bloxcord.net/welcome-home Your personal dashboard within your organization. See your standing at a glance and jump straight into the tools you reach for the most, all from one place. Welcome Home dashboard Welcome home. View your standing at a glance and jump straight into the tools you reach for the most, whether that's opening a Player Audit, checking your Quota, filing a Leave of Absence, or peeking at the Leaderboard. It's your dashboard, personal to you, tuned to your role, and built to keep everything you need one click away. # Welcome to BloxCord Source: https://docs.bloxcord.net/welcome-to-bloxcord BloxCord is an all-in-one management platform and Discord bot built for Roblox groups, offering member ranking, moderation, logbooks, live analytics, automation, and more, all from one place. Connect your Roblox and Discord accounts to get started with BloxCord. Set up your Roblox group as an organization and invite your team. Track member activity, events, and moderation actions in one place. Manage member ranks and promotions directly from Discord # Why BloxCord Source: https://docs.bloxcord.net/why-bloxcord Built for organizations that need more. BloxCord combines moderation, staffing, automation, game integrations, documentation, and much more into a single platform, eliminating the need for dozens of disconnected tools. ## Built Different Every feature is designed with depth in mind. From granular permissions to detailed audit trails, BloxCord goes further than any other platform to give you complete control over your organization. Configure everything. Toggle features on or off, customize forms, build your own rules, define session types, set nickname templates, and shape BloxCord to fit exactly how your group operates. Rate limiting, permission-based access control, audit logs, and secure API keys keep your data and your community safe. Every action is tracked, every access is verified. Features you won't find anywhere else. Period. BloxCord ships tools that redefine what a moderation platform can do, not just what one should do. ## Features That Go Further Replay any session exactly as it happened in-game. See player positions, actions, and scene context in a fully interactive viewer to understand exactly what occurred from start to finish. Watch your servers in real time. See who's online, what they're doing, and jump into action instantly. Live data, live decisions. Verify your members with a secure age verification flow built directly into your organization. Confirm eligibility while keeping the process fast and easy for your members. Handle in-game moderation calls with full context, assignment, and resolution tracking, all inside BloxCord. ## The Whole Package Track playtime, manage session types, and enforce quotas with ease. Build any form you can imagine, collect responses, and manage them all in one place. Publish your rules and handbooks so every member always knows what's expected. A clean workflow for members to request time off and for staff to approve it. Send real-time events anywhere with customizable templates. Build your own tools on top of BloxCord with Game Keys, Auth Keys, and full request logs. ## Why Groups Choose BloxCord Whether you have 10 members or 10,000, BloxCord scales with your organization. Every feature is built to handle real-world load without slowing down. Permissions, rate limits, feature toggles, and access control mean you decide exactly who can do what. No surprises, no compromises. BloxCord is designed from day one for Roblox communities. Every feature, every integration, every workflow is tailored to how your group actually operates. New features, refinements, and improvements land constantly. BloxCord is the platform that keeps getting better. ## Ready to See for Yourself? Explore the rest of the docs to see everything BloxCord can do, or jump straight in and set up your organization. Either way, welcome to the platform your community deserves. # Your Activity Source: https://docs.bloxcord.net/your-activity See everything you've been up to in one place. Track recent sessions, game activity, and your progress over time. Gameservers must be configured before activity can be tracked and displayed. Visit the Features tab to get started. ## Overview Open the page and you're greeted with a full snapshot of your recent activity. Totals for playtime, sessions, and other key metrics pulled straight from your recent sessions, so you always know where you stand. Activity overview Playtime, session counts, and activity metrics that refresh as you play. See how this week compares to last, so you can track your consistency over time. Know at a glance whether you're on track for your requirements or falling behind on minutes. Numbers are pulled directly from your in-game sessions. No manual logging required. ## Game Joins Scroll down and the story keeps going. A detailed log of every game join and session, so you can retrace your steps whenever you need to. Game joins and session log Each entry shows when you joined, how long you stayed, and which server you were on. Perfect for verifying your own hours, reviewing what you got up to during your last shift, or catching any discrepancies before someone else does. Every join is timestamped and logged, so you have a complete play history. See which server each session took place in, useful for cross-referencing events. # Your Cooldown Source: https://docs.bloxcord.net/your-cooldown See your current promotion cooldown, review recent rank changes, and always know where you stand in your promotion cycle. Promotion Cooldowns must be configured before cooldowns can be displayed. Visit the Features tab to get started. ## Are you on cooldown? The moment the page loads, you'll see whether a promotion cooldown is currently active on your account. Your cooldown and recent rank changes Your next eligible promotion date is always front and center, so you can plan ahead with confidence. You're eligible for your next rank change. Time to earn it. Cooldown lengths and rules are configured by your organization's leadership. What you see here reflects your group's current settings, so if the numbers feel off, that's the place to ask. # Your Friends Source: https://docs.bloxcord.net/your-friends Ever feeling lonely? Friends is your circle at a glance. See who you've played with, who's online right now, and who's worth reconnecting with. Guest Features must be enabled before friend data can be displayed. Visit the Features tab to get started. Friends page showing members from your organization See which friends are online right now and ready to jump back into the action. View friends who recently played, making it easy to reconnect even after they've logged off. See the people you've crossed paths with most recently across your organization. View your most reputable friends at a glance.