Roblox game pass script: sell perks the right way

-- Every pass the game sells, by name. The server and LocalScripts both read this.
local PassConfig = {}

-- Paste each pass ID from Creator Hub in place of 0.
-- A pass left at 0 is skipped, so you can set them up one at a time.
local ids: { [string]: number } = {
	VIP = 0, -- walk through the VIP door
	Speed = 0, -- walk faster
	GravityCoil = 0, -- a Tool kept in ServerStorage.PassItems
}
PassConfig.ids = ids

-- The Player attribute the server sets to true once a player owns the pass
function PassConfig.attributeFor(passName: string): string
	return "OwnsPass_" .. passName
end

return PassConfig

Pass IDs do not need hiding. The buy button needs the ID to open the purchase window anyway, and owning a pass is decided by Roblox, not by anything a player can read or change in ReplicatedStorage.

local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local ServerStorage = game:GetService("ServerStorage")

-- What the PassConfig module returns, so strict type checking can check how it is used
type PassConfigModule = {
	ids: { [string]: number },
	attributeFor: (passName: string) -> string,
}

local PassConfig = require(ReplicatedStorage:WaitForChild("PassConfig")) :: PassConfigModule
local passItems = ServerStorage:WaitForChild("PassItems")

-- Roblox's docs say Studio does not mock pass purchasing. Set this to true to try every
-- perk while testing in Studio. RunService:IsStudio() is false on live servers, so this
-- never gives perks away in the published game.
local GRANT_ALL_IN_STUDIO = false

local SPEED_PASS_WALK_SPEED = 24 -- the default WalkSpeed is 16
local VIP_PLAYERS_GROUP = "VIPPlayers"
local VIP_DOOR_GROUP = "VIPDoor"
local CHECK_ATTEMPTS = 3

-- passesOwned[player] holds the passes that player owns, e.g. passesOwned[player].VIP == true
local passesOwned: { [Player]: { [string]: boolean } } = {}

-- VIP door: parts in the VIPDoor group block everyone except characters in VIPPlayers
for _, groupName in { VIP_PLAYERS_GROUP, VIP_DOOR_GROUP } do
	if not workspace:IsCollisionGroupRegistered(groupName) then
		workspace:RegisterCollisionGroup(groupName)
	end
end
workspace:CollisionGroupSetCollidable(VIP_PLAYERS_GROUP, VIP_DOOR_GROUP, false)

local vipDoor = workspace:FindFirstChild("VIPDoor")
if vipDoor and vipDoor:IsA("BasePart") then
	vipDoor.CollisionGroup = VIP_DOOR_GROUP
else
	warn("No Part named VIPDoor in Workspace, so the VIP pass opens no door")
end

local function giveTool(player: Player, toolName: string)
	local template = passItems:FindFirstChild(toolName)
	if not (template and template:IsA("Tool")) then
		warn(`ServerStorage.PassItems has no Tool named {toolName}`)
		return
	end
	-- StarterGear: Roblox copies it into the Backpack every time the character spawns.
	-- It can appear a moment after the player joins, so wait for it briefly.
	local starterGear = player:WaitForChild("StarterGear", 10)
	if starterGear and starterGear:IsA("StarterGear") then
		template:Clone().Parent = starterGear
	else
		warn(`No StarterGear for {player.Name}, so {toolName} will not come back after a respawn`)
	end
	-- Backpack: if the character is already in the world, hand over a copy now too
	local backpack = player:FindFirstChildOfClass("Backpack")
	if backpack and player.Character then
		template:Clone().Parent = backpack
	end
end

-- Perks that live on the character. A respawn creates a new character without them,
-- so this runs for the current character and again for every new one.
local function applyCharacterPerks(player: Player, character: Model)
	local owned = passesOwned[player]
	if not owned then
		return
	end

	if owned.VIP then
		for _, descendant in character:GetDescendants() do
			if descendant:IsA("BasePart") then
				descendant.CollisionGroup = VIP_PLAYERS_GROUP
			end
		end
	end

	if owned.Speed then
		local humanoid = character:WaitForChild("Humanoid", 10)
		if humanoid and humanoid:IsA("Humanoid") then
			humanoid.WalkSpeed = SPEED_PASS_WALK_SPEED
		end
	end
end

local function onCharacterAdded(player: Player, character: Model)
	-- Accessories and other parts can arrive after the character spawns
	character.DescendantAdded:Connect(function(descendant: Instance)
		local owned = passesOwned[player]
		if owned and owned.VIP and descendant:IsA("BasePart") then
			descendant.CollisionGroup = VIP_PLAYERS_GROUP
		end
	end)
	applyCharacterPerks(player, character)
end

-- Gives a player everything one pass includes. Safe to call more than once.
local function grantPass(player: Player, passName: string)
	local owned = passesOwned[player]
	if not owned or owned[passName] then
		return -- the player has left, or already has this pass
	end
	owned[passName] = true
	-- Attributes set by the server replicate, so the player's LocalScripts can show "Owned"
	player:SetAttribute(PassConfig.attributeFor(passName), true)

	if passName == "GravityCoil" then
		giveTool(player, "GravityCoil")
	end

	local character = player.Character
	if character then
		applyCharacterPerks(player, character)
	end
end

-- Asks Roblox whether the player owns one pass, retrying if the request fails
local function checkPass(player: Player, passName: string, passId: number)
	for attempt = 1, CHECK_ATTEMPTS do
		local ok, result = pcall(function()
			return MarketplaceService:UserOwnsGamePassAsync(player.UserId, passId)
		end)
		if ok then
			if result == true then
				grantPass(player, passName)
			end
			return
		end
		warn(`Could not check the {passName} pass for {player.Name} (try {attempt}): {result}`)
		if attempt < CHECK_ATTEMPTS then
			task.wait(attempt * 2)
			if not passesOwned[player] then
				return -- the player left while we waited
			end
		end
	end
end

local function onPlayerAdded(player: Player)
	passesOwned[player] = {}

	player.CharacterAdded:Connect(function(character: Model)
		onCharacterAdded(player, character)
	end)
	local character = player.Character
	if character then
		onCharacterAdded(player, character)
	end

	for passName, passId in PassConfig.ids do
		if GRANT_ALL_IN_STUDIO and RunService:IsStudio() then
			task.spawn(grantPass, player, passName)
		elseif passId ~= 0 then
			-- One thread per pass: Roblox can batch checks started together into fewer requests
			task.spawn(checkPass, player, passName, passId)
		end
	end
end

-- A player bought a pass in this server. Listen on the server only: here
-- wasPurchased is the final result, and a LocalScript's copy is not to be relied on.
MarketplaceService.PromptGamePassPurchaseFinished:Connect(
	function(player: Player, passId: number, wasPurchased: boolean)
		if not wasPurchased then
			return
		end
		for passName, id in PassConfig.ids do
			if id == passId then
				grantPass(player, passName)
			end
		end
	end
)

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	passesOwned[player] = nil
end)

Roblox's API reference says UserOwnsGamePassAsync caches its results, updates the cache when PromptGamePassPurchaseFinished fires, and always returns true the first time a player enters a server after buying the pass. The passesOwned table is still worth keeping: it is the server's own answer that other scripts and the perk code read without waiting on Roblox.

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

-- What the PassConfig module returns, so strict type checking can check how it is used
type PassConfigModule = {
	ids: { [string]: number },
	attributeFor: (passName: string) -> string,
}

local PassConfig = require(ReplicatedStorage:WaitForChild("PassConfig")) :: PassConfigModule

local PASS_NAME = "VIP" -- the pass this button sells: one of the names in PassConfig.ids
local passId = PassConfig.ids[PASS_NAME] or 0
local ownedAttribute = PassConfig.attributeFor(PASS_NAME)

local player = Players.LocalPlayer
local priceText = "" -- filled in once Roblox returns the price for this player

local gui = Instance.new("ScreenGui")
gui.Name = "PassButtonGui"
gui.ResetOnSpawn = false -- keep the button when the character respawns

local button = Instance.new("TextButton")
button.Name = "BuyPass"
button.AnchorPoint = Vector2.new(0, 1)
button.Position = UDim2.new(0, 16, 1, -16)
button.Size = UDim2.fromOffset(200, 48)
button.BackgroundColor3 = Color3.fromRGB(255, 196, 61)
button.TextColor3 = Color3.fromRGB(40, 28, 0)
button.FontFace = Font.fromEnum(Enum.Font.BuilderSansBold)
button.TextSize = 18
button.Parent = gui

local corner = Instance.new("UICorner")
corner.CornerRadius = UDim.new(0, 10)
corner.Parent = button

local function refresh()
	if player:GetAttribute(ownedAttribute) == true then
		button.Text = `{PASS_NAME} owned`
		button.AutoButtonColor = false
	else
		button.Text = `Get {PASS_NAME}{priceText}`
		button.AutoButtonColor = true
	end
end

button.Activated:Connect(function()
	if player:GetAttribute(ownedAttribute) == true then
		return
	end
	if passId == 0 then
		warn(`Paste the {PASS_NAME} pass ID into PassConfig first`)
		return
	end
	-- Roblox shows its own purchase window and takes the payment.
	-- This script never grants anything: the server does that when the purchase finishes.
	MarketplaceService:PromptGamePassPurchase(player, passId)
end)

-- The server sets this attribute when the player owns the pass, or buys it now
player:GetAttributeChangedSignal(ownedAttribute):Connect(refresh)
refresh()
gui.Parent = player:WaitForChild("PlayerGui")

-- Show the price this player sees. GetProductInfoAsync asks Roblox's servers, so it is in a pcall.
if passId ~= 0 then
	local ok, info = pcall(function()
		return MarketplaceService:GetProductInfoAsync(passId, Enum.InfoType.GamePass)
	end)
	if ok and info.IsForSale == true and type(info.PriceInRobux) == "number" then
		priceText = `: {info.PriceInRobux} Robux`
		refresh()
	elseif not ok then
		warn(`Could not load the {PASS_NAME} pass price: {info}`)
	end
end

The price comes from GetProductInfoAsync, which replaced the deprecated GetProductInfo that older tutorials (and some of Roblox's own examples) still use. Roblox's Passes page says to load prices on the client if you use its price optimization feature, so each player sees their own price. Activated fires for a click, a tap and a controller button press.

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

local COINS_100_PRODUCT_ID = 0 -- replace 0 with your developer product ID

-- One function per developer product. Each returns true only once the player has what they paid for.
local productHandlers: { [number]: (player: Player) -> boolean } = {}

productHandlers[COINS_100_PRODUCT_ID] = function(player: Player): boolean
	local leaderstats = player:FindFirstChild("leaderstats")
	local coins = leaderstats and leaderstats:FindFirstChild("Coins")
	if coins and coins:IsA("IntValue") then
		coins.Value += 100
		return true
	end
	return false
end

local function processReceipt(receiptInfo: { [string]: any }): Enum.ProductPurchaseDecision
	local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
	if not player then
		-- The buyer left. Roblox keeps the purchase open and offers it again when they rejoin.
		return Enum.ProductPurchaseDecision.NotProcessedYet
	end

	local handler = productHandlers[receiptInfo.ProductId]
	if not handler then
		warn(`No handler for developer product {receiptInfo.ProductId}`)
		return Enum.ProductPurchaseDecision.NotProcessedYet
	end

	local ok, granted = pcall(handler, player)
	if ok and granted == true then
		return Enum.ProductPurchaseDecision.PurchaseGranted
	end

	warn(`Could not grant product {receiptInfo.ProductId} to {player.Name}: {granted}`)
	return Enum.ProductPurchaseDecision.NotProcessedYet
end

-- Set this once, in one server Script, for all of your developer products
MarketplaceService.ProcessReceipt = processReceipt

This assumes a leaderstats folder with a Coins IntValue, as in the leaderboard guide. Returning NotProcessedYet leaves the purchase open: Roblox calls ProcessReceipt again when the player rejoins or makes another developer product purchase.