Developer Products: One-Time Purchases

Monetize your Roblox game with Developer Products. Learn to implement one-time purchases for in-game items and currency.

Developer Products are a crucial monetization tool for Roblox developers, allowing players to make one-time purchases within your game for consumable items or temporary benefits. Unlike Game Passes, which grant permanent perks, Developer Products are designed for repeated purchases, making them ideal for in-game currency, power-ups, revives, or other items that players might need multiple times during their gameplay. Understanding how to implement and manage Developer Products can significantly boost your game's revenue.

Developer Products are created and managed through the Roblox website. To create one, navigate to your game's page, click the gear icon, and select 'Configure Experience'. From there, go to the 'Monetization' tab and then 'Developer Products'. You'll be prompted to create a new Developer Product, where you'll need to define its name, description, and price in Robux. You can create multiple Developer Products for different items within your game.

Once your Developer Products are created on the website, you'll need to use scripts within Roblox Studio to allow players to purchase them. The primary function for purchasing Developer Products is `MarketplaceService:PromptProductPurchase()`. This function is typically called from a `LocalScript` because it triggers a purchase dialog directly on the player's client.

Implementing a Developer Product Purchase:

Here's a basic example of how to script a purchase for a Developer Product (e.g., buying in-game coins):

-- Place this LocalScript in a UI element, like a Button, that triggers the purchase

local Players = game:GetService("Players")
local MarketplaceService = game:GetService("MarketplaceService")

local player = Players.LocalPlayer

-- Replace 'YOUR_GAME_ID' with your actual game's ID
local gameId = YOUR_GAME_ID 
-- Replace 'YOUR_DEVELOPER_PRODUCT_ID' with the ID of the Developer Product you created on the website
local developerProductId = YOUR_DEVELOPER_PRODUCT_ID 

local purchaseButton = script.Parent -- Assuming the script is inside a Button

local function onPurchaseButtonClicked()
 print("Attempting to purchase Developer Product...")
 
 -- Prompt You to purchase the Developer Product
 local success, message = pcall(function()
 MarketplaceService:PromptProductPurchase(player, developerProductId)
 end)
 
 if not success then
 warn("Failed to prompt purchase: " .. tostring(message))
 -- Optionally display an error message to the player
 end
end

purchaseButton.MouseButton1Click:Connect(onPurchaseButtonClicked)

-- Optional: Handle purchase completion (this is usually handled by the server)
-- You can use MarketplaceService events, but server-side validation is crucial.

Server-Side Validation (Crucial for Security):

While `PromptProductPurchase` is called on the client, it's absolutely critical to validate purchases on the server to prevent exploits. You'll typically use a `Script` (server-side) to listen for purchase completion events.

-- Place this Script in ServerScriptService

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

-- This event fires when a player successfully purchases a developer product or game pass
MarketplaceService.ProcessReceipt = function(receiptInfo)
 local userId = receiptInfo.PlayerId
 local productId = receiptInfo.ProductId
 
 local player = Players:GetPlayerByUserId(userId)
 
 -- Check if You is still in the game
 if not player then
 return Enum.ProductPurchaseDecision.NotProcessedYet -- Roblox will retry later
 end
 
 -- Check if the purchased item is one of your Developer Products
 -- You'll need to have a way to map product IDs to your game's items
 -- For example, a table of your Developer Product IDs
 local developerProductIds = {
 YOUR_DEVELOPER_PRODUCT_ID_1, 
 YOUR_DEVELOPER_PRODUCT_ID_2
 -- Add all your Developer Product IDs here
 }
 
 local isOurProduct = false
 for _, id in ipairs(developerProductIds) do
 if id == productId then
 isOurProduct = true
 break
 end
 end
 
 if isOurProduct then
 -- Grant the item or currency to the player
 print("Player " .. player.Name .. " purchased product " .. productId)
 
 -- Example: Granting in-game currency
 -- local leaderstats = player:FindFirstChild("leaderstats")
 -- if leaderstats then
 -- local coins = leaderstats:FindFirstChild("Coins")
 -- if coins then
 -- -- Determine how many coins to give based on the productId
 -- local coinsToGrant = 0
 -- if productId == YOUR_DEVELOPER_PRODUCT_ID_1 then
 -- coinsToGrant = 100
 -- elseif productId == YOUR_DEVELOPER_PRODUCT_ID_2 then
 -- coinsToGrant = 500
 -- end
 -- coins.Value = coins.Value + coinsToGrant
 -- end
 -- end
 
 return Enum.ProductPurchaseDecision.PurchaseGranted -- Tell Roblox the purchase was successful
 else
 -- If it's not one of your products, let Roblox handle it (e.g., Game Passes)
 return Enum.ProductPurchaseDecision.NotProcessedYet
 end
end

By implementing both client-side prompting and server-side validation, you ensure a secure and functional monetization system for your Roblox game using Developer Products.