Persistly
Start free
Local-first cloud saves for games

Cloud save infrastructure for modern games.

Persist player progress, shared account data, and named save slots across supported SDKs with stage/prod keys, conflict-safe sync, and dashboard visibility.

Start freeView documentation
Local-firstRestore historyStage + prod keysJS, Unity, Godot

Everything needed for reliable game saves.

Focused save infrastructure so your game can ship without a custom backend.

Cloud saves

Persist player progress with named slots, local cache, versioned cloud writes, and restore history.

Cross-device sync

Let players resume from accepted cloud saves while conflicts stay explicit instead of silently overwriting progress.

Shared account data

Store account-wide settings, unlock flags, bundles, or shared inventory alongside named slots.

Stage and production

Every project starts with separate test and live runtime keys so integration work stays away from production data.

Usage visibility

Track requests, storage, save activity, accounts, warnings, and billing capacity from the dashboard.

Bounded runtime contract

SDKs receive structured conflicts, validation errors, rate limits, and payload boundaries they can handle deliberately.

SDKs for the release path.

Start with JavaScript, Unity, or Godot. Each SDK follows the same named-slot model.

javascript // JavaScript SDK
import { PersistlyGameSaves } from "@persistlyapp/sdk";

await PersistlyGameSaves.configure({
  runtimeKey: "ps_test_replace_me",
});

await PersistlyGameSaves.shared.saveData(gameState);
await PersistlyGameSaves.shared.forceSyncData();
unity // Unity SDK
await PersistlyGameSaves.ConfigureAsync(
    new PersistlyGameSavesSettings("ps_test_replace_me"));

await PersistlyGameSaves.Shared.SaveDataAsync(gameState);

await PersistlyGameSaves.Shared.ForceSyncDataAsync();
godot // Godot addon
const PersistlyGameSaves = preload(
    "res://addons/persistly/persistly_game_saves.gd")

var persistly := PersistlyGameSaves.new()
persistly.configure({ "runtime_key": "ps_test_replace_me" })

persistly.save_data(game_state)
persistly.force_sync_data()
JavaScriptUnityGodot

One save model across supported surfaces.

Use the same runtime contract for browser games, engine projects, and wrappers.

BrowserUnityGodotDesktopMobile wrappersCloud-hosted saves

Simple pricing for save-sync capacity.

Start free, then scale by projects, requests, storage, and restore history.

Free

Prototype path

$0

Best for prototypes, local testing, and tiny games that need real save sync behavior.

100k runtime requests/monthReal save-sync behavior for prototypes and tiny games
  • 1 project
  • 100k runtime requests/month
  • 60 prod requests/min, 20 stage requests/min
  • 1 GB storage
  • 24h smart restore history
  • 256 KB slot data, 16 KB slotInfo
  • Stage + prod environments
  • Runtime keys with test/live separation
  • Public docs and SDK examples
Start free

Starter

Recommended

Most indie games start here

$15.20/mo

Billed yearly at $182.40.

Best fit for shipped indie games that need disciplined save sync without extra backend work.

1M runtime requests/monthProduction save sync for shipped indie games
  • Everything in Free, plus:
  • 3 projects
  • 1M runtime requests/month
  • 300 prod requests/min, 60 stage requests/min
  • 25 GB storage
  • 7-day smart restore history
  • 512 KB slot data, 32 KB slotInfo
Create account

Growth

For active games

$39.20/mo

Billed yearly at $470.40.

For games with real traction and higher sync volume across active players and devices.

5M runtime requests/monthHigher sync volume across active players and devices
  • Everything in Starter, plus:
  • 10 projects
  • 5M runtime requests/month
  • 1,200 prod requests/min, 120 stage requests/min
  • 100 GB storage
  • 30-day smart restore history
  • 1 MB slot data, 64 KB slotInfo
  • Higher request and storage limits
Create account

Pro

Studio scale

$119.20/mo

Billed yearly at $1,430.40.

For studios and serious live games that need higher request ceilings and priority support.

20M runtime requests/monthHigh request ceilings and priority support for live games
  • Everything in Growth, plus:
  • 25 projects
  • 20M runtime requests/month
  • 3,000 prod requests/min, 300 stage requests/min
  • 500 GB storage
  • 90-day smart restore history
  • 2 MB slot data, 128 KB slotInfo
  • Priority support for live games
Create account
Start freeCompare plans

Developer experience first.

Readable docs, stable SDKs, and a dashboard that exposes the operational state.

Persistly integration path
import { PersistlyGameSaves } from "@persistlyapp/sdk";

await PersistlyGameSaves.configure({
  runtimeKey: "ps_test_replace_me",
});

const local = await PersistlyGameSaves.shared.saveData({
  level: 5,
  coins: 1200,
  checkpoint: "forest-gate",
});

await PersistlyGameSaves.shared.forceSync("autosave");

if (local.status === "local_saved") {
  // Local progress is safe before cloud sync.
}

Ship cloud saves without backend sprawl.

Create a project, copy a runtime key, and sync the first named save slot.

Start freeRead documentation