MonetizationService

Getting it

local MonetizationService = Engine:GetService("MonetizationService")

Overview

MonetizationService handles everything between "show a buy button" and "the player has their item":

• A catalog of what you sell, with names, prices and your own data, replicated to each player.
• Prompts that return a Promise resolving with whether the player bought.
• Receipts that grant developer products exactly once, stored in the player's DataService profile so a purchase can never be granted twice, even across servers.
• Prices with Roblox price levels, regional pricing, discounts and Roblox Plus discounts.
• Policy checks: products marked as random rewards, ads and subscriptions are only offered to players whose Roblox policy allows them (see PlayerService).
• Ownership of passes, assets and bundles with caching, subscription status, Robux transfers, rewarded video ads and ad units.
• A per-player ledger: Robux spent, purchase history, passes, subscriptions and more.

local MonetizationService = Engine:GetService("MonetizationService")
local DataService = Engine:GetService("DataService")

local PlayerData = DataService:CreateProfileStore("PlayerData", { Coins = 0 }) -- your player profiles
MonetizationService:BindProfileStore(PlayerData) -- receipts are recorded in these profiles

MonetizationService:DefineProduct(1234567, { Name = "500 Coins", Data = { Coins = 500 } })
MonetizationService:DefinePass(7654321, { Name = "VIP" })

MonetizationService:BindProductHandler(1234567, function(player, receipt, profile)
	profile:Increment("Coins", 500)
	return true -- granted
end)

MonetizationService.PassPurchased:Connect(function(player, passId)
	if passId == 7654321 then
		giveVip(player)
	end
end)

local MonetizationService = Engine:GetService("MonetizationService")

MonetizationService:GetPriceAsync("Product", 1234567):andThen(function(price)
	buyButton.Text = string.format("%d R$", price.Price)
end)

buyButton.Activated:Connect(function()
	MonetizationService:PromptProductAsync(1234567)
end)

Where purchases are stored

Receipts and the rest of the ledger are recorded inside each player's profile, under ProfilePath (default "Monetization"), in the profile store you choose: call :BindProfileStore(store) before players join, or name the store in ProfileStoreName. The service never picks a store by itself. Your game starts the player sessions in that store as usual, and the service adds its record to a profile that has none yet, so it does not need to be in your template.

Without a profile store it still works, but keeps the records in memory for the session and remembers granted receipts on that server only, so a purchase could be granted twice on different servers. It warns you the first time it grants a receipt that way. Product handlers then get nil as their profile.

Catalog

Options: { Name?, Price?, AdReward?, Random?, Data? }. Random = true marks a paid random reward (loot box); such items are only sold where PaidRandomItems is allowed. AdReward = true marks a product granted by watching a rewarded video ad. Data is free for your own use and replicates with the catalog.

Kinds: "Product", "Pass", "Subscription", "Asset", "Bundle", "CommerceProduct".

Receipts

With HandleReceipts = true (default) the service sets MarketplaceService.ProcessReceipt itself. Only one script in a game may own that callback.

Prompts

All prompt methods check the player's policy first, open the Roblox purchase prompt, and resolve with (purchased: boolean, details) when it closes. They reject when the policy forbids the purchase (and fire PromptRefused) or after PromptTimeoutSeconds.

Bulk items are { Type = "Asset" | "Bundle", Id, Duration? }. :IsPromptOpen(player, kind, id) tells you whether a prompt is still showing.

Prices

PriceInfo: { Price, ListPrice, RegionalPrice, PriceLevel, Country?, IsForSale, IsRegional, IsDiscounted, Discount, DiscountPercent, Discounts, Source }. Source is "Live" when it comes from Roblox or "Estimate" when Engine calculated it from the regional table.

Ownership and subscriptions

The ledger

A Record holds Purchases, RobuxSpent, PurchaseCount, FirstPurchase, LastPurchase, Passes, Subscriptions, transfer totals, AdRewards and Plus details. With LogToStatistics, purchases are also reported to StatisticsService.

Robux transfers

MonetizationService:PromptRobuxTransferAsync(sender: Player, receiverUserId: number, amount: number): Promise

Lets a player send Robux to another user (between TransferMinRobux and TransferMaxRobux). TransferSent and TransferReceived fire with { TransferRequestId, Direction, Amount?, SenderUserId?, ReceiverUserId?, Receipt }.

Before it opens the prompt, the service asks Roblox whether both users may transfer Robux. When one of them may not, it rejects with "SenderNotEligible" or "ReceiverNotEligible" without opening a prompt, and fires TransferRefused. When Roblox cannot tell, the prompt opens as usual. Turn the check off with CheckTransferEligibility = false.

Both methods use MarketplaceService:CanUsersTransferRobuxAsync, and the answer is cached per sender and receiver for TransferEligibilityCacheSeconds. A player is never eligible to send Robux to themselves.

Ads

On the client: :IsRewardedAdAvailableAsync(), :WatchRewardedAdAsync(productId, placementId?), :IsAdIneligibleResult(name), :RegisterAdOpportunity(button, placementId?), :RegisterDisclosureButton(button, campaignId), :GetAdUnits(root?) and :HideAdUnits(root?). Ads are only shown where the player's policy allows them; with HideAdUnitsWhenNotAllowed ad units are removed for those players.

Sessions

When a player joins, the service looks up their price level, country and Plus details (PrefetchOnJoin) and fires SessionReady: Signal<(player, SessionInfo)>. :GetSessionInfo(player) returns { PriceLevel, Country?, Plus?, StoreName?, ProfilePath }.

IsPrivateServer, IsReservedServer and PrivateServerOwnerId describe the current server, handy for private-server perks.

:PromptCreateAvatarAsync(player, tokenId, humanoidDescription) wraps Roblox's avatar creation prompt.

Client

The client gets a read-only view of the catalog and its own session, plus prompts and prices for the local player.

Client requests are rate-limited (ClientRequestRatePerSec). Granting always happens on the server; the client can only open prompts.

Configuration

Types

export type Kind = "Product" | "Pass" | "Subscription" | "Asset" | "Bundle" | "CommerceProduct"
export type Id = number | string
export type Definition
export type DefinitionOptions
export type PriceInfo
export type Discount
export type ProductInfo
export type SubscriptionStatus
export type PlusDetails
export type Record
export type PurchaseEntry
export type ReceiptInfo
export type ProductHandler = (player: Player, receipt: ReceiptInfo, profile: any?) -> boolean?
export type PromptKind
export type BulkItem
export type Transfer
export type TransferEligibility = "Eligible" | "SenderNotEligible" | "ReceiverNotEligible" | "Unknown"
export type SessionInfo