Abonnements

Abonnements dans les jeux vous permettent d'offrir aux utilisateurs des avantages récurrents moyennant des frais mensuels. Les abonnements sont similaires aux pass, mais alors que les avantages d'un pass sont accordés indéfiniment, les avantages d'un abonnement dépendent du paiement d'un frais mensuel par l'utilisateur.

Les abonnements sur Roblox ont les caractéristiques suivantes :

• Renouvellement automatique : Les abonnements se renouvellent automatiquement, ce ne sont pas des achats uniques, et peuvent être fixés en devise locale ou en Robux.
• Paiement en Robux : Qu'un abonnement soit acheté en devise locale ou en Robux, vous recevez les revenus de l'abonnement en Robux. Pour plus de détails, voir Gagner avec les abonnements.
• Un seul niveau : Tous les abonnements d'un jeu peuvent être possédés par des utilisateurs simultanément. Les abonnements mutuellement exclusifs ne sont pas supportés.
• Tarification régionale : La Tarification régionale est activée par défaut pour les abonnements vendus en Robux et ne peut pas être désactivée. La Tarification régionale n'est pas disponible pour les abonnements vendus en devise locale.

Directives sur les abonnements

Avant de créer vos abonnements, assurez-vous qu'ils respectent les Conditions d'utilisation de Roblox et se conforment aux lois locales. Tout jeu qui engage des escroqueries, tente de tromper les utilisateurs avec de fausses offres, ou viole autrement nos Normes de la communauté sera retiré.

Vous devez également vous assurer que vos abonnements respectent ces directives :

• Fournir des options d'abonnement claires et distinctes : Utilisez des noms courts, succincts et explicites qui différencient les options d'abonnement les unes des autres. Spécifiez le prix et la durée de chaque option lors de la marchandisation dans le jeu.
• Offrir les mêmes avantages sur toutes les plateformes et appareils : Peu importe où l'abonnement a été acheté, assurez-vous que l'utilisateur reçoit les mêmes avantages pour un plan d'abonnement donné.
• Concevoir des abonnements qui s'harmonisent entre eux et avec l'ensemble des offres du jeu : La hiérarchisation de la même suite d'avantages, comme offrir des niveaux "Bronze", "Argent" et "Or" qui sont mutuellement exclusifs, n'est pas actuellement disponible. Assurez-vous que les abonnements représentent des ensembles distincts d'avantages.
• Offrir les avantages pour toute la durée de l'abonnement : Une fois une offre d'abonnement mise en ligne, honorez les avantages décrits et ne révoquez pas les avantages en coulisse.
• Ne pas diriger les utilisateurs vers un achat sur une autre plateforme (comme mobile, web, etc.) dans le jeu : Bien que vous soyez libre de communiquer avec les utilisateurs hors plateforme, utiliser l'application Roblox pour diriger les utilisateurs vers des achats ailleurs est interdit.
• Ne pas conditionner les avantages des abonnements par des exigences supplémentaires une fois qu'un utilisateur a payé : Exiger qu'un utilisateur effectue des tâches supplémentaires, comme publier sur les réseaux sociaux, pour obtenir des avantages pour lesquels il a payé est interdit. Cette directive n'impacte pas les passes de combat, que vous êtes autorisé à créer et à commercialiser comme un achat d'abonnement.

Robux contre devise locale

Les abonnements peuvent être fixés en Robux ou en devise locale. Le tableau suivant compare les deux options de paiement.

Créer des abonnements

Pour créer un abonnement :

1. Accédez à votre jeu dans le Tableau de bord du Créateur et sélectionnez Monétisation ⟩ Abonnements.
2. Cliquez sur Créer un abonnement.
3. Téléchargez une image de couverture.
4. Entrez un nom qui est unique. Vous ne pouvez pas avoir deux abonnements avec le même nom dans le même jeu.
5. Entrez une description qui décrit clairement les avantages que vous offrez.
6. Sélectionnez l'une des options de paiement suivantes :

   • Les abonnés paient en Robux : Faites payer aux utilisateurs des frais d'abonnement récurrents en Robux. Si vous choisissez cette option, vous devez entrer un prix personnalisé supérieur ou égal à 49 Robux. La Tarification régionale est activée par défaut pour l'abonnement et ne peut pas être désactivée.
   • Les abonnés paient en devise locale : Faites payer aux utilisateurs des frais d'abonnement récurrents dans leur devise locale. Si vous choisissez cette option, vous devez choisir un prix d'abonnement parmi les 5 niveaux de prix disponibles.
7. Sélectionnez l'un des types de produits suivants :

   • Durable : Articles permanents qui persistent après utilisation ou acquisition, comme des objets physiques tels que des armes. Si un abonnement inclut un pack de différents types de biens, dont un ou plusieurs sont durables, comme un pack de valeur avec une épée et une potion, choisissez Durable comme type de produit.
   • Consommable : Articles temporaires que l'on peut racheter et qui expirent après utilisation ou acquisition, tels que des potions consommables qui accordent des boosts temporaires qui expirent avec le temps.
   • Monnaie : Tout moyen d'échange que les utilisateurs peuvent utiliser pour acheter des articles dans votre jeu.
8. Cliquez sur Créer un abonnement.

Activer les abonnements

Vous pouvez avoir jusqu'à 50 abonnements par jeu entre les abonnements actifs et inactifs.

Pour mettre un abonnement en vente, cliquez sur ⋮ à côté de l'abonnement que vous souhaitez activer et sélectionnez Activer. Les abonnements actifs sont automatiquement disponibles à la vente dans l'onglet Boutique de la page de détails du jeu et peuvent être ajoutés à votre jeu grâce aux fonctions MarketplaceService.

Avant d'activer votre abonnement pour la première fois, vous devez confirmer une version abrégée du nom de votre jeu. Ce nom abrégé de jeu est affiché à l'utilisateur lorsqu'il s'abonne et apparaît avec le nom d'abonnement que vous avez créé dans Créer des abonnements.

États des abonnements

Les abonnements ont deux états possibles :

• Actif : Les abonnements actifs sont disponibles à la vente, les abonnés pouvant renouveler leur abonnement au début de la prochaine période.
• Inactif : Les abonnements inactifs ne sont pas disponibles à la vente.

Pour changer l'état d'un abonnement, cliquez sur ⋯ en haut à droite de la tuile d'abonnement et sélectionnez Activer (si l'abonnement est actuellement inactif) ou Retirer de la vente (si l'abonnement est actuellement actif).

Si vous sélectionnez Retirer de la vente, vous aurez la possibilité de laisser les abonnés existants renouveler leur abonnement ou d'annuler les renouvellements futurs pour les abonnés actuels. Si vous ne prévoyez pas de retirer définitivement les avantages d'abonnement associés de votre jeu, nous vous recommandons de laisser les abonnés existants renouveler leur abonnement.

Modifier les abonnements

Les champs que vous pouvez modifier dépendent de la méthode de paiement.

Changer la méthode de paiement n'affecte que les nouveaux abonnements. Les abonnés existants restent sur leur méthode de paiement d'origine et doivent annuler et se réabonner pour changer.

Supprimer les abonnements

Pour supprimer un abonnement, cliquez sur ⋮ à côté de l'abonnement que vous souhaitez supprimer et sélectionnez Supprimer.

Supprimer un abonnement actif entraîne des remboursements complets pour les abonnés actifs et zéro Robux pour vous. Dans la plupart des situations, si vous souhaitez supprimer un abonnement, nous vous recommandons d'abord de le retirer de la vente, de sélectionner l'option pour annuler tous les renouvellements, et d'attendre la conclusion de la période actuelle.

La suppression d'un abonnement nécessite les quatre derniers chiffres de l'ID de l'abonnement pour confirmation.

Intégrer les abonnements dans un jeu

Vérifier le statut d'abonnement d'un utilisateur

Le code d'exemple suivant implémente la détection d'abonnement dans votre jeu :

-- Exécutez ce code sur le serveur
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local SUBSCRIPTION_ID = "EXP-11111111" -- Remplacez par votre ID d'abonnement

local function grantAward(player: Player)
	-- Vous devriez accorder le prix associé à l'abonnement ici
end

local function revokeAwardIfGranted(player: Player)
	-- Cette méthode est appelée pour chaque joueur qui n'a pas l'abonnement
    -- Si votre code sauvegarde les abonnements dans des Datasets ou fournit un certain avantage qui doit être 'révoqué'
    -- vous devriez utiliser cette méthode pour gérer la révocation
end

local function checkSubStatus(player)
	local success, response = pcall(function()
		return MarketplaceService:GetUserSubscriptionStatusAsync(player, SUBSCRIPTION_ID)
	end)

	if not success then
		warn(`Erreur lors de la vérification si le joueur a l'abonnement : {response}`)
		return
	end

	if response.IsSubscribed then
		grantAward(player)
	else
		revokeAwardIfGranted(player)
	end
end

local function onUserSubscriptionStatusChanged(player: Player, subscriptionId: string)
	if subscriptionId == SUBSCRIPTION_ID then
		checkSubStatus(player)
	end
end

Players.PlayerAdded:Connect(checkSubStatus)
Players.UserSubscriptionStatusChanged:Connect(onUserSubscriptionStatusChanged)

Remplacer un pass par un abonnement

Une option pour déployer des abonnements dans votre jeu est de remplacer un pass existant par un abonnement. C'est une excellente option si vous souhaitez mettre rapidement en œuvre des abonnements sans ajouter de nouvelles fonctionnalités ou récompenses.

Lors du remplacement d'un pass par un abonnement, gardez les éléments suivants à l'esprit :

• Tous les détenteurs existants du pass doivent continuer à bénéficier de l'avantage qu'ils ont payé.
• Le pass doit être retiré de la vente afin que de nouveaux utilisateurs puissent plutôt acheter l'abonnement.
• Les abonnements peuvent être révoqués, ce qui signifie que si votre pass précédemment maintenait ses avantages dans une base de données, vous devrez "annuler" ces avantages. Cette considération ne s'applique pas à toutes les mises en œuvre de pass, mais pourrait s'appliquer à des mises en œuvre plus complexes.

Le code d'exemple suivant remplace un pass par un abonnement :

-- Exécutez ce code sur le serveur
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local LEGACY_GAME_PASS_ID = 1234 -- Remplacez par l'ID du pass remplacé par un abonnement
local SUBSCRIPTION_ID = "EXP-11111111" -- Remplacez par votre ID d'abonnement

local function awardBenefit(player: Player)
	-- Vous devriez attribuer l'abonnement ici
end

local function revokeBenefitIfGranted(player: Player)
	-- Cette méthode est appelée pour chaque joueur qui n'a pas l'abonnement
    -- Si votre code sauvegarde les abonnements dans des Datasets ou fournit un certain avantage qui doit être 'révoqué'
    -- vous devriez utiliser cette méthode pour gérer la révocation
end

local function checkSubscriptionStatus(player: Player)
	local success, result = pcall(function()
		return MarketplaceService:GetUserSubscriptionStatusAsync(player, SUBSCRIPTION_ID)
	end)

	if not success then
		print(`Erreur lors de la récupération du statut d'abonnement : {result}`)
		return
	end

	if result.IsSubscribed then
		awardBenefit(player)
	else
		revokeBenefitIfGranted(player)
	end
end

local function onPlayerAdded(player: Player)
	local success, result = pcall(function()
		return MarketplaceService:UserOwnsGamePassAsync(player.UserId, LEGACY_GAME_PASS_ID)
	end)

	if not success then
		print(`Erreur lors de la récupération du statut de pass : {result}`)
		return
	end

	if result then
		-- Si le joueur a acheté le pass hérité, nous n'avons pas besoin de vérifier le statut de son abonnement
		-- car il a l'avantage accordé à vie
		awardBenefit(player)
		return
	end

	checkSubscriptionStatus(player)
end

local function onUserSubscriptionStatusChanged(player: Player, subscriptionId: string)
	if subscriptionId == SUBSCRIPTION_ID then
		checkSubscriptionStatus(player)
	end
end


local function onPromptGamePassPurchaseFinished(player: Player, purchasedPassID: number, purchaseSuccess: boolean)
	if purchaseSuccess and purchasedPassID == LEGACY_GAME_PASS_ID then
		awardBenefit(player)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
Players.UserSubscriptionStatusChanged:Connect(onUserSubscriptionStatusChanged)
-- Nous continuerons à écouter les achats de pass au cas où le pass serait toujours en vente
MarketplaceService.PromptGamePassPurchaseFinished:Connect(onPromptGamePassPurchaseFinished)

Inviter à acheter des abonnements

Les utilisateurs peuvent acheter des abonnements directement depuis l'onglet Boutique de votre page de détails de jeu, mais vous devriez également ajouter un moyen pour eux d'acheter des abonnements dans le jeu.

Lorsque vous invitez à acheter un abonnement, UserSubscriptionStatusChanged se déclenche si le joueur possède déjà l'abonnement, ce qui aide à capturer les scénarios où un joueur achète un abonnement depuis l'onglet Boutique de votre page de détails de jeu tout en étant déjà en jeu.

Bien que vous puissiez inviter à acheter un abonnement depuis le client, vérifier si un utilisateur possède déjà un abonnement avec GetUserSubscriptionStatusAsync doit être fait depuis le serveur.

Le code d'exemple suivant crée un RemoteFunction que le client peut utiliser pour demander le statut d'un abonnement :

-- Ce code doit s'exécuter sur le serveur
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Créez un RemoteFunction que le client peut utiliser pour demander le statut de l'abonnement
local getSubscriptionStatusRemote = Instance.new("RemoteFunction")
getSubscriptionStatusRemote.Name = "GetSubscriptionStatus"
getSubscriptionStatusRemote.Parent = ReplicatedStorage

getSubscriptionStatusRemote.OnServerInvoke = function(player: Player, subscriptionId: string)
	assert(typeof(subscriptionId) == "string")

	return MarketplaceService:GetUserSubscriptionStatusAsync(player, subscriptionId)
end

-- Ce code doit s'exécuter sur le client
local MarketplaceService = game:GetService("MarketplaceService")
local Players = game:GetService("Players")

local SUBSCRIPTION_ID = "EXP-11111111" -- Remplacez par votre ID d'abonnement

local getSubscriptionStatusRemote = ReplicatedStorage:WaitForChild("GetSubscriptionStatus")
local purchaseSubscriptionButton = script.Parent.PromptPurchaseSubscription -- Remplacez par votre bouton


local function playerHasSubscription()
    -- Notez que si votre abonnement remplace un pass, vous devrez également vérifier si le pass est possédé ici

	local success, result = pcall(function()
		return getSubscriptionStatusRemote:InvokeServer(SUBSCRIPTION_ID)
	end)

	if not success then
		print(`Erreur lors de la récupération du statut d'abonnement : {result}`)
		return
	end

    return result.IsSubscribed
end

-- Masque le bouton si le joueur a déjà l'abonnement
local function hideButtonIfPlayerHasSubscription()
    if playerHasSubscription() then
        purchaseSubscriptionButton.Visible = false
    end
end

local function onPromptSubscriptionPurchaseFinished(player: Player, subscriptionId: string, didTryPurchasing: boolean)
    if didTryPurchasing then
        -- Il peut falloir du temps pour que l'abonnement soit enregistré, donc nous vérifierons pour voir si l'achat a été effectué dans 10 secondes
        -- et masquerons le bouton si c'est le cas
        task.delay(10, hideButtonIfPlayerHasSubscription)
    end
end

-- Si le joueur a déjà l'abonnement, nous ne voulons pas afficher le bouton du tout
hideButtonIfPlayerHasSubscription()

purchaseSubscriptionButton.Activated:Connect(function()
    MarketplaceService:PromptSubscriptionPurchase(Players.LocalPlayer, SUBSCRIPTION_ID)

    -- Si le joueur a déjà l'abonnement, masquer le bouton
    hideButtonIfPlayerHasSubscription()
end)

MarketplaceService.PromptSubscriptionPurchaseFinished:Connect(onPromptSubscriptionPurchaseFinished)

Autres fonctions pertinentes

D'autres fonctions pertinentes disponibles dans MarketplaceService sont :

• GetSubscriptionProductInfoAsync, qui retourne les informations du produit d'un abonnement. Comprend si l'abonnement est fixé en Robux ou en devise locale.
• GetUserSubscriptionPaymentHistoryAsync, qui retourne l'historique de paiement d'abonnement d'un utilisateur.
• GetUserSubscriptionStatusAsync, qui retourne le statut d'abonnement d'un utilisateur.

Gagner avec les abonnements

Pour les abonnements fixés en devise locale, vous gagnez des Robux à un taux de 0,01 USD à 1 Robux selon le prix de base de la plateforme que vous avez sélectionnée, après les frais de plateforme. Vous gagnez 70 % de la valeur de l'abonnement le premier mois, et 100 % à partir du deuxième mois. Cette répartition des revenus est cohérente sur toutes les plateformes.

Par exemple, si votre abonnement mensuel est fixé à 5 USD :

• Premier mois : Vous gagnez 350 Robux (500 * 0.7 = 350)
• Deuxième mois et suivants : Vous gagnez le montant total de 500 Robux (500 * 1.0 = 500)

Pour les abonnements fixés en Robux, vous gagnez 70 % de la valeur de l'abonnement chaque mois. Cette répartition des revenus est cohérente sur toutes les plateformes.

Par exemple, si votre abonnement mensuel est fixé à 500 Robux :

• Premier mois : Vous gagnez 350 Robux (500 * 0.7 = 350)
• Deuxième mois et suivants : Vous continuez à gagner 350 Robux (500 * 0.7 = 350)

Les gains provenant des abonnements en devise locale sont soumis à une période de retenue de 30 jours et seront ajoutés à votre solde Robux après la livraison complète de la durée de l'abonnement.

Les gains provenant des abonnements en Robux suivent la même période de retenue que les passes et les produits développeurs, qui est d'environ 5 jours.

Remboursements

Pour les abonnements en devise locale, si un utilisateur demande un remboursement par l'intermédiaire de sa banque ou de la boutique d'applications dans la période de retenue de 30 jours, la retenue sera annulée et vous ne recevrez pas le paiement pour cette transaction.

Les remboursements reçus en dehors de la période de retenue entraîneront une déduction du montant du paiement pour la transaction remboursée de votre solde Robux. Si votre jeu est détenu par un Groupe et que le solde du Groupe est inférieur au montant à déduire, le reste sera déduit du solde Robux du propriétaire du Groupe.

Lorsque les utilisateurs annulent ou ne renouvellent pas leurs abonnements actifs, ils ne reçoivent pas automatiquement de remboursements. Ils doivent demander des remboursements manuellement, qui sont traités au cas par cas. Pour plus d'informations sur le processus de remboursement des abonnements utilisateurs, consultez le centre d'aide.

Paiements

Vous pouvez trouver vos paiements d'abonnement dans Solde Robux ⟩ Mes Transactions.

Les paiements d'Abonnement et de Groupe d'Abonnement apparaissent sous Robux entrants, tandis que les remboursements sont regroupés sous Robux sortants comme un Retour de Paiement. Les sous-pages d'abonnements et de groupes d'abonnements fournissent des informations supplémentaires pour leurs catégories respectives.

Pour voir les informations de remboursement pour des utilisateurs individuels, utilisez GetUserSubscriptionPaymentHistoryAsync.

Analytique des abonnements

L'analytique des abonnements vous aide à évaluer le succès des abonnements individuels, à identifier des tendances et à prévoir de potentiels futurs gains. Les abonnements sont ajoutés à la page d'analytique des abonnements après leur première activation et ne sont pas supprimés lorsqu'ils sont désactivés ou supprimés. Vous pouvez accéder à des analyses prêtes à l'emploi via le Tableau de bord du Créateur, ou vous pouvez capturer les mises à jour d'abonnement en temps réel à l'aide de webhooks.

Via le Tableau de bord du Créateur

Pour accéder à l'analytique des abonnements sur le Tableau de bord du Créateur :

1. Allez sur votre page Créations sur le Tableau de bord du Créateur et sélectionnez votre jeu.
2. Allez dans Monétisation ⟩ Abonnements.
3. Sélectionnez l'onglet Analytique.

L'analytique des abonnements suit les métriques suivantes :

• Abonnements : Le nombre total d'abonnements actifs dans votre jeu.
• Revenu estimé : Le revenu net gagné par les jeux après les frais. N'inclut pas d'informations de remboursement.
• Répartition des abonnés : Les différents types d'abonnés.

  • Nouveau : Le nombre d'achats d'abonnement par des abonnés pour la première fois.
  • Renouvelé : Le nombre d'abonnements renouvelés achetés dans une période antérieure.
  • Resuscité : Le nombre de nouveaux abonnements achetés par des utilisateurs qui avaient précédemment annulé.
• Annulations : Le nombre d'abonnements qui n'ont pas été renouvelés. Cela comprend toutes les annulations, quel qu'en soit le déclencheur, que ce soit une annulation par l'utilisateur, une désactivation d'abonnement par le créateur, ou par d'autres moyens.

  • Les annulations sont différentes des remboursements. Les abonnements annulés sont des abonnements qui ne se renouvelleront plus mais qui sont payés en intégralité pour le reste du cycle de facturation, tandis que les remboursements retournent le montant d'abonnement payé à l'utilisateur.
• Abonnements par plateforme : Le nombre d'abonnements achetés sur chaque plateforme.
• Revenus par plateforme : Le revenu net gagné grâce aux abonnements achetés sur chaque plateforme.

Ces informations sont visibles sous forme de graphiques basés sur une plage de dates dans l'onglet Tendances, et comme une liste complète des abonnements totaux offerts dans l'onglet Historique.

Via des webhooks

La fonctionnalité Webhook de l'API Cloud comprend des déclencheurs pour quatre événements d'abonnement : annulé, acheté, remboursé et renouvelé. Ces notifications sont déclenchées immédiatement, vous pouvez donc réagir en temps réel ou créer vos propres analyses personnalisées. Pour plus d'informations sur la façon de configurer un webhook, consultez Notifications Webhook.