roblox-data-stores

Roblox data stores and cloud services

Choose the service

Player data: use session locking

Two servers must never own the same player's data at once (teleports, fast rejoins), or items duplicate and progress is lost. ProfileStore (loleris) implements session locking, auto-save, and BindToClose flushing, and is the recommended default. Install it from Wally/the Creator Store and put it in ServerScriptService.

-- ServerScriptService/Server/Services/DataService.luau (ProfileStore)
local Players = game:GetService("Players")
local ServerScriptService = game:GetService("ServerScriptService")

local ProfileStore = require(ServerScriptService.ServerPackages.ProfileStore)

local TEMPLATE = {
	version = 1,
	coins = 0,
	inventory = {} :: { [string]: number },
}
type PlayerData = typeof(TEMPLATE)

local PlayerStore = ProfileStore.New("PlayerData", TEMPLATE)
local profiles: { [Player]: typeof(PlayerStore:StartSessionAsync("")) } = {}

local function onPlayerAdded(player: Player)
	local profile = PlayerStore:StartSessionAsync(`User_{player.UserId}`, {
		Cancel = function()
			return player.Parent ~= Players -- stop waiting if the player left
		end,
	})
	if profile == nil then
		player:Kick("Could not load your data. Please rejoin.")
		return
	end
	profile:AddUserId(player.UserId) -- GDPR / right-to-be-forgotten linkage
	profile:Reconcile() -- fill in fields added to TEMPLATE since this profile was created
	profile.OnSessionEnd:Connect(function()
		profiles[player] = nil
		player:Kick("Your data was loaded on another server. Please rejoin.")
	end)
	if player.Parent == Players then
		profiles[player] = profile
	else
		profile:EndSession() -- left while loading
	end
end

for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end
Players.PlayerAdded:Connect(onPlayerAdded)
Players.PlayerRemoving:Connect(function(player)
	local profile = profiles[player]
	if profile then
		profile:EndSession() -- saves and releases the lock
	end
end)

local DataService = {}
function DataService.get(player: Player): PlayerData?
	local profile = profiles[player]
	return profile and profile.Data
end
return DataService

Mutate profile.Data directly on the server (it is cached in memory and auto-saved). Don't SetAsync per change. Check the ProfileStore docs for the exact current API before relying on less common features (global updates, MessageAsync, mock stores for Studio).

Raw DataStoreService rules (when not using a wrapper)

• Buffer in memory: load once on join, mutate the in-memory table, save periodically (e.g. every

2–5 minutes with random jitter), on leave, at checkpoints (purchases), and in game:BindToClose.

• `UpdateAsync` over `SetAsync` whenever the write depends on the old value or multiple servers may

write the key. The transform function must be pure and fast (no yields); return nil to cancel.

• Retry transient errors with exponential backoff + jitter, capped attempts; process retries for

a key in order (an old retry must not overwrite newer data). Treat a failed write as "outcome unknown".

• Never save Instances, Vector3, CFrame, functions, or mixed/sparse tables: store plain tables,

numbers, strings, booleans, and buffers. Serialize datatypes ({ x, y, z }). Validate UTF-8 strings.

• Keys and data store names ≤ 50 characters; value ≤ 4,194,304 characters after JSON encoding.
• Stable key patterns (User_{UserId}), never display names. Few data stores, few keys per player.
• Studio needs File → Experience Settings → Security → Enable Studio Access to API Services; use a separate test

universe or a different data store name so testing never touches production data.

Complete raw implementation (session lock, autosave, BindToClose, retries): references/raw-datastore.md.

Budgets and limits (2026)

• UpdateAsync consumes both read and write budget.
• Check DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite) before

bulk work; tune per-server limits once at startup with SetRateLimitForRequestType.

• Don't pre-compress data; Roblox compresses automatically. Shard only genuinely hot keys.
• Use versions (ListVersionsAsync, GetVersionAtTimeAsync) to restore data instead of writing backup keys.

Schema versioning and migrations

Store a version field. On load, run ordered migration functions until the data reaches the current version, then reconcile defaults. Never delete fields in the same release that stops writing them; never reuse field names with different meanings.

--!strict
type Data = { [string]: any }

local MIGRATIONS: { (Data) -> () } = {
	[1] = function(data) -- v1 -> v2: "gold" renamed to "coins"
		data.coins = data.gold or 0
		data.gold = nil
	end,
	[2] = function(data) -- v2 -> v3: inventory list -> counts
		local counts: { [string]: number } = {}
		for _, itemId in data.inventory or {} do
			counts[itemId] = (counts[itemId] or 0) + 1
		end
		data.inventory = counts
	end,
}
local CURRENT_VERSION = #MIGRATIONS + 1

local function migrate(data: Data): Data
	local version = data.version or 1
	while version < CURRENT_VERSION do
		MIGRATIONS[version](data)
		version += 1
	end
	data.version = CURRENT_VERSION
	return data
end

print(migrate({ gold = 5, inventory = { "Sword", "Sword" } }))

Leaderboards (OrderedDataStore)

• Values must be integers. Write on a schedule or on meaningful change, not every increment.
• Read top N with GetSortedAsync(false, 100) on one server loop (e.g. every 60 s), cache the

result, and replicate to clients. Don't let every server/client read constantly.

• For "this week" boards, include the period in the store name (Wins_2026W39) or use a MemoryStore sorted map.

MemoryStore essentials

• Quotas are experience-wide: memory 64 KB + 1.2 KB × users; requests 1000 + 120 × CCU units/min.
• MemoryStoreSortedMap: ranked data, server browsers, live leaderboards (SetAsync with expiration,

GetRangeAsync, UpdateAsync).

• MemoryStoreQueue: matchmaking/work queues (AddAsync, ReadAsync + RemoveAsync with the returned id

after successful processing, invisibility timeout for crash safety).

• MemoryStoreHashMap: high-volume key-value without sorting (SetAsync, GetAsync, UpdateAsync, ListItemsAsync).
• Always set expirations; handle throttling (pcall + retry); keep items small.

MessagingService essentials

• Message ≤ 1 kB. Per server: 600 + 240 × players sends/min; 20 + 8 × players subscriptions.
• Delivery is best effort and not ordered: use it for notifications ("refresh your cache",

global announcements), never as the source of truth. Pair with DataStore/MemoryStore for state.

• Wrap SubscribeAsync/PublishAsync in pcall; they can fail or yield.

More code (MemoryStore queue matchmaking, cross-server announcement, RTBF): references/memory-and-messaging.md.

Right to be forgotten

Use static key patterns so automated RTBF (configured in Creator Dashboard) can delete player data templates like PlayerData/User_{userId}. Otherwise handle the right-to-erasure webhook (see roblox-open-cloud). Link keys to user IDs: SetAsync(key, value, { userId }), return them as the second value from an UpdateAsync transform, or call ProfileStore's AddUserId.

Related skills

roblox-security (duplication and trade exploits), roblox-monetization (receipts), roblox-open-cloud (external access, bulk operations), roblox-teleport-matchmaking.