Un `Logger` émet des entrées de journal structurées qui sont étiquetées avec un nom hiérarchique, vous permettant de regrouper des messages liés par sous-système ou fonctionnalité. Obtenez un logger de niveau supérieur à partir de `Class.LogService:GetLogger()`, puis créez des loggers enfants imbriqués avec `Class.Logger:GetLogger()`. Chaque logger a un `Class.Logger.Name` court et un `Class.Logger.FullPath` joint par des points construit à partir de son ascendance (par exemple, un logger nommé `Damage` créé à partir d'un logger nommé `Combat` a le chemin complet `Combat.Damage`).

```lua
local LogService = game:GetService("LogService")

local combat = LogService:GetLogger("Combat")
local damage = combat:GetLogger("Damage")

print(damage.Name)      --> Damage
print(damage.FullPath)  --> Combat.Damage

damage:Info("Infligé {amount} de dégâts à {target}", {amount = 25, target = "Gobelin"})
```
Les loggers se comportent de la même manière que les méthodes de journalisation structurée sur `Class.LogService` : les messages s'écoulent vers la fenêtre **Output**, la Console Développeur, et `Class.LogService.MessageOut`, et sont inclus dans `Class.LogService:GetLogHistory()` étiquetés avec le chemin complet du logger.

#### Hiérarchie et Propagation

Lorsqu'un message est enregistré sur un logger, son événement `Class.Logger.MessageOut` se déclenche sur ce logger **et** sur chaque ancêtre jusqu'à la racine. Cela vous permet d'attacher un écouteur sur un logger parent pour observer tous les messages émis par ses descendants. Le message est émis au système de sortie du moteur exactement une fois, étiqueté avec le chemin complet du logger d'origine.

#### Syntaxe de Modèle et Contexte

Les méthodes de journalisation acceptent les mêmes espaces réservés de modèle `{key}` et tables `context` que les méthodes de journalisation structurée sur `Class.LogService`. Voir `Class.LogService` pour des détails sur la syntaxe de modèle et comment les valeurs de contexte sont stockées.

#### Durée de Vie

Un logger reste valide tant que vous conservez une référence à celui-ci. Une fois toutes les références à un logger (et ses descendants) libérées, il est récupéré, et appeler toute méthode sur un logger obsolète génère une erreur. Le nombre de loggers actifs et la longueur du chemin complet d'un logger sont tous deux limités ; dépasser l'une ou l'autre limite génère une erreur de `Class.Logger:GetLogger()`.

#### Avertissement

Cette classe peut avoir un comportement inattendu ou peu fiable et le contenu peut être tronqué. Ne comptez pas sur le contenu des événements et des messages émis par les loggers pour une logique de jeu importante.


Se déclenche chaque fois qu'un message est enregistré via ce logger ou tout logger en dessous dans la hiérarchie. Parce qu'un message enregistré déclenche `MessageOut` sur le logger d'origine et chacun de ses ancêtres, un écouteur attaché à un logger parent observe chaque message émis par ses descendants. Le paramètre `message` contient le texte entièrement rendu (les espaces réservés de modèle déjà remplacés), et le paramètre `context` contient les paires clé-valeur structurées lorsque le message a été enregistré avec une table de contexte ; sinon, il est nul.

```lua
local LogService = game:GetService("LogService")
local combat = LogService:GetLogger("Combat")

combat.MessageOut:Connect(function(message, messageType, context)
	print("[Combat]", message)
end)

-- Un message enregistré sur un descendant déclenche également le MessageOut du parent.
combat:GetLogger("Damage"):Info("Touché pour {amount}", {amount = 10})
-- Imprime : [Combat] Touché pour 10
```


Logger.MessageOut

message

La chaîne de message entièrement rendue après toute substitution d'espace réservé de modèle.


messageType

Une valeur `Enum.MessageType` indiquant le niveau de gravité du message.


context

Un dictionnaire de paires clé-valeur fournies lorsque le message a été enregistré, ou nul si aucun contexte n'a été fourni.


Se déclenche lorsqu'un message est enregistré via ce logger ou l'un de ses descendants.


Renvoie le logger enfant avec le `name` donné, le créant s'il n'existe pas déjà. Appeler cela avec le même nom de manière répétée renvoie la même instance de logger tant qu'une référence à celui-ci est conservée. Le `Class.Logger.FullPath` du logger retourné est le chemin complet de ce logger suivi de `.` et `name`.

Cette méthode génère une erreur si le nom est vide, contient un `.`, ou contient des caractères de contrôle, si le chemin complet résultant est trop long, ou si le nombre maximum de loggers actifs a été dépassé.

```lua
local LogService = game:GetService("LogService")

local network = LogService:GetLogger("Network")
local http = network:GetLogger("Http")

print(http.FullPath)  --> Network.Http
```


Logger:GetLogger

name

Le nom du logger enfant. Doit être non vide, ne doit pas contenir de caractère `.` et ne doit pas contenir de caractères de contrôle.


Le `Class.Logger` enfant dont le chemin complet est le chemin complet de ce logger suivi de `.name`.


Renvoie un logger enfant avec le nom donné, le créant s'il n'existe pas déjà.


Enregistre un message au niveau `Enum.MessageType.MessageOutput`, étiqueté avec le `Class.Logger.FullPath` de ce logger. Lorsqu'une table `context` est fournie, les espaces réservés de modèle comme `{key}` dans le message sont remplacés par les valeurs de contexte correspondantes, et le contexte est préservé en tant que données structurées pour l'affichage dans la Console Développeur et la fenêtre **Output** de Studio.

```lua
local LogService = game:GetService("LogService")
local logger = LogService:GetLogger("Shop")

logger:Output("Le joueur {name} a ouvert le magasin", {name = "Alice"})
-- Sortie : "Le joueur Alice a ouvert le magasin"
```


Logger:Output

La chaîne de message. Prend en charge les espaces réservés de modèle `{key}` lorsqu'une table de contexte est fournie.


Un dictionnaire optionnel de paires clé-valeur. Lorsqu'il est fourni, les espaces réservés `{key}` dans le message sont remplacés par les valeurs correspondantes.


Enregistre un message au niveau `Enum.MessageType.MessageOutput` avec un contexte structuré optionnel.


Enregistre un message au niveau `Enum.MessageType.MessageInfo`, étiqueté avec le `Class.Logger.FullPath` de ce logger. Lorsqu'une table `context` est fournie, les espaces réservés de modèle comme `{key}` dans le message sont remplacés par les valeurs de contexte correspondantes.

```lua
local LogService = game:GetService("LogService")
local logger = LogService:GetLogger("Combat")

logger:Info("Infligé {amount} de dégâts", {amount = 42})
-- Sortie : "Infligé 42 de dégâts"
```


Logger:Info

Enregistre un message au niveau `Enum.MessageType.MessageInfo` avec un contexte structuré optionnel.


Enregistre un message au niveau `Enum.MessageType.MessageWarning`, étiqueté avec le `Class.Logger.FullPath` de ce logger. Lorsqu'une table `context` est fournie, les espaces réservés de modèle comme `{key}` dans le message sont remplacés par les valeurs de contexte correspondantes.

```lua
local LogService = game:GetService("LogService")
local logger = LogService:GetLogger("Combat")

logger:Warn("Santé faible : {hp}", {hp = 5})
-- Sortie : "Santé faible : 5"
```


Logger:Warn

Enregistre un message au niveau `Enum.MessageType.MessageWarning` avec un contexte structuré optionnel.


Enregistre un message au niveau `Enum.MessageType.MessageError`, étiqueté avec le `Class.Logger.FullPath` de ce logger. Contrairement à `Class.LogService:Error()`, cette méthode émet une entrée de journal de niveau erreur et retourne normalement ; elle ne lance **pas** d'exception. Lorsqu'une table `context` est fournie, les espaces réservés de modèle comme `{key}` dans le message sont remplacés par les valeurs de contexte correspondantes.

```lua
local LogService = game:GetService("LogService")
local logger = LogService:GetLogger("Network")

logger:Error("Échec de la requête : {reason}", {reason = "délai d'attente"})
-- Émet un journal de niveau erreur ; l'exécution continue.
```


Logger:Error

Enregistre un message au niveau `Enum.MessageType.MessageError` avec un contexte structuré optionnel.


Enregistre un message au niveau `Enum.MessageType` spécifié, étiqueté avec le `Class.Logger.FullPath` de ce logger. C'est une méthode polyvalente qui combine `Class.Logger:Output()|Output()`, `Class.Logger:Info()|Info()`, `Class.Logger:Warn()|Warn()`, et `Class.Logger:Error()|Error()` en un seul appel avec un paramètre de type de message explicite. Contrairement à `Class.LogService:Log()`, passer `Enum.MessageType.MessageError` émet un journal de niveau erreur et retourne normalement plutôt que de lancer une exception.

```lua
local LogService = game:GetService("LogService")
local logger = LogService:GetLogger("Combat")

logger:Log(Enum.MessageType.MessageInfo, "Événement {action}", {action = "apparition"})
```


Logger:Log

Le `Enum.MessageType` spécifiant le niveau de journal.


Enregistre un message au niveau spécifié avec un contexte structuré optionnel.


Logger

Le nom de ce logger tel que fourni à `Class.LogService:GetLogger()` ou `Class.Logger:GetLogger()`. C'est un segment de chemin unique et ne contient jamais de caractère `.`. Utilisez `Class.Logger.FullPath` pour le chemin complet joint par des points.


Logger.Name

Le segment de nom de ce logger au sein de son parent.


Le chemin complet de ce logger, formé en joignant le `Class.Logger.Name` de chaque logger depuis la racine jusqu'à celui-ci avec des séparateurs `.`. Pour un logger de niveau supérieur, le chemin complet est égal à son nom. Les messages enregistrés via ce logger sont étiquetés avec ce chemin complet dans `Class.LogService:GetLogHistory()`.


Logger.FullPath

Le chemin joint par des points de ce logger depuis le logger racine.


Un logger nommé qui émet des entrées de journal structurées limitées à un chemin hiérarchique.


`Object` est la classe de base pour toutes les classes dans la hiérarchie des classes Roblox.
Chaque autre classe que le moteur Roblox définit hérite de tous les membres
 de `Object`. Il n'est pas possible de créer directement un `Object`.


Cet exemple démontre les subtilités de l'événement `Changed` sur des objets normaux
et des objets `Value`.


Cet exemple de code démontre l'événement Changed se déclenchant dans un objet parent.


Cet événement se déclenche immédiatement après qu'une propriété d'objet a été changée, avec
certaines exceptions (voir ci-dessous). La nouvelle valeur d'une propriété changée est
**non** passée en tant que paramètre. Au lieu de cela, vous pouvez y accéder en utilisant
`object[property]`:

```
object.Changed:Connect(function(property)
	print("La nouvelle valeur de la propriété est", object[property])
end)
```

- Si vous êtes uniquement intéressé par l'écoute des changements d'une propriété spécifique,
  envisagez d'utiliser la méthode
  `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` à la place.
- Pour écouter les changements d'attributs, voir
  `Class.Instance:GetAttributeChangedSignal()` et
  `Class.Instance.AttributeChanged`.
- Pour détecter quand des enfants sont ajoutés ou supprimés, voir
  `Class.Instance.ChildAdded` et `Class.Instance.ChildRemoved`.

Pour les objets `Class.ValueBase` tels que `Class.IntValue` et
`Class.StringValue`, cet événement ne se déclenche que lorsque la propriété `Value`
del'objet change. Pour détecter d'autres changements dans les objets `Class.ValueBase`,
utilisez `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()`.

#### Limitations

Cet événement ne se déclenche **pas** pour les changements liés à la physique, tels que lorsque les
propriétés `Class.BasePart.CFrame|CFrame`,
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity`,
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity`,
`Class.BasePart.Position|Position`, ou
`Class.BasePart.Orientation|Orientation` d'un `Class.BasePart`
changent en raison de la gravité. Pour détecter les changements dans ces propriétés, envisagez
utiliser un événement basé sur la physique comme `Class.RunService.PreSimulation`.
De même, l'événement `Changed` ne se déclenche pas lorsque
`Class.BasePart.AssemblyMass|AssemblyMass` se met à jour en raison d'un changement de
matériau, de taille ou de densité pour une pièce soudée (mais l'événement se déclenche pour
`Class.BasePart.Mass|Mass` si vous modifiez la taille d'une pièce).

Pour les propriétés qui changent fréquemment, l'événement `Changed` pourrait ne pas se déclencher
pour chaque modification, ou il pourrait ne pas se déclencher du tout. **Si un changement de propriété
impacte votre logique de jeu, testez soigneusement** pour vous assurer que l'événement se déclenche comme vous l'attendez.


Object.Changed

property

Se déclenche immédiatement après qu'une propriété de l'objet change, avec quelques
limitations.


Cet exemple de code démontre comment sauvegarder une valeur avant qu'un événement de changement ne se déclenche
sur celle-ci afin d'obtenir plus d'informations sur un changement.


Cet exemple de code démontre l'équivalence de l'événement `Changed` et de l'événement
retourné par `GetPropertyChangedSignal`.

Cette méthode renvoie un événement qui se comporte exactement comme le
`Class.Object.Changed|Changed` événement, sauf qu'il ne se déclenche que lorsque la
propriété donnée change. Il est généralement préférable d'utiliser cette méthode
plutôt qu'une connexion à `Class.Object.Changed|Changed` avec une fonction
qui vérifie le nom de la propriété. Les appels suivants à cette méthode sur le même
objet avec le même nom de propriété renvoient le même événement.

Les objets `Class.ValueBase`, tels que `Class.IntValue` et
`Class.StringValue`, utilisent un événement `Class.Object.Changed|Changed` modifié
qui se déclenche avec le contenu de leur propriété `Value`. Ainsi, cette
méthode fournit un moyen de détecter les changements dans d'autres propriétés de ces
objets.

Notez que cet événement ne passera aucun argument à une fonction connectée,
donc la valeur de la propriété changée doit être lue directement dans un
script.

#### Limitations

L'événement renvoyé par cette méthode ne se déclenche **pas** pour les changements liés à la physique,
comme lorsque les propriétés `Class.BasePart.CFrame|CFrame`,
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity`,
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity`,
`Class.BasePart.Position|Position`, ou
`Class.BasePart.Orientation|Orientation` d'un `Class.BasePart`
changent en raison de la gravité. Pour détecter les changements dans ces propriétés, envisagez
utiliser un événement basé sur la physique comme `Class.RunService.PreSimulation`.

De plus, l'événement renvoyé peut ne pas se déclencher à chaque modification de
propriétés qui changent très fréquemment, et/ou il peut ne pas se déclencher pour de telles
propriétés du tout. Il est recommandé de tester soigneusement les changements de propriété
qui impactent la logique du jeu.


Object:GetPropertyChangedSignal

La propriété à laquelle se connecter.


Un signal qui se déclenche chaque fois que la propriété change.


Obtenez un événement qui se déclenche lorsque une propriété donnée de l'objet change.


Démontre comment déterminer la classe de Workspace en utilisant `Class.Instance:IsA()`

Workspace est de la classe 'Workspace', donc la première affirmation est vraie. Workspace
n'est pas de la classe 'BasePart', donc la deuxième affirmation est fausse. Workspace
hérite de Instance et est donc de la classe 'Instance', donc la troisième
affirmation est vraie.


IsA renvoie vrai si la classe de l'objet est **équivalente à** ou une
**sous-classe** d'une classe donnée. Cette fonction est similaire aux
opérateurs **instanceof** dans d'autres langages, et est une forme de
[introspection de type](https://en.wikipedia.org/wiki/Type_introspection). Pour
ignorer l'héritage de classe, testez directement la propriété `Class.Object.ClassName|ClassName`.
Pour vérifier les types de données natifs Luau (nombre,
chaîne, etc.), utilisez les fonctions `type` et `typeof`.

Le plus souvent, cette fonction est utilisée pour tester si un objet est une sorte de
partie, comme `Class.Part` ou `Class.WedgePart`, qui hérite de
`Class.BasePart` (une classe abstraite). Par exemple, si votre objectif est de
changer tous les membres d'un personnage à la même couleur, vous pourriez utiliser
`Class.Instance:GetChildren()|GetChildren` pour itérer sur les enfants,
puis utiliser IsA pour filtrer les objets non-`Class.BasePart` qui manquent la
propriété `Datatype.BrickColor`:

```lua
local Players = game:GetService("Players")

local function paintFigure(character, color)
	-- Itérer sur les objets enfants du personnage
	for _, child in character:GetChildren() do
		-- Filtrer les objets non-part, tels que Shirt, Pants et Humanoid
		-- R15 utilise MeshPart et R6 utilise Part, donc nous utilisons BasePart ici pour détecter les deux :
		if child:IsA("BasePart") then
			child.BrickColor = color
		end
	end
end
paintFigure(Players.Player.Character, BrickColor.new("Bright blue"))
```
Puisque toutes les classes héritent de `Class.Object`, appeler
`object:IsA("Object")` renverra toujours vrai.


Object:IsA

className

La classe contre laquelle la classe de l'Objet sera vérifiée.
Sensible à la casse.


Décrit si la classe de l'Objet correspond ou est une sous-classe de la
classe donnée.


Renvoie vrai si la classe d'un objet correspond ou hérite d'une classe donnée.


Object:isA

Object

Une chaîne en lecture seule représentant la classe à laquelle appartient ce `Class.Object`.

Cette propriété peut être utilisée avec diverses autres fonctions qui sont utilisées pour
identifier des objets par type, telles que `Class.Object:IsA()` ou
`Class.Instance:FindFirstChildOfClass()`.

Notez que cette propriété est en lecture seule et ne peut pas être modifiée par des scripts.
Les développeurs souhaitant changer la classe d'un objet devront plutôt créer
un nouveau `Class.Object`.

Contrairement à `Class.Object:IsA()`, ClassName peut être utilisé pour vérifier si un objet
appartient à une classe spécifique en ignorant l'héritage de classe. Par exemple :


Object.ClassName

Une chaîne en lecture seule représentant la classe à laquelle appartient ce `Class.Object`.


Object.className

`Object` est la classe de base pour toutes les classes dans la hiérarchie des classes Roblox.


Luau

Dictionary

Un logger nommé qui émet des entrées de journal structurées limitées à un chemin hiérarchique.

Class

Catégorie de message et niveau de gravité.

Enum

Enum.MessageType

Un objet qui exécute des fonctions connectées lors d'une occurrence spécifique.

Data Type

RBXScriptSignal

Type de données ayant une valeur de vrai ou faux.

boolean

Une séquence de caractères, tels que des lettres, des chiffres et des symboles.

string

Expériences

Avatar

Contenus

Exemples et projets

API du moteur

Ouvrir Cloud API

Studio

Analyses

Plateforme

Tutoriels

Programmes Créateurs

Éducation

Apprendre

Cette méthode est asynchrone et retourne une `Operation`, qui représente l'état courant de l'opération. Il contient un chemin de terminaison que vous pouvez interroger pour obtenir la vraie réponse et les métadonnées applicables. Voir la [documentation]({longRunningOperationsLink}) sur les opérations à long terme pour plus d’informations.
            
Les sections suivantes décrivent la réponse et les objets de métadonnées qui sont fournis lorsqu'une opération se termine.

Les points de terminaison bêta sont prêts à être utilisés publiquement. Des modifications sont possibles mais rares.

Ces pages de documentation Open Cloud seront supprimées le 31 mars 2026. À compte de cette date, vous serez automatiquement redirigé vers la nouvelle documentation Open Cloud. {linkStart}En savoir plus{linkEnd}

Ces anciennes pages Open Cloud seront supprimées et redirigées le 31 mars 2026. {linkStart}En savoir plus{linkEnd}

Les points de terminaison expérimentaux sont accessibles au public, mais peuvent parfois faire l'objet de modifications majeures lors de la finalisation du contrat de l'API.

Ce point de terminaison peut être appelé au sein de l'expérience via {httpServiceLinkStart}HttpService{httpServiceLinkEnd} avec une clé API.

Ce champ peut être défini lors de la création d'une ressource, mais ne peut pas être modifié par des requêtes ultérieures.

Ces champs peuvent être définis lors de la création d'une ressource, mais ne peuvent pas être modifiés par des requêtes ultérieures.

Ce champ peut être fourni dans les demandes, mais ne sera jamais inclus dans les réponses.

Méthode d'authentification obsolète. Privilégiez l'utilisation d'une clé API ou d'OAuth 2.0 lorsque cela est possible.

Par clé API : {maxInPeriod} demande toutes les {periodInSeconds} secondes par adresse IP

Ne requiert pas d'authentification pour l'appel. Présente généralement des limites de débit bien plus faibles. Il est toujours préférable d'utiliser une clé API ou OAuth 2.0 lorsque cela est possible.

Pour chaque regroupement, un seul des champs suivants du schéma doit être fourni. Les autres peuvent être exclus.

Vous pouvez réactiver cette fonctionnalité à tout moment. {linkStart}Faites-nous part de vos commentaires.{linkEnd}

Vous consultez l'ancienne documentation. {linkStart}Faites-nous part de vos commentaires.{linkEnd}

Vous pouvez désactiver cette fonctionnalité à tout moment et revenir aux anciennes pages de référence. {linkStart}Rédiger un commentaire{linkEnd}.

Vous consultez la documentation remaniée. {linkStart}Faites-nous part de vos commentaires.{linkEnd}

Ce champ peut être défini sur les réponses, mais sera ignoré dans les demandes.

Remarque : les limites de débit peuvent être plus basses pendant les périodes de fort trafic. Certains points d'extrémité ont des limites de débit supplémentaires. [En savoir plus sur les limites de taux]({link}).

{limit} requêtes par jour sur toutes les clés API d'un utilisateur ou d'un groupe

{limit} requêtes par heure pour toutes les clés API pour un utilisateur ou un groupe

{limit} requêtes par minute pour toutes les clés API pour un utilisateur ou un groupe

{limit} requêtes par seconde pour toutes les clés API pour un utilisateur ou un groupe

{limit} requêtes par minutes par propriétaire de clé API

{limit} requêtes par jour par utilisateur de l'application

{limit} requêtes par heure par utilisateur de l'application

{limit} requêtes par minute par utilisateur de l'application

{limit} requêtes par seconde par utilisateur de l'application

{limit} requête.s par seconde par propriétaire de clé API

Les périmètres d'application définissent les autorisations de vos identifiants. Ceux-ci ne peuvent accéder qu'aux points de terminaison correspondant aux périmètres d'application sélectionnés.

Les points de terminaison stables sont prêts pour la production et ne connaîtront pratiquement jamais de modifications importantes au cours de leur existence.

Cette cible vous permet de limiter l'accès de votre clé aux {requiredParts}sélectionnées

Cette cible vous permet de limiter l'accès de votre clé aux {requiredParts} et {optionalParts} sélectionnées.

Les types de cibles permettent de restreindre les ressources sur lesquelles vos identifiants disposent de droits. Seules les ressources sélectionnées seront accessibles, même si votre compte possède des permissions sur d'autres ressources. Certains périmètres d'application ne comportent pas de cibles ; dans ce cas, toutes vos ressources concernées restent accessibles.

La partie de niveau supérieur de l'univers n'a pas à être sélectionnée pour les clés API dont vous disposez. Ainsi, votre clé API pourra accéder à toutes vos expériences personnelles ainsi qu'à celles des groupes pour lesquels vous avez les droits requis.

La fonctionnalité Essayer n'est pas encore prise en charge pour les points de terminaison nécessitant une clé API ou une authentification OAuth 2.0

L'authentification par cookie est désactivée pour les actions à haut risque afin de garantir la sécurité.

Les points de terminaison à risque critique sont extrêmement sensibles et la fonctionnalité Essayer est désactivée pour des raisons de sécurité

Remarque : les en-têtes d'authentification ne figurent pas dans cet exemple de code. Il se peut que vous deviez en ajouter un pour que la commande fonctionne.

Il s'agit d'un point de terminaison à haut risque qui peut modifier ou supprimer des données essentielles. Faites preuve de la plus grande vigilance lors des tests.

Ce point de terminaison API est classé À HAUT RISQUE et peut affecter les données en ligne ou les comptes d'utilisateurs.

Les demandes authentifiées aux API à haut risque peuvent provoquer des modifications irréversibles. Vérifiez soigneusement les paramètres de votre demande avant de continuer.

Connectez-vous pour utiliser l'authentification par cookie

Il s'agit d'un point de terminaison à faible risque qui récupère les données. Il est généralement sûr à tester.

Il s'agit d'un point de terminaison à risque moyen qui modifie les données. Testez-le soigneusement avec des comptes non essentiels, car les changements peuvent être irréversibles.

Pour sécuriser votre compte, ne collez jamais ici de texte provenant d'autres sources et ne divulguez pas les informations de cette page.

Vous vous apprêtez à tester en direct des points de terminaison d'API avec les vrais identifiants de votre compte.

Ne continuez que si vous comprenez bien les conséquences des appels d'API que vous vous apprêtez à réaliser. Consultez attentivement la documentation avant toute expérimentation.

Les appels d'API utiliseront votre session authentifiée.

Ce sont de véritables appels d'API susceptibles d'affecter votre compte ou vos données.

Des limites de débit et d'autres restrictions d'API s'appliquent.

Certaines opérations peuvent modifier ou supprimer des données.

Ce point de terminaison a été remplacé par ces autres points de terminaison recommandés :

Les périmètres d'application suivants sont requis pour appeler ce point de terminaison. Pour plus
d'informations sur la génération de clés appropriées, voir [Gestion des clés API]({apiKeyReferenceDocLink}).

Pour plus d'informations sur la génération de clés, voir [Gestion des clés API]({apiKeyReferenceDocLink}).

Les points de terminaison suivants sont disponibles à des chemins relatifs à l'URL de base.

Cette chaîne est formatée comme un [FieldMask](/cloud/reference/types#fieldmask).

Une valeur JSON peut être `null`, `boolean`, `string`, `number`, `array`, ou `object`.

Les champs d'application suivants sont nécessaires pour que votre application OAuth 2.0 puisse utiliser ce point de terminaison. Pour plus d'informations sur l'enregistrement d'une application OAuth 2.0, voir [Enregistrement et révision d'une application]. ({oauth2ReferenceDocLink}).

Pour plus d'informations sur l'enregistrement d'une application OAuth 2.0, voir [Enregistrement et examen d'une application]({oauth2ReferenceDocLink}).

Les objets suivants décrivent les charges utiles qui sont acceptées ou renvoyées. Voir chaque point de terminaison individuel pour plus d'informations sur l'utilisation de ces objets.

Les périmètres d'application suivants sont requis pour appeler ce point de terminaison.

Routes de ressources

Ce string est formatée en tant que [Timestamp](/cloud/reference/types#timestamp).

Non recommandé

Vous consultez la référence Open Cloud remaniée.

Vous avez désactivé la nouvelle référence Open Cloud.

Consultez vos comptes de facturation publicitaire.

Permet de configurer les comptes de facturation publicitaire et d'acheter du crédit d'annonce.

Consultez vos campagnes publicitaires et leurs performances.

Créez, modifiez et gérez vos campagnes publicitaires.

Cela permet de consulter des informations sur vos contenus.

Il permet d'importer et de mettre à jour des éléments sur Roblox.

Cela permet d'afficher les autorisations de contenu pour les sujets (y compris les groupes et les expériences) et les contenus auxquels votre compte a accès.

Cela permet d'accorder des autorisations de contenu à tous les sujets (y compris les groupes et les expériences) et contenus auxquels votre compte a accès.

Cela vous permet d'afficher le statut et les résultats des tâches de configuration automatique de l'avatar en votre nom.

Cela vous permet de créer et de gérer des tâches de configuration automatique de l'avatar en votre nom.

Permet de mettre à jour les badges appartenant à l'utilisateur.

Cela permet de visualiser des informations sur vos articles commerciaux.

Cela permet d'apporter des modifications à vos articles de commerce synchronisés.

Cela permet de visualiser des informations sur vos connexions marchandes.

Cela permet de modifier vos connexions commerciales.

Cela vous permet d'afficher des informations sur vos produits de la Boutique du créateur.

Cela permet de consulter les informations liées à vos enregistrements dans la boutique du créateur.

Cela permet de modifier les informations liées à vos enregistrements dans la boutique du créateur.

Donne accès à la création de data stores en votre nom.

Permet de supprimer des stockages de données en votre nom.

Permet d'accéder à une liste de magasins de données.

Donne l'accès pour prendre un instantané de tes magasins de données.

Donne l'accès à la création d'entrées dans tes magasins de données.

Permet de marquer les entrées spécifiées en vue de leur suppression.

Donne accès à la liste des entrées de votre data store.

Donne l'accès à la lecture des entrées spécifiées dans tes magasins de données.

Permet de mettre à jour la valeur, les attributs et les utilisateurs d'une entrée.

Donne accès à la suppression des révisions des entrées de votre data store.

Donne accès à la liste des révisions des entrées de votre data store.

Donne accès aux révisions en lecture des entrées de votre data store.

Permet d'afficher les détails de configuration des produits développeur de l'utilisateur autorisé.

Permet de modifier les produits développeur de l'utilisateur autorisé.

Cela permet de visualiser des informations sur les environnements de votre univers.

Cela permet de modifier les environnements de votre univers.

Permet d'afficher les détails de configuration des passes de jeu de l'utilisateur autorisé.

Permet de modifier les passes de jeu de l'utilisateur autorisé.

Permet d'afficher les informations des forums de la communauté pour votre compte.

Permet d'afficher les informations des forums de la communauté pour le compte.

Cela permet d'afficher des informations sur vos communautés.

Cela te permet de gérer les demandes d'adhésion à la communauté et les mises à jour de rôle des membres de la communauté de rang inférieur pour ton compte.

Permet d'afficher les données de propriétés d'une instance.

Vous permet de modifier les données des propriétés des instances (actuellement ne supporte que les scripts).

Accorde l'accès à la gestion des contenus de l'utilisateur.

Donne accès à la gestion de tes badges.

Donne accès à la gestion de vos badges et à l'utilisation de Robux.

Donne l'accès à la mise à jour des badges de l'utilisateur autorisé.

Donne accès à la gestion de vos produits développeurs.

Accorde l'accès aux informations sur les expériences pour lesquelles vous avez activé les notifications.

Accorde l'activation ou la désactivation des notifications pour des expériences en votre nom.

Donne accès à la gestion de tes passes.

Donne accès à la gestion de tes communautés.

Donne la permission de lire les informations de la communauté.

Donne des autorisations de gestion de la communauté.

Donne accès à la lecture et à l'écriture de vos tables de localisation

Donne accès à la gestion de la collaboration en équipe pour toutes tes expériences.

Donne accès à la gestion de vos expériences et de certaines informations associées à vos expériences (par exemple des informations de localisation).

Permet de lire les informations de localisation de vos expériences.

Permet de modifier les préférences de localisation de vos expériences.

Donne accès à la gestion de votre compte utilisateur.

Permet l'accès pour modifier les préférences de localisation de l'utilisateur.

Vous permet de visualiser le statut, les journaux et les résultats des tâches d'exécution de Luau pour le lieu associé.

Vous permet de créer de nouvelles tâches d'exécution de Luau pour le lieu associé.

Donne accès à la purge asynchrone de toutes les structures de données de l'univers.

Permet de créer de nouveaux items dans la file d'attente.

Permet d'accéder à des éléments lus depuis le devant de la file d'attente.

Accorde l'accès à la lecture des items situés à l'avant de la file d'attente.

Permet de lire les items de votre mémoire.

Permet d'accéder à la lecture des éléments de la carte.

Donne accès à la création, la mise à jour et la suppression des éléments de la carte.

Cela permet de publier des messages au nom des utilisateurs.

Cela permet d'envoyer des notifications de votre expérience aux utilisateurs.

(Obsolète) Donne accès à la lecture d'une liste d'entrées dans un magasin de données ordonné.

(Obsolète) Donne l'accès à la création d'une nouvelle entrée dans un magasin de données ordonné.

Permet d'accéder aux entrées d'une liste à partir d'un magasin de données ordonné.

Donne l'accès à la création d'entrées dans un magasin de données ordonné.

Cela permet d'énumérer les secrets liés à ton expérience.

Cela permet de créer et de mettre à jour des secrets liés à ton expérience.

Cette autorisation vous permet de soumettre un job d'évaluation et de visualiser le résultat de l'emploi.

Permet d'accéder aux informations sur les produits de votre abonnement.

Cela permet de lire les informations des miniatures en votre nom.

Permet de créer ou de modifier des alertes d'analyse.

Permet la lecture des analyses de l'expérience.

Permet d'écrire des ressources liées aux analyses du jeu.

Donne la capacité de lire les informations sur les lieux.

Donne la possibilité d'éditer les informations du lieu.

Donne accès à la publication de nouvelles versions d'expériences à Roblox.

Cela vous permet de lire les miniatures et les paramètres de personnalisation des miniatures pour vos expériences.

Cela vous permet d'importer et de supprimer des miniatures et de gérer les paramètres de personnalisation des miniatures pour vos expériences.

Donne la possibilité de lire des informations sur l'expérience.

Donne l'accès à la modification des expériences de l'utilisateur autorisé.

Permet de voir les restrictions de l'utilisateur dans l'expérience.

Vous permet de modifier les restrictions d'utilisateur dans l'expérience.

Cela permet la consultation des notifications envoyées à votre compte.

Accorde la possibilité de lire la prime et le statut vérifié de l'utilisateur autorisé.

Cela te permet de voir les comptes sociaux de l'utilisateur autorisé.

Permet de lire les événements d'un jeu.

Permet de modifier les événements d'un jeu

Cela active la fonctionnalité Single Sign-On.

Cela vous donne accès à la lecture des informations de votre profil.

Résumé