Abonnements, Premium Payouts et ce qui les remplace

Un Game Pass se paie une fois, un Developer Product à chaque utilisation. Il existe une troisième voie : l’abonnement d’expérience, payé chaque mois. Dans cette leçon, tu vas voir comment il fonctionne, comment le vérifier proprement, puis faire le point sur un sujet qui a beaucoup changé : les Premium Payouts, remplacés par de nouveaux programmes en 2025 et 2026.

Les abonnements d’expérience

Un abonnement donne des avantages récurrents contre un paiement mensuel. La différence avec un pass est simple : l’avantage d’un pass est acquis pour toujours, celui d’un abonnement dure tant que le joueur paie.

D’après la documentation officielle (octobre 2026), les abonnements Roblox :

• se renouvellent automatiquement chaque mois ;
• peuvent être payés en Robux ou en monnaie locale (euros, dollars…) ;
• te rapportent toujours des Robux, quel que soit le mode de paiement ;
• ne sont pas exclusifs entre eux : un joueur peut avoir tous tes abonnements en même temps. Les paliers « Bronze / Argent / Or » mutuellement exclusifs ne sont pas possibles ;
• sont limités à 50 abonnements par jeu (actifs et inactifs confondus).

Robux ou monnaie locale ?

Source : page officielle « Subscriptions », consultée en octobre 2026.

Pour un abonnement en monnaie locale, la documentation indique que tu gagnes des Robux au taux de 1 Robux pour 0,01 $ du prix de base, après frais de plateforme. Exemple officiel : un abonnement à 5 $ te rapporte 350 Robux le premier mois, puis 500 Robux les mois suivants.

Créer et gérer un abonnement

Dans le Creator Hub : Monetization › Subscriptions › Create Subscription. Tu choisis une image, un nom unique (il ne pourra plus être modifié), une description claire des avantages, le mode de paiement et le type de produit (durable, consommable ou monnaie). Ensuite, tu actives l’abonnement pour le mettre en vente.

Quelques règles à connaître avant de te lancer :

• Avant la première activation, tu dois choisir un nom court pour ton jeu, affiché aux abonnés. Il est définitif.
• Le prix d’un abonnement en Robux ne peut changer qu’une fois tous les 60 jours, et une hausse ne s’applique qu’après un préavis d’au moins 30 jours envoyé par Roblox aux abonnés.
• Évite de supprimer un abonnement actif : pour un abonnement en monnaie locale, les abonnés sont remboursés et tu ne touches rien. La documentation conseille plutôt de le retirer de la vente (Take Off Sale) en annulant les renouvellements, puis d’attendre la fin de la période en cours.

Vérifier un abonnement côté serveur

Pour l’Obby des Nuages, imaginons un abonnement « Nuage+ » qui double les pièces ramassées. Trois outils officiels suffisent :

• MarketplaceService:GetUserSubscriptionStatusAsync(player, subscriptionId) : renvoie une table avec IsSubscribed (l’abonnement est actif) et IsRenewing (il se renouvellera). À appeler côté serveur, dans un pcall.
• Players.UserSubscriptionStatusChanged : événement déclenché quand le serveur constate qu’un abonnement a changé. Il reçoit (player, subscriptionId) et n’est reçu que par les scripts serveur. D’après la référence, le serveur ne revérifie le statut qu’après la fermeture d’une fenêtre d’achat d’abonnement : c’est pourquoi on revérifie aussi à chaque arrivée du joueur.
• PolicyService:GetPolicyInfoForPlayerAsync(player) : indique notamment, avec IsEligibleToPurchaseSubscription, si ce joueur a le droit d’acheter un abonnement (selon son pays, son âge, sa plateforme).

-- Script (côté serveur) dans ServerScriptService, nommé « Abonnements »
local MarketplaceService = game:GetService("MarketplaceService")
local PolicyService = game:GetService("PolicyService")
local Players = game:GetService("Players")

local ID_ABONNEMENT = "EXP-0000000000" -- remplace par l'ID de ton abonnement (chaîne de texte)

-- Met à jour l'attribut lu par le script des pièces
local function verifierAbonnement(player: Player)
	local ok, statut = pcall(function()
		return MarketplaceService:GetUserSubscriptionStatusAsync(player, ID_ABONNEMENT)
	end)
	if not ok then
		warn("Statut d'abonnement indisponible pour " .. player.Name .. " : " .. tostring(statut))
		return -- on garde l'état précédent plutôt que de retirer l'avantage par erreur
	end
	player:SetAttribute("AbonneNuagePlus", statut.IsSubscribed == true)
end

-- Indique à l'interface si on a le droit de proposer l'abonnement à ce joueur
local function verifierEligibilite(player: Player)
	local ok, politique = pcall(function()
		return PolicyService:GetPolicyInfoForPlayerAsync(player)
	end)
	local eligible = ok and politique.IsEligibleToPurchaseSubscription == true
	player:SetAttribute("PeutSAbonner", eligible)
end

Players.PlayerAdded:Connect(function(player)
	verifierEligibilite(player)
	verifierAbonnement(player)
end)

-- Statut modifié (le serveur le revérifie après la fermeture d'une fenêtre d'achat d'abonnement)
Players.UserSubscriptionStatusChanged:Connect(function(player, idAbonnement)
	if idAbonnement == ID_ABONNEMENT then
		verifierAbonnement(player)
	end
end)

Puis, dans ton script serveur qui gère le ramassage des pièces (le Script « Pieces » du module 4), il suffit de lire l’attribut au moment de créditer. Par exemple, ajoute cette fonction au-dessus de preparerPiece, puis utilise calculerGain(player) à la place de VALEUR_PIECE dans la ligne qui ajoute la pièce :

-- Extrait du script serveur des pièces : calcul du gain d'une pièce
local function calculerGain(player: Player): number
	if player:GetAttribute("AbonneNuagePlus") then
		return 2 -- avantage de l'abonnement : pièces doublées
	end
	return 1
end

Proposer l’abonnement

Côté client, on ouvre la fenêtre officielle avec MarketplaceService:PromptSubscriptionPurchase(player, subscriptionId), seulement si le serveur a indiqué que c’est possible :

-- LocalScript dans un bouton « BoutonNuagePlus » de la boutique
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local ID_ABONNEMENT = "EXP-0000000000"
local joueur = Players.LocalPlayer
local bouton = script.Parent :: TextButton

-- On cache l'offre aux joueurs qui ne peuvent pas s'abonner ou qui sont déjà abonnés
local function mettreAJour()
	bouton.Visible = joueur:GetAttribute("PeutSAbonner") == true
		and joueur:GetAttribute("AbonneNuagePlus") ~= true
end

bouton.Activated:Connect(function()
	MarketplaceService:PromptSubscriptionPurchase(joueur, ID_ABONNEMENT)
end)

joueur:GetAttributeChangedSignal("PeutSAbonner"):Connect(mettreAJour)
joueur:GetAttributeChangedSignal("AbonneNuagePlus"):Connect(mettreAJour)
mettreAJour()

Quand le joueur termine son achat, le serveur reçoit UserSubscriptionStatusChanged, revérifie le statut, met l’attribut à jour… et le bouton disparaît tout seul.

Et les Premium Payouts ?

Pendant des années, les créateurs touchaient des Premium Payouts (appelés ensuite Engagement-Based Payouts) : Roblox leur versait des Robux selon la part du temps que les abonnés Premium passaient dans leur jeu. Pas besoin de vendre quoi que ce soit : un jeu où les abonnés Premium jouaient longtemps était rémunéré.

Ce programme n’existe plus. La documentation officielle indique que depuis le 24 juillet 2025, il est déprécié et remplacé par les Creator Rewards. Roblox explique ce choix par le manque de transparence de l’ancien système : les créateurs ne savaient pas quelles actions faisaient augmenter leurs gains.

Le principe des Creator Rewards

Les Creator Rewards (« récompenses des créateurs ») ont deux volets, selon la page officielle consultée en octobre 2026 :

• Daily Engagement Rewards (engagement quotidien) : tu reçois 5 Robux chaque jour pour chaque « Active Spender » qui passe au moins 10 minutes dans ton jeu ce jour-là (en une ou plusieurs visites). Aucune inscription n’est nécessaire.
  • Limite : chaque jour, seuls les trois premiers jeux (dans l’ordre de ses visites) où cet Active Spender passe au moins 10 minutes sont récompensés. Un quatrième jeu ne touche rien, même s’il y joue longtemps (ce sont les exemples de la page officielle).
  • Un Active Spender est un joueur qui a acheté pour au moins 9,99 $ sur Roblox (Robux, Premium ou abonnements) au cours des 60 derniers jours, et qui n’était ni nouveau ni « de retour » sur Roblox pendant cette période.
• Audience Expansion Rewards (nouveaux joueurs) : quand ton jeu fait venir sur Roblox un nouveau joueur, ou en fait revenir un ancien absent depuis 60 jours (par un lien de partage, un lien direct ou une recherche du nom de ton jeu), et qu’il y joue au moins 10 minutes, tu touches 35 % de ses premiers 100 $ d’achats qualifiants sur ses 60 premiers jours.
  • Conditions supplémentaires : un compte vérifié par pièce d’identité et en règle, et un jeu qui garde en moyenne au moins 100 joueurs actifs par jour pendant ces 60 jours. Pour un premier jeu, c’est rarement atteint, et c’est normal.

Ces récompenses sont versées en Earned Robux avec une attente de 60 jours. Roblox surveille activement les abus (bots, faux comptes, encouragement à créer des comptes secondaires) et peut retirer les gains, voire exclure le créateur.

Roblox Plus, le successeur de Premium

Deuxième changement : Roblox a lancé Roblox Plus le 30 avril 2026 (4,99 $ par mois selon l’annonce officielle) et, le même jour, a cessé de vendre Premium : d’après la page d’aide officielle, les abonnés Premium existants peuvent garder leur abonnement, mais ne peuvent plus s’y réabonner s’ils l’annulent, et leurs avantages ont été modifiés à partir du 30 mai 2026. Pour toi, créateur, Roblox Plus apporte, selon la documentation (octobre 2026) :

• des réductions payées par Roblox : les abonnés Plus paient tes objets 10 % puis 20 % moins cher, mais tu touches la même somme ;
• un bonus d’inscription : jusqu’à 750 Robux (250 Robux par mois pendant 3 mois consécutifs, une fois l’abonnement payant, hors essai gratuit) pour chaque joueur qui s’abonne à Plus depuis ton jeu via MarketplaceService:PromptRobloxSubscriptionPurchase ; ces gains ont une attente de 60 jours ;
• une compensation pour les serveurs privés payants, gratuits pour les abonnés Plus : jusqu’à 100 Robux par abonné qui passe au moins 60 minutes sur 30 jours dans le serveur privé qu’il a créé dans ton jeu ;
• 10 % des transferts de Robux faits par des abonnés Plus dans ton jeu, via l’API dédiée.

Reconnaître un abonné Roblox Plus en jeu

Attention aux vieux tutoriels : la propriété Player.MembershipType (qui valait Enum.MembershipType.Premium pour les abonnés) est désormais dépréciée. La documentation recommande Player.HasRobloxSubscription, un booléen en lecture seule :

-- Script (côté serveur) dans ServerScriptService : petit bonus cosmétique pour les abonnés
local Players = game:GetService("Players")

local function mettreAJourBadgeAbonne(player: Player)
	-- Attribut lu par l'interface pour afficher une étoile à côté du nom
	player:SetAttribute("EtoileAbonne", player.HasRobloxSubscription)
end

Players.PlayerAdded:Connect(function(player)
	mettreAJourBadgeAbonne(player)
	player:GetPropertyChangedSignal("HasRobloxSubscription"):Connect(function()
		mettreAJourBadgeAbonne(player)
	end)
end)

Les recommandations de Roblox pour l’ancien Premium restent de bon sens : l’abonnement ne doit pas être un « mur payant » à l’entrée du jeu, il ne faut pas promettre de Robux ou de récompenses hors du jeu, et un éventuel avantage doit rester non décisif face aux joueurs non abonnés (un objet cosmétique, pas une arme surpuissante).

Quand utiliser quoi ?

📌 Ce qu’il faut retenir

• Un abonnement se renouvelle chaque mois : 70 % pour toi en Robux, ou 70 % puis 100 % en monnaie locale (octobre 2026).
• Vérifie-le côté serveur avec GetUserSubscriptionStatusAsync (champ IsSubscribed) et Players.UserSubscriptionStatusChanged, et l’éligibilité avec PolicyService.
• L’avantage doit s’arrêter quand l’abonnement prend fin.
• Les Premium Payouts ont été remplacés le 24 juillet 2025 par les Creator Rewards (engagement quotidien et nouveaux joueurs).
• Roblox Plus (lancé le 30 avril 2026) succède à Premium, qui n’est plus vendu depuis cette date ; utilise Player.HasRobloxSubscription au lieu de MembershipType.

📚 Sources et pour aller plus loin

• Subscriptions — guide officiel (prix, parts, délais, code)
• MarketplaceService — référence de l’API (abonnements)
• PolicyService — référence de l’API
• Creator Rewards — programme officiel
• Engagement-based payouts — ancienne page, avec l’avis de remplacement
• Roblox Plus — gains des créateurs
• Introducing Roblox Plus — annonce officielle sur le DevForum
• Roblox Premium Membership — fin de la vente de Premium (aide officielle)
• Players.UserSubscriptionStatusChanged — référence de l’API
• Player.HasRobloxSubscription — référence de l’API