Connecting a Template game to the platform

The Template as the Blockout SDK: the game-key connection for market reads, feedback, the game's own analytics and the staff Platform tab, its setup and what is still planned.

Roblox Template

The Template is the Blockout SDK. Its PlatformService connects a game's server to the platform's developer API using that game's key, and every game built on the Template gets it by switching platform on: there is no separate package. It supports market and tracked-game reads, player feedback into the game's hub, and the staff Platform tab. Reads of the game's own analytics and feedback are built into the Template and wait for the platform to release their routes; a general Roblox proxy is still planned.

What the bridge provides today

Game-key identity

A key belongs to one platform game. The server sends it to https://studio.blockoutgames.com/developer/v1 as a Roblox Secret header. It never goes through a client remote or replicated config. The /key read reports the game identity and rate limit.

Market and tracked-game reads

Game code can call key, games, game, history, genres, market and limiteds. These read the platform's tracked market data. A tracked game's detail and history are different from private analytics about that game's own players, retention or revenue.

Player feedback

The Feedback window, opened from the Feedback button in Roblox's top bar beside Settings (not from the menu), sends category and text to the game server, which fills in the player, place and version. The platform stores the message in that game's hub Feedback tab, where authorized studio members triage it.

A shared read cache

Servers coordinate through a MemoryStore lease and cache. Game servers use cached answers rather than each spending the game's request allowance independently. Feedback writes and transfer calls are never cached, but each also takes a turn from a count every server shares (one entry a minute in the same MemoryStore map): 30 feedback sends and 30 transfer calls a minute for the whole game, so at least 60 of the key's 120 requests a minute stay for reads however many servers run.

The game's own analytics and feedback

analytics(range) and feedbackList(query) read the key's own game's owned analytics (daily users, retention, revenue and more) and the feedback its players sent, through /game/analytics and /game/feedback. See The key's own game.

The staff Platform tab

In the admin panel, for staff only and only with platform on: the key's game and limit, players now, every owned metric in groups with sparklines over 30 or 90 days, who plays, the key's requests and the cache. See The staff Platform tab.

The staff Feedback tab

The game's feedback, each with the sender's picture and names, filtered for the reader, by status and category, read only. See The staff Feedback tab.

A Template game and the platform share one game-key boundary. A player's Feedback window sends category and text to its game server. PlatformService adds server-known identity and sends the message with the game's secret key to the developer API, which records it in that game's hub. Server gameplay reads market data through PlatformService and its shared MemoryStore cache. The key stays on the server and the platform checks it on outbound API requests.

Setting up the connection

  1. Create a key for the correct game

    Open the game's Developer tab on the platform and create its key. Copy it while it is shown; the full value is not displayed again. See Getting a key for permissions, rotation and revocation.

  2. Add the Roblox secret

    Store the value under BlockoutApiKey, scoped to domain studio.blockoutgames.com, in the experience's Creator Dashboard Secrets. For Studio, add a Local Secret under Experience Settings, Security. Local secrets belong to that machine and do not configure live servers.

  3. Enable HTTP and the optional system

    Turn on Allow HTTP Requests in the experience's Security settings and set platform = true in the game's src/core/shared/Config/Overrides/Features.luau. Publish the game's build using its normal release procedure. Do not put the key value in source, config or a place file.

  4. Check from an authorized game server

    Run the staff platform command. Check the reported game, request limit, cache state and last error. Try a market read and send a harmless test feedback message, then confirm it appears in that game's hub.

With no secret, startup warns once and calls return unavailable; the rest of the game can play. With platform off, calls return switched_off, and its service lifecycle, Feedback window, top-bar Feedback button and command are skipped. PlatformService sends every request through server/Roblox/Http, the one module the Template's boundary linter lets make HTTP requests or read a secret.

Calling the service from game code

Reads and feedback sends can yield and return Result; call them from start() or a spawned thread, never a non-yielding init(). The diagnostic status() method is synchronous. A read's success is { value, stale, storedAt }, so the payload is at result.value.value. Unknown API values stay nil; absence does not mean zero.

A small server-side market read
local PlatformService = require(script.Parent.PlatformService)task.spawn(function()	local result = PlatformService.games({ sort = "growth_24h", limit = 10 })	if not result.ok then		warn(`[Market] {result.reason}`)		return	end	for _, tracked in result.value.value.items do		print(tracked.name, tracked.ccu)	endend)

Requests have bounded retries and route-specific validation. The cache defaults are 60 seconds fresh for games, game detail and the feedback list; 300 for history, genres, market, limiteds and key usage; 600 for analytics and breakdowns; 1,800 for the key (its game never changes). Stale answers remain eligible for up to 3,600 seconds. A shared lease lasts ten seconds and waiters poll every half-second for up to three seconds. A failed MemoryStore falls back to this server's local cache. See the service guide for its complete methods, reasons and setup, and service architecture for lease mechanics and adding routes.

How player feedback reaches the game hub

Players choose Bug, Idea, Balance, Praise or Other and send 1–2,000 characters after trimming. The internal Idea category is suggestion. RemoteGuard validates the category and up to 8,000 UTF-8 bytes before the handler performs character and rate checks.

The server supplies playerId, placeId and serverVersion; the client cannot nominate another player. One generated idempotency key covers all retries of the send. A successful receipt means the platform accepted the write, and only then is feedback_sent logged with the category. Authorized studio members can see and triage messages in the game hub Feedback tab.

The remote's short bucket allows one send then refills over 30 seconds. Its hourly bucket has capacity ten and refills at ten tokens an hour; these are token buckets, not a fixed calendar-hour reset. Both are kept per user id for the server's life. A token is spent only once the platform took the feedback or refused what the player wrote: invalid text, a missing secret, an outage or a key problem keeps the player's budget. One send per player is in flight at a time, a server's players together send at most ten a minute (feedbackPerServerMinute), and every server of the game together at most 30 (feedbackPerGameMinute), both taken before the send. Direct server calls to sendFeedback do not use the remote's player limits; game code must avoid uncontrolled calls.

The staff platform command

platform is a staff command in the Server category, registered only when the feature is on. It shows whether a key is configured, the key's game and limit through the cached /key read, cache hits, misses (with how many a 304 answered) and stale replies, shared-cache errors and the last request error. It never prints the secret.

SymptomWhat to inspect
unavailableSecret name and whether it was set for this live experience or local Studio machine.
unreachableAllow HTTP Requests and the transport error.
unauthorized, or a stale key result with a 401 in diagnosticsRotation, revocation, the game being unlisted, and whether this running server still holds its old secret.
rate_limitedDistinct query count and other users of the same game key.
Shared-cache errorMemoryStore availability; local caching continues with a separate fetch per server.

Running servers keep the secret read at initialization. After rotating a key, update Roblox's secret and replace old servers using the game's normal migration/release process. A cached success can delay discovery of the old key's rejection; do not use a cached identity read as proof that the replacement secret was loaded.

Planned: Roblox proxy services

The game's own analytics and feedback reads are served by the platform since 2026-11-03. Beyond them, the founder's direction is a broader bridge: the platform proxying Roblox data that game servers cannot fetch directly, and further feedback services.

A proxy needs its own request budget, caching and a written design decision before implementation. It must not consume the collector's Roblox allowance without accounting for it; the collector's history cannot be backfilled. New private game-facing capabilities must also define the game-key ownership boundary and permissions before being described as available.

The Template source note is docs/systems/Platform.md; why the platform is reached through one service and a shared read cache is its line in ARCHITECTURE.md Decisions.

Updated