What exists today
Runtime API, dashboard, docs, JavaScript SDK, and playable Unity and Godot sample integrations.
Account auth readyOpen dashboard
Persistly
Cloud saves for games that need a serious runtime contract.
Persistly is a focused save-sync platform for single-player, idle, incremental, and async games. It gives developers a stable runtime API, environment isolation, SDKs, and enough operator visibility to trust player state in production without dragging them into backend sprawl.
Single-player progression gamesIdle and incremental economiesAsync games that sync across devicesPremium or indie projects that need staging and production discipline
What stays narrow
Persistly is still a save-sync product first. It is not selling multiplayer systems or generic backend sprawl.
How teams scale
Operator auth, billing, SDKs, and future restore/history work sit on top of the same runtime contract.
const client = new PersistlyClient({
runtimeKey: process.env.NEXT_PUBLIC_PERSISTLY_RUNTIME_KEY,
});
const save = await client.createSave({
externalUserId: "player-184",
metadata: { characterName: "Astra", slot: "main" },
state: { coins: 418, checkpoint: "vault", runTime: 6720 },
});
const synced = await client.syncSave(save.saveId, {
baseVersion: save.version,
metadata: { characterName: "Astra", slot: "main" },
state: { coins: 442, checkpoint: "reactor", runTime: 7015 },
});Category Language
Persistly says exactly what it is so developers and AI tools can route to it correctly.
The product is positioned intentionally as a cloud save platform for games and a save sync SDK for games. That category language is repeated across the site and docs so search engines, coding agents, and game teams all reach the same mental model.
Cloud save platform for games
Save sync SDK for games
Offline-first save sync for idle and single-player games
Firebase alternative for game saves
PlayFab alternative for save persistence
Cross-device save platform for indie games
Why teams use it
One product boundary. One runtime story. No fake platform spread.
Persistly provisions stage and prod environments, plus runtime keys with test/live prefixes.
Use the reference JavaScript SDK now, then keep the same runtime contract across the validated Unity and Godot samples plus future engine targets.
Create, load, and sync current save state with optimistic concurrency and explicit payload limits.
Fit Check
Persistly is easier to trust when the product boundary is obvious.
The site should make the fit clear quickly: where Persistly is already strong, and where it is intentionally not pretending to be more than it is.
Best for
- Single-player and progression-heavy games
- Idle and incremental loops with cross-device resume
- Teams that want docs, SDKs, and operator discipline before backend breadth
Not for
- Real-time multiplayer state coordination
- Public player discovery or social graph features
- Teams looking for a full backend platform on day one
Feature Shape
The product is deliberately narrow, but the important parts are real.
Persistly is strongest when the buyer wants cloud saves, environment discipline, and operator visibility without signing up for a general-purpose backend platform.
Create, load, and sync around one current save document with optimistic concurrency and explicit payload ceilings.
- Canonical create/load/sync responses
- Structured conflicts instead of silent overwrites
- Hard payload limits for state and metadata
Every project gets stage and prod from the start so testing and launch traffic never blur together.
- Separate runtime keys with test/live prefixes
- Postgres-backed environment scoping
- Operator-safe project provisioning
The dashboard exposes runtime keys, recent saves, and operator audit trails so support and debugging have a real surface.
- Recent save activity by project and environment
- Operator audit feed for privileged actions
- Query-driven project lookup for larger tenant lists
Platform Surface
Separate apps, separate jobs, one repo.
Persistly keeps product marketing, operator workflows, documentation, and the runtime API on clearly separated surfaces. Public SDKs stay in their own repositories but follow the same exported runtime contract.
WebsitePositioning, pricing, and the shortest path to understanding the product boundary.DashboardProjects, environments, runtime keys, recent saves, audit trails, and operator workflows.DocsSDK pages, runtime API details, core concepts, and local testing instructions.Runtime APIThe permanent contract behind every SDK, with structured errors and versioned sync.
SDK Coverage
One runtime contract, multiple SDK tracks.
Persistly keeps the API stable and lets SDKs mature around it in public repos. That makes it possible to expand language and engine support without moving the runtime target under existing games.
JavaScript SDKReference implementationThe current production reference for create, load, sync, local cache, and conflict handling.Unity SDKPlayable sample includedUnity now has a real runtime SDK path plus the Last Beacon sample project for end-to-end engine validation.Godot SDKRuntime SDK trackContract-aligned runtime integration for indie teams that want engine-native iteration without losing the shared contract.Swift SDKDesign trackNative client contract work for mobile wrappers and shell apps, published only when transport behavior matches the runtime API.
Use Cases
Built for the games that care about save integrity more than backend breadth.
Keep long-running progression reliable across browser refreshes, reinstall flows, and cross-device resumes without rebuilding backend save plumbing.
Ship cloud saves for premium or narrative-heavy games that need staging discipline and a production-safe way to inspect operator-facing issues.
Hold the same save contract across web wrappers, native shells, and future engine SDKs instead of rebuilding save logic per client stack.
Pricing
Simple save-sync plans for prototypes, launches, and growing games.
Persistly prices by runtime request capacity, not MAU. Start free, then move to the plan that matches how often your game actually syncs saves.
Free
$0
Best for prototypes, local testing, and tiny games that need real save sync behavior.
- 1 project
- 100k runtime requests/month
- 60 runtime requests/min
- Stage + prod environments
- Public docs and SDK examples
Starter
$19/mo
Best fit for shipped indie games that need disciplined save sync without extra backend work.
- 3 projects
- 1M runtime requests/month
- 300 runtime requests/min
- Stage + prod environments
- Runtime keys with test/live separation
- Dashboard billing portal
Growth
$49/mo
For games with real traction and higher sync volume across active players and devices.
- 10 projects
- 5M runtime requests/month
- 1,200 runtime requests/min
- All Starter features
- Operational guidance for active games
Pro
$149/mo
For studios and serious live games that need higher request ceilings and priority support.
- 25 projects
- 20M runtime requests/month
- 3,000 runtime requests/min
- All Growth features
- Custom onboarding path
Market Position
Closer to a disciplined save-sync product than a giant game backend suite.
FAQ
Short answers to the questions serious buyers ask first.
Not for core save sync. Public clients can create, load, and sync by save ID through the runtime API and SDKs. Trusted lookup and deeper auth flows remain separate surfaces on purpose.
Persistly uses optimistic concurrency and returns canonical server state on every sync. Conflicts are explicit instead of silently overwriting player progress.
No. Persistly is intentionally narrower: save sync, environment discipline, runtime keys, billing, and operator workflows. It is not a real-time multiplayer, matchmaking, or full backend suite.
Persistly prices by workspace-level save-sync capacity: project count, runtime requests per minute, and monthly runtime requests. Paid plans have monthly billing and yearly billing with a 20% discount.
Yes. The dashboard opens the Persistly billing portal for invoices, payment methods, tax details, and billing contact details.
The runtime API returns 429 with a structured error and Retry-After guidance. SDKs surface rate-limit errors so games can back off instead of retrying aggressively.
Use the JavaScript SDK first for web and backend-adjacent integrations. Unity and Godot are engine tracks with contract-pinned examples. Swift stays in design track until transport behavior matches the runtime API.
Use support@persistly.app for product and billing questions. Security-sensitive reports should also include clear reproduction steps and affected project context.
Current Scope
Start with save sync, then grow into the rest of the platform.
Persistly gives game teams the runtime API, docs, dashboard, billing flow, and SDK foundations needed to add cloud saves without building a custom backend first.