How to make a developer product in Roblox

How a developer product purchase works

1. The player presses your button. A LocalScript calls PromptProductPurchase and Roblox shows its purchase window.
2. The player confirms. Roblox takes the Robux and sends your server a receipt: who bought (PlayerId), what (ProductId) and a unique PurchaseId.
3. Roblox calls your ProcessReceipt function with that receipt. You grant the item and return PurchaseGranted.
4. Until Roblox gets PurchaseGranted back, the purchase counts as not delivered. Roblox calls ProcessReceipt again for it later, for example the next time the player joins a server.

Step 1: Create the product

1. Publish your place. Open the Creator Dashboard, select your experience, and go to Monetization, then Developer Products.
2. Click Create a Developer Product, give it a name ("100 Coins"), an icon and a price in Robux, and save.
3. Copy the product's ID from the list. You will paste it into both scripts below.

Step 2: The buy button

In StarterGui, add a ScreenGui named ShopGui with a TextButton named BuyCoins, and put this LocalScript inside the button:

-- LocalScript inside the BuyCoins TextButton.
-- Only shows the purchase window. The server gives the coins (Receipts script).
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local COINS_100_ID = 0000000 -- your developer product ID

local button = script.Parent :: TextButton

button.Activated:Connect(function()
	MarketplaceService:PromptProductPurchase(Players.LocalPlayer, COINS_100_ID)
end)

Nothing here gives coins. The GUI button guide covers styling the button and opening a shop panel; the shop GUI guide builds a whole shop.

Step 3: Grant purchases on the server

Insert a Script in ServerScriptService named Receipts. It must be the only script in your game that sets ProcessReceipt. Each product gets a small grant function that returns true only when it really gave the item.

-- Script in ServerScriptService named Receipts.
-- The ONLY script that sets MarketplaceService.ProcessReceipt.
local DataStoreService = game:GetService("DataStoreService")
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local purchaseHistory = DataStoreService:GetDataStore("PurchaseHistory_v1")

local function addCoins(player: Player, amount: number): boolean
	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if coins and coins:IsA("IntValue") then
		coins.Value += amount
		return true
	end
	return false -- leaderstats not ready yet: the purchase stays pending and comes back later
end

-- product ID -> grant function. Return true ONLY once the item is really given.
-- These run inside UpdateAsync, so they must not wait or yield.
local PRODUCTS: { [number]: (player: Player) -> boolean } = {
	[0000000] = function(player: Player): boolean -- 100 Coins
		return addCoins(player, 100)
	end,
	[1111111] = function(player: Player): boolean -- Full heal
		local humanoid = player.Character and player.Character:FindFirstChildOfClass("Humanoid")
		if humanoid and humanoid.Health > 0 then
			humanoid.Health = humanoid.MaxHealth
			return true
		end
		return false
	end,
}

local function processReceipt(receiptInfo: { [string]: any }): Enum.ProductPurchaseDecision
	local purchaseId = tostring(receiptInfo.PurchaseId)
	local ok, recorded = pcall(function()
		return purchaseHistory:UpdateAsync(purchaseId, function(alreadyGranted: boolean?): boolean?
			if alreadyGranted then
				return true -- delivered again after an earlier grant: do not grant twice
			end
			local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
			local grant = PRODUCTS[receiptInfo.ProductId]
			if not (player and grant and grant(player) == true) then
				return nil -- cancel the write: the purchase stays pending and is retried
			end
			return true
		end)
	end)
	if ok and recorded == true then
		return Enum.ProductPurchaseDecision.PurchaseGranted
	end
	if not ok then
		warn("[Receipts] purchase " .. purchaseId .. " not processed:", recorded)
	end
	return Enum.ProductPurchaseDecision.NotProcessedYet
end

MarketplaceService.ProcessReceipt = processReceipt

UpdateAsync returning nil from its function cancels the write, which is how "not granted" leaves no record. The grant runs inside that function, so it must be quick and must not wait: add to a value, set an attribute, give a Tool from ServerStorage. Something slow, such as saving the player's whole profile, belongs in your normal save code.

The newer BindReceiptHandler

Roblox's MarketplaceService reference now describes MarketplaceService:BindReceiptHandler as a newer way to handle developer product receipts, with a handler per list of product IDs, and calls ProcessReceipt the legacy route. A bound handler takes precedence and receipts it does not match fall through to ProcessReceipt, so both can live side by side while you move over. The rule from this guide does not change: record the PurchaseId with the grant, and only report success after a real grant. ProcessReceipt still works, and almost every existing game uses it.

Step 4: Test it

1. In Studio, open Game Settings, Security, and turn on Enable Studio Access to API Services, so the data store works.
2. Press Play and click the button. Studio shows a test purchase window; buying in Studio does not charge Robux.
3. Confirm, and check that Coins went up by 100 once.
4. In the live game, buy the cheapest product once with a real account and check it arrives. That is the only test of the full path.

Common errors and fixes

Open the Output window (Window menu, then Output) before you press Play.

Build it with RoCode

If you would rather not set this up by hand, RoCode can build it in the place you have open. RoCode is an independent AI agent for Roblox Studio, not made by Roblox: you describe the change in a web chat, and its Studio plugin creates the scripts and instances in your Explorer, so there is no code to paste. You still create the products themselves in Creator Hub.

Paste your real product IDs into the prompt, and buy each product once in Studio and once in the live game. How RoCode connects to Studio.

Questions

Sources and further reading

• Roblox Creator Docs: Developer products. creating products, prompting and handling receipts
• Roblox Creator Docs: MarketplaceService.ProcessReceipt. the receipt fields and the retry behaviour
• Roblox Creator Docs: MarketplaceService:BindReceiptHandler
• Roblox Creator Docs: GlobalDataStore:UpdateAsync. returning nil to cancel the write

How the code was checked: every script on this page passes Luau's strict type checker against Roblox's API definitions (luau-lsp, 5 November 2026). A type check catches misspelt APIs and wrong types, not game logic, so playtest in Studio before you publish.