Install the SDK, create a key, and ship live Roblox infrastructure.

Quickstart

Run a live API self-test inside Roblox Studio.

1. 1

   Create an account, verify email, set a password, and enable Google Authenticator from Security.

2. 2

   Create a live key from Keys. The raw key is shown once, then stored only as a hash on the VPS.

3. 3

   Add the Lua SDK as a ModuleScript named RobloxAPIs in ServerScriptService.

4. 4

   Call RunStudioSelfTests from a server script to validate safe write/read flows across the live APIs.

local HttpService = game:GetService("HttpService")
local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

local summary, err = client:RunStudioSelfTests({
  userId = 156,
  renderSign = true
})

if err then
  warn("RobloxAPIs self-test failed to start", err.statusCode)
  return
end

print(HttpService:JSONEncode(summary))

Install SDK

Roblox Lua ModuleScript

The SDK is hosted at /sdk/robloxapis.lua. Paste it into a ModuleScript named RobloxAPIs. Server-side placement is recommended so live keys never enter client scripts.

Studio self-test

One call validates the current live API surface.

RunStudioSelfTests writes temporary test data, reads it back, and cleans up the records that should not remain active. It currently covers Experience Config, Storage Vault, Cross-Game Ban, Trade Guard, Receipt Ledger, Entitlement Mirror, Inventory Snapshot, Quest Templates, Progression Cloud, Group Sync, Economy Guard, Session Analytics, Feature Flags, Player Segments, Leaderboards, Cooldowns, Webhook Events, Live Messaging, Matchmaking Queue, and Server Directory.

Authentication

API keys are separate from website sessions.

In-game requests authenticate with either an Authorization bearer token or an X-API-Key header.

Authorization: Bearer rba_sk_live_your_key
X-API-Key: rba_sk_live_your_key

Physically testable API

Experience Config API

This API stores a live configuration payload and reads it back from Roblox Studio. The SDK helper can render that payload onto a sign so the test is visible in the game world.

client:SetExperienceConfig("studio-sign", {
  title = "Roblox APIs Live Test",
  message = "Fetched live from robloxapis.com",
  accent = "#20E3B2",
  variant = "success"
})

local rendered, err = client:ApplyExperienceConfigSign("studio-sign", {
  position = Vector3.new(0, 6, 0)
})

Trade safety

Trade Guard API

Trade Guard verifies a player-to-player trade before the game finalizes it. It stores the trade id once, detects duplicate submissions, scores suspicious value imbalance or rapid trade velocity, and returns a decision the server can enforce.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

local result, err = client:VerifyTrade({
  tradeId = tradeId,
  fromUserId = sender.UserId,
  toUserId = receiver.UserId,
  offeredItems = {
    { itemId = "crystal_sword", quantity = 1, value = 1200 }
  },
  requestedItems = {
    { itemId = "gold_pack", quantity = 1, value = 900 }
  }
})

if err or result.decision == "block" or result.decision == "review" then
  return false
end

Monetization safety

Receipt Ledger API

Receipt Ledger stores developer product receipts once. The first verification returns duplicate: false; later calls with the same purchase id return duplicate: true so grants stay idempotent.

local MarketplaceService = game:GetService("MarketplaceService")
local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

MarketplaceService.ProcessReceipt = function(receiptInfo)
  local result, err = client:VerifyReceipt(receiptInfo, {
    grant = "vip_pack",
    metadata = { source = "ProcessReceipt" }
  })

  if err then
    return Enum.ProductPurchaseDecision.NotProcessedYet
  end

  if not result.duplicate then
    -- Grant the product here.
  end

  return Enum.ProductPurchaseDecision.PurchaseGranted
end

Shared player inventory

Inventory Snapshot API

Inventory Snapshot mirrors item ownership, quantities, attributes, metadata, and equipped loadout slots under the shared workspace quota. Use it when multiple places need the same player inventory view without duplicating item state in every experience.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:SetInventoryItem(player.UserId, "crystal-sword", {
  type = "weapon",
  quantity = 1,
  attributes = {
    rarity = "rare",
    power = 120
  }
})

client:UpdateInventoryItem(player.UserId, "crystal-sword", {
  equipped = true,
  loadoutSlot = "primary"
})

local inventory, err = client:ListInventory(player.UserId, {
  itemType = "weapon",
  equipped = true
})

In-game telemetry

Session Analytics API

Session Analytics stores player and server events with session ids, event types, numeric values, and custom properties. Use it for round completion, onboarding funnels, retention signals, map performance, and other server-authored events that should be queryable outside Roblox DataStores.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:TrackAnalyticsEvents({
  {
    eventId = "join_" .. player.UserId .. "_" .. game.JobId,
    userId = player.UserId,
    sessionId = game.JobId,
    eventType = "session_started",
    value = 1,
    properties = {
      map = workspace:GetAttribute("MapName")
    }
  },
  {
    eventId = "round_" .. player.UserId .. "_" .. os.time(),
    userId = player.UserId,
    sessionId = game.JobId,
    eventType = "round_completed",
    value = 120,
    properties = {
      result = "win"
    }
  }
})

local summary, err = client:GetAnalyticsSummary({
  sessionId = game.JobId,
  sinceMinutes = 60
})

Experiments and live ops

Feature Flags API

Feature Flags stores rollout definitions and returns deterministic player assignments. Use it for A/B tests, seasonal toggles, economy tuning, UI variants, beta access, and emergency kill switches without publishing a new Roblox build.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:SetFeatureFlag("double-xp", {
  enabled = true,
  defaultVariant = "control",
  rolloutPercent = 50,
  variants = {
    { key = "control", weight = 50, payload = { multiplier = 1 } },
    { key = "treatment", weight = 50, payload = { multiplier = 2 } }
  }
})

local result, err = client:GetFeatureAssignment("double-xp", player.UserId)
if not err then
  local assignment = result.assignment
  player:SetAttribute("XpMultiplier", assignment.payload.multiplier or 1)

  client:TrackFeatureExposure("double-xp", {
    exposureId = "double-xp-" .. player.UserId .. "-" .. game.JobId,
    userId = player.UserId,
    variant = assignment.variant,
    sessionId = game.JobId
  })
end

Cohorts and targeting

Player Segments API

Player Segments lets a game evaluate reusable cohorts in one request. Use it for VIP access, beta groups, event targeting, returning-player bonuses, risk buckets, high-level matchmaking pools, or targeted Feature Flags rollouts.

• Player Segments API allows manual memberships for hand-picked users.
• Player Segments API allows rule-based cohorts using traits like level, region, spend, accountAgeDays, or nested paths like stats.wins.
• Player Segments API allows one in-game call to evaluate several segments and return the matched segment keys.
• Player Segments API allows temporary membership with expiration timestamps for events, private tests, or limited access.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:SetSegment("level-10-plus", {
  name = "Level 10+",
  enabled = true,
  rules = {
    mode = "all",
    conditions = {
      { trait = "level", op = "gte", value = 10 },
      { trait = "region", op = "in", value = { "na", "eu" } }
    }
  }
})

local result, err = client:EvaluateSegments(player.UserId, {
  segments = { "vip", "level-10-plus" },
  traits = {
    level = player:GetAttribute("Level") or 1,
    region = player:GetAttribute("Region") or "na"
  }
})

if not err and table.find(result.matches, "level-10-plus") then
  player:SetAttribute("EligibleForHardMode", true)
end

Competition and ranking

Leaderboards API

Leaderboards stores board definitions and player scores so Roblox servers can submit results, show top lists, and fetch a player's current rank without building ranking infrastructure from scratch.

• Leaderboards API allows seasonal, event, global, ranked-mode, or custom board definitions.
• Leaderboards API allows best-score, latest-score, or additive score behavior.
• Leaderboards API allows top-list reads for lobby UI, reward screens, and event boards.
• Leaderboards API allows player rank lookups immediately after a score update.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:SetLeaderboard("season-wins", {
  name = "Season Wins",
  sortOrder = "desc",
  scoreMode = "best",
  scoreType = "wins",
  resetInterval = "seasonal"
})

local result, err = client:SubmitLeaderboardScore("season-wins", player.UserId, wins, {
  displayName = player.Name,
  metadata = {
    mode = "ranked",
    season = "s1"
  }
})

if not err then
  print("Rank", result.entry.rank)
end

local top = client:GetLeaderboardTop("season-wins", { limit = 10 })

Timers and rewards

Cooldowns API

Cooldowns stores reusable timer rules and per-player claim state so Roblox servers can safely enforce daily rewards, spin wheels, ability timers, shop claims, and mission resets across every place in a universe network.

• Cooldowns API allows reusable rules with duration, scope, metadata, and enabled state.
• Cooldowns API allows one claim call to either grant the reward or return the remaining lockout time.
• Cooldowns API allows player cooldown status reads for UI countdowns and lobby reminders.
• Cooldowns API allows cooldown resets for moderation, support grants, testing, and seasonal migrations.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:SetCooldown("daily-reward", {
  name = "Daily Reward",
  durationSeconds = 86400,
  scope = "daily-reward"
})

local result, err = client:ClaimCooldown("daily-reward", player.UserId, {
  metadata = {
    reward = "coins_250",
    serverJobId = game.JobId
  }
})

if err then
  warn("Cooldown claim failed", err.statusCode)
elseif result.claimed then
  -- Grant the daily reward here.
else
  player:SetAttribute("RewardSecondsLeft", result.cooldown.remainingSeconds)
end

In-game progression

Progression Cloud API

Progression Cloud stores player level, XP, streaks, quests, and claimed rewards by season. Use PATCH for small in-game updates like quest progress or streak changes.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:SetProgression(player.UserId, {
  season = "s1",
  level = 1,
  xp = 0,
  quests = {
    daily_win = { progress = 0, goal = 2 }
  }
})

local updated, err = client:UpdateProgression(player.UserId, {
  season = "s1",
  quest = "daily_win",
  progress = 1,
  goal = 2,
  incrementXp = true,
  xp = 150
})

Policy graph

Group Sync API

Group Sync stores moderation and role policy for Roblox groups connected to a studio workflow. It is useful for shared moderator roles, linked universe lists, and deciding whether Cross-Game Ban enforcement should apply to a group network.

client:SetGroupPolicy(123456, {
  enforceCrossGameBans = true,
  trustedRoles = { "Admin", "Moderator" },
  linkedUniverses = { tostring(game.GameId) },
  notes = "Production policy"
})

Cross-server operations

Live Messaging API

Live Messaging stores short-lived announcements, event toggles, shutdown warnings, or admin broadcasts that game servers can poll by topic. Messages can be scoped by universe or server job, and revoked when an operation changes.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

client:PublishLiveMessage("event.double_xp", {
  enabled = true,
  minutes = 30
}, {
  priority = "high",
  ttlSeconds = 1800
})

local inbox, err = client:PollLiveMessages({
  topic = "event.double_xp",
  limit = 10
})

if not err then
  for _, message in ipairs(inbox.messages) do
    print(message.topic, message.payload.enabled)
  end
end

Queue handoff

Matchmaking Queue API

Matchmaking Queue creates short-lived party tickets with mode, region, skill, and party metadata. The API returns either a queued state or a matched handoff object that your server can use to coordinate the next teleport or server reservation step.

local RobloxAPIs = require(script.RobloxAPIs)

local client = RobloxAPIs.new("rba_sk_live_your_key")

local ticket, err = client:CreateMatchmakingTicket(player.UserId, {
  partyId = "party-123",
  party = {
    { userId = player.UserId, role = "leader", ready = true }
  },
  mode = "ranked_2v2",
  region = "auto",
  skill = 1200,
  autoMatch = true
})

if not err and ticket.ticket.status == "matched" then
  print(ticket.ticket.matchId, ticket.ticket.reservedServerCode)
end

API reference

Current v1 routes

Errors

Every failure returns JSON.

{
  "ok": false,
  "error": "invalid_api_key"
}

Security

Operational security rules for Roblox games.

Release process

Versioned routes, documented changes, and visible status.

Breaking API changes should ship under a new version path. Non-breaking SDK helpers can be added to the hosted Lua and JS SDKs. Product-facing changes are tracked in the changelog and service availability is summarized on the status page.