Private beta, now open for applications

Your game's backend,
already built.

Steam sign-in, leaderboards, live player events, cloud saves and a wiki built from your game's data, behind one API. Skip the server work and spend the time on your game.

Apply for beta access Read the API docs

Online features without the online work

In production since May 2024

Don't Die, Collect Loot signs its players in and broadcasts their player events through LongJump in its live Steam release.

20,940
Steam players
86,652
play sessions
189,441
player events

How it works

From launch to cloud save in three calls

  1. 1
    Sign in. When your game launches, get a ticket from Steamworks with GetAuthTicketForWebApi and start a play session.
  2. 2
    Listen. Open your game's event stream. Players hear about each other's boss kills, rare drops and new records the moment they happen.
  3. 3
    Save. Write your player's progress to a named slot, and it follows them to any machine. Scores and events work the same way.
app.longjump.dev
# 1. Start a play session with a Steam ticket
POST /api/v1/game_environments/{env}/steam_players
{ "identity": "my_game_client", "ticket": "14000000a7f3..." }

# 2. Open the event stream
GET  /api/v1/game_environments/{env}/mqtt
#    → where to connect, and your game's stream

# 3. Save to the cloud; it follows the player anywhere
POST /api/v1/game_environments/{env}/cloud_saves
{ "name": "slot-1", "isAutosave": true,
  "data": { "class": "Ranger", "floor": 12, "gold": 4810 } }

GDKs for

  • Unity
  • Godot
  • Unreal beta
  • C
  • .NET
  • Java
  • JavaScript
  • TypeScript
Call the API directlyPlain HTTPS from any engine, and an event stream over standard MQTT.Read the API docs Need another engine or language?We build new GDKs on request. Tell us what you build with.Request a GDK

Steam sign-in

Players sign in with a Steam auth ticket. LongJump verifies it with Valve, keeps their name and avatar fresh, and issues a token your game sends on every call. Your publisher key stays on the server, never in the build.

Separate environments

Development, staging, a demo and the full release each get their own Steam App ID, sessions, scores, saves and event stream. Playtests never touch production players.

GDKs for your engine

Client libraries for Unity, Godot, Unreal (beta), C, .NET, Java, JavaScript and TypeScript, with more on request. The Unity GDK adds sign-in that renews itself, player events that reconnect on their own, save slots and crash reporting.

Cloud saves

Named save slots that follow the player between machines, with every save kept. Keep a save private, or make it public so others can see a build, a run or a character.

Live player events

Broadcast what players do (a boss down, a rare drop, a new record) and every connected player gets it on the event stream, instantly. You decide what goes in the event and how the game reacts.

Admin console

Manage games, environments and leaderboards, look up players and their saves, run tournaments, and see activity across your games from one console.

Game wikis

Your game's wiki, written by your game

Point LongJump at your game's project and get a full wiki back. Then it stays right, every release.

Your game

  • Items.asset
  • Skills.asset
  • Sprites/

LongJump

  • Finds every kind of thing
  • Links every stat to its sources
  • Pulls icons from your art
  • Themes it like your game
wiki.yourgame.com

Your wiki

Game data

Stats, drops and requirements. Only LongJump writes it, so it's never wrong.

Your community

Guides, lore and strategy. Players write it, and the export never touches it.

Every release, the game data refreshes and every page that shows it updates. Renamed items keep their articles.

ddcl.wiki.longjump.dev
The Don't Die, Collect Loot wiki's main page, with its classes and Memories
A skill page on the Don't Die, Collect Loot wiki, with its infobox and effects

Live demo

Don't Die, Collect Loot

A Unity action RPG in Early Access on Steam. Classes, skill trees, items, monsters, bosses and quests, all built from the game's own data.

2,200+
articles
1,800
icons
24
page types
Open the wiki
nwrx.wiki.longjump.dev
The Ninja Warriors Again RX wiki's main page
The Kunoichi character page, with a moves table and stats

Live demo

The Ninja Warriors Again RX

A beat 'em up on a completely different engine (OpenBOR). Built the same way: characters, moves, enemies, bosses and stages.

52
articles
130
images
OpenBOR
engine
Open the wiki
  • Fandom-grade editing. Same engine as Fandom and wiki.gg, with the infoboxes, tabs and templates editors know.
  • Looks like your game. Theme from your palette, logo and fonts. Pixel art stays crisp.
  • On your domain. Serve it at wiki.yourgame.com, or on ours. Servers, backups and certificates are on us.

Leaderboards

From lifetime high scores to weekend tournaments

Over 700 kinds of leaderboard, out of the box. Yes, we counted. Pick one to see how it's built.

RankingHigherLower
KeepBestLatest
Tie-breakers012
ResetsNeverDailyWeeklyCron
OpenAlwaysWindowDates
AttemptsAny3
PlayersSteamGuests
Lifetime high scores Open

    Updates live as scores land

    • Live. Each board pushes changes to players the moment they happen.
    • Fair play. Score limits, safe retries, logged submissions and silent hiding.
    • Strong admin. Preview a change before saving, open or close a tournament, export results.
    • Scales. Boards stay fast from a handful of players to millions.

    The map ahead

    Where LongJump goes next

    Partner studios in our beta help decide what we build next.

    • Config promotion

      Build configuration in development, then promote it to staging and production.

    • More ways to sign in

      Guest accounts that keep their saves and progress, plus email, Apple, Google and Discord, all linked to one player, with account merging.

    • Consoles and mobile

      Sign-in for consoles, iOS and Android, so every feature works beyond Steam.

    • Profiles and friends

      Editable profiles, friend lists (including Steam friends), blocking and online status.

    • Groups and clans

      Player-made groups with roles and join requests. Scores and chat can belong to a group.

    • Competition

      Running-total boards, automatic cheat flagging, and rewards when a season or tournament ends.

    • Storage

      Small per-player objects with their own permissions, version checks on writes, batch reads and search.

    • Chat and notifications

      Direct, group and room chat, and messages that reach players live or at their next sign-in.

    • Parties and matchmaking

      Team up before a match, and find other players by skill, region and mode.

    • Multiplayer

      Relayed matches, match listing, and authoritative matches on your own headless Unity server builds.

    • Economy

      Server-owned wallets and currency, purchase validation, server-granted inventory and a store.

    • Your own logic

      Hooks around any API call and custom server functions, without forking the platform.

    • Studio portal

      A console for your studio, with keys for your own tools and scripts.

    • Crash reports that help

      An issue list that shows where each crash happened in your code, with filters you'd actually use.

    • Analytics

      An event feed for retention and balancing dashboards, plus request and game metrics.

    • More from your wiki

      Publishing from the command line, wiki notes in your game's source, and live data such as drop rates.

    Private beta

    Take the long jump with us

    We're opening LongJump to a limited group of studios. Beta studios get direct access to the team building it and a real say in what ships next.

    • Your own team, games and environments
    • Help wiring LongJump into your game
    • Early access to new features as they land
    Apply for beta access
    What do you need?

    Questions

    Which engines does LongJump support?

    Any engine that can make HTTPS requests and open an MQTT connection, which is what the event stream uses. Steam sign-in uses the Steamworks SDK, which Unity, Godot and Unreal all support. We build and test with Unity.

    Does my Steam publisher key ship in my game?

    No. Your publisher Web API key is stored with your team on the server and used only there. Your game sends a short-lived auth ticket, exactly as Valve recommends.

    Can I test without affecting live players?

    Yes. Each environment has its own sessions, scores, saves and event stream, so development and staging never reach production.

    What about games that aren't on Steam?

    Currently players sign in with Steam. More sign-in methods are on the way; tell us what you need in your application.

    What does it cost?

    Free during the beta, and free while your game is in development. After that, pricing will be based on monthly active players, set with indie studios in mind.

    What support do I get?

    Direct, hands-on support from the team building LongJump for the whole beta.

    Is it reliable?

    LongJump has run consistently in production since May 2024, behind a live game on Steam.

    Is there API documentation?

    Yes. The API reference covers every endpoint, its errors and a quick start.