The backend your multiplayer game needs.
Player auth, persistent data, leaderboards, server registry, live config, economy, and matchmaking - one platform for Unity, Roblox, Godot, and custom game servers.
Stop stitching together auth, player storage, leaderboard logic, server discovery, and runtime config. Wire up one API and keep shipping gameplay.
Free forever on the Dev plan. No credit card required.
$ curl -X POST \
"$CRUX/v1/projects/$P/environments/$E/leaderboards/$B/entries/" \
-H "Authorization: ApiKey $CRUX_KEY" \
-d '{"player_id": "p_42", "score": 9001}'
HTTP/1.1 200 OK
{
"accepted": true,
"entry": { "player_id": "p_42", "score": 9001, "rank": 7 }
}import { CruxClient } from "crux-sdk";
const gsb = CruxClient.forPlayer(
"https://crux.supercraft.host", "YOUR_PROJECT_ID", "YOUR_ENV_ID", process.env.GSB_KEY,
);
const auth = await gsb.loginAnonymous();
await gsb.submitScore("global", auth.player_id, 9001);
const top = await gsb.getTop("global", 10);
console.log(`#${top[0].rank} ${top[0].player_id}`);using Supercraft.Crux;
var gsb = ServerToolkitClient.ForPlayer(
"https://crux.supercraft.host", "YOUR_PROJECT_ID", "YOUR_ENV_ID", apiKey);
var auth = await gsb.LoginAnonymousAsync();
await gsb.SubmitScoreAsync("global", auth.player_id, 9001);
var top = await gsb.GetTopAsync("global", 10);
Debug.Log($"#{top[0].rank} {top[0].player_id}");# Autoload Crux once via Project Settings → Autoload
Crux.init_player("https://crux.supercraft.host", "YOUR_PROJECT_ID", "YOUR_ENV_ID", api_key)
var auth = await Crux.login_anonymous()
await Crux.submit_score("global", auth.player_id, 9001.0)
var top = await Crux.get_top("global", 10)
print("#%d %s" % [top[0].rank, top[0].player_id])-- Server Script in ServerScriptService
local Crux = require(game.ServerScriptService.Crux)
local gsb = Crux.init("YOUR_PROJECT_ID", "YOUR_SERVER_TOKEN", "YOUR_ENV_ID")
game.Players.PlayerAdded:Connect(function(player)
local record = gsb:VerifyPlayer(player.UserId)
gsb:SubmitScore("global", record.player_id, 9001)
local top = gsb:GetLeaderboardTop("global", 10)
print(string.format("#%d %s", top[1].rank, top[1].player_id))
end)Most backend tools handle players. Most hosting tools handle servers.
Crux brings both together, so the runtime needs of multiplayer games stop living across custom scripts, ad hoc endpoints, and operational guesswork. One platform to authenticate players, store progression and shared game state, run leaderboards and seasonal resets, register and discover dedicated servers, deliver live configs, and keep staging and production separate.
Built for live games, not generic apps
Configs, player state, rankings, and server availability stay connected instead of drifting apart across five different tools.
Covers the runtime side too
Not just auth plus a database. Dedicated-server registration, discovery, live config, and matchmaking - the surfaces multiplayer games actually need.
Fewer platforms to stitch
Move faster without assembling separate vendors for auth, persistence, rankings, config rollout, and server discovery.
Cleaner rollout to production
Go from prototype to live without the backend becoming the part slowing down shipping. Environment-aware by design.
What you get
Enough breadth to run live operations, without dragging in a giant platform you do not need. Every feature is on every plan.
Player Authentication
Email and password, guest sessions, OAuth (Google, GitHub, Discord), and Roblox verification. Support real accounts, onboarding, and authenticated player access without building auth from scratch.
Persistent Player Data
Player-scoped and project-scoped JSON documents for progression, profiles, unlocks, event flags, inventories, and shared runtime values. Server-authoritative with patch semantics.
Leaderboards
Ranked and seasonal boards with configurable rules, fast ranking reads, recurring resets, and support for timed events or score-based loops. Anti-cheat friction on write.
Economy
Currencies, virtual items, and inventories with atomic updates for rewards, sinks, consumables, and grants. Every transaction audited server-side.
Dedicated Server Registry
Register, heartbeat, and search dedicated servers to power server browsers, active session discovery, region-aware listings, and stale cleanup.
Live Config Delivery
Upload versioned bundles and activate them per environment so balance changes, rotations, loot tables, and rulesets ship without a full patch.
Matchmaking
Queue by game mode and region, poll for your match, and get back the live server it was placed on - drawn from your own registry, so a crashed server is never a destination. Pairs players today. Manage the queue from the dashboard, including forming a match by hand.
Social
Friends, pending requests, and blocks. Drop-in social graph so your players can connect without a third-party identity vendor.
Stats & Achievements
Named counters the backend owns, so progression is something you can query rather than a blob you parse. Bind an achievement to a stat and a threshold and it unlocks in the same transaction as the write that earns it - the response tells you what was earned, once, so rewards cannot pay twice.
Built to watch a live game, not a generic app.
The dashboard observes your running game - player writes, server heartbeats, config pushes, and SDK quickstarts for every engine you ship on.
One API. Three auth modes.
API Key
Admin scripts, CI, tooling, and control-plane access.
Server Token
Dedicated game servers and trusted runtime services.
Player JWT
Authenticated players issued by the auth system.
Players, servers, and operators stay on separate trust boundaries while the surface area is simple enough to integrate with Unity, Roblox, Godot, or any HTTP client.
Example outcomes
- Player profiles and progression
- Guest-to-account upgrade flows
- Seasonal scoreboards and rank loops
- Server browser features
- Live event configuration
- Balance and loot tuning
- Server-authoritative reward systems
- Achievements that unlock off a counter
- Environment-aware staging and rollout
Relay Zero: a whole co-op game wired to Crux, in the open.
Snippets prove an API compiles. Relay Zero proves the architecture: a Godot 4 co-op extraction slice, about 4,000 lines of GDScript, MIT-licensed, where the same simulation runs offline and on an authoritative headless server.
What it demonstrates, in real code
- Trust boundaries that hold. Guest sign-in on the client; the server verifies every player token against Crux and match join tokens fail closed.
- An authoritative WebSocket server. Fixed 20 Hz simulation, 15 Hz snapshots, peer-bound input, so clients cannot drive another player's actor.
- Live ops without redeploys. Versioned config bundles with a last-known-good fallback, packaged defaults, and five ready-made live events.
- Server-owned progression. Loadouts, reward claims, and two leaderboards (weekly score, fastest run) are written by the server, never the client.
- A deploy story. Headless Linux export, Docker Compose, health check, and a browser client build.
Clone it, gut it, ship yours
It is a working foundation, not a finished game, and its README says exactly what is still missing. That is the point: every claim on this page is something you can read, run, and delete until only your game is left.
Built around multiplayer games, not generic app backends.
Most generic backends stop at auth and storage. Crux also covers the runtime needs of server-based games, with a better fit for live ops and environment-aware rollout.
Best suited for
- Dedicated-server games
- Multiplayer survival and co-op games
- Region-based game server fleets
- Unity, Roblox, Godot, and custom-engine backends
- Indie and mid-size studios that want backend velocity
- Teams that do not want to build a platform team before shipping gameplay
Less suited for
- Purely offline, single-player games
- Projects that only need a generic login database
- Highly specialized AAA matchmaking stacks from day one
Why say this clearly? Because the offer is stronger when it reads like a tool built for a specific class of multiplayer game, not a vague "backend for everything."
The stack you'd have built yourself.
Boring, proven components. No surprise vendor lock-in, no homegrown database engine.
| Component | Role |
|---|---|
| Go API server | Single binary API service |
| PostgreSQL | Primary data store with row-level security |
| Redis | Hot caches, rate limiting, matchmaking queues |
| Object storage | Versioned config bundle storage |
- Clean environment isolation. Production, staging, and test stay separated by design.
- Server-aware runtime APIs. Dedicated servers do not impersonate admin clients.
- Live-ops friendly. Configs, rankings, and player state fit together operationally.
- Stack-flexible. Use it with launchers, dashboards, custom tools, and game services.
Built so you never get stranded.
2025 and 2026 were brutal for indie backends - free tiers gutted, whole platforms shut down with weeks of notice, shipped games left broken. Crux is built to be the opposite: free forever, every feature, an open API, and your data portable on day one.
Free forever, every feature
The Dev tier is free forever - 10,000 MAU, unlimited projects, every feature unlocked. No feature gating, no credit card, and never auto-paused.
Open API, open source
Plain HTTP + JSON, and the SDKs plus the full API are open source on GitHub. No black box. Self-hosting the backend is on the roadmap.
Your data, always exportable
Every player, document, leaderboard, and config is readable through the same API you write with. Pull all of your data out, any time - no lock-in.
A written no-strand commitment
If Crux ever winds down, we commit to advance notice and an export window so your game keeps working. Read the sunset & export guarantee.
From the Crux Blog
All articles →Architecture guides, engine integrations, and vendor comparisons for indie multiplayer game devs.
Build the backend your multiplayer game actually needs.
Start on the free Dev tier - 10,000 MAU, unlimited projects, every feature. No credit card. Upgrade when your game takes off.