> ## Documentation Index > Fetch the complete documentation index at: https://docs.didit.me/llms.txt > Use this file to discover all available pages before exploring further. # Générer un token SDK de surveillance via l'API > Avec Didit, générez un token éphémère lié à un sujet pour envoyer des événements de surveillance depuis votre app sans exposer votre clé API. Prompt de l’API de génération d’un token du SDK Mint Monitoring Copier le prompt dans le presse-papiers \

\`Mint a short-lived device credential so my web or mobile app can send monitoring events for one user straight to Didit.

Endpoint:
POST https://verification.didit.me/v3/events/sdk-token/

Authentication:
Use the x-api-key header with my Didit API key. This call runs on MY BACKEND only - the API key must never ship in an app. Only the returned monitoring_token travels to the device. A scoped key needs transactions: write.

Goal:
\- Get a monitoring_token for the signed-in user. The app sends it in the X-Monitoring-Token header to the device lane (POST /v1/events/ and POST /v1/events/batch/).

Request body (application/json):
\{
"vendor_data": "user-42",                                  // required - the subject every event belongs to
"entity_type": "individual",                               // optional - company binds a company; any other value an individual (default)
"allowed_event_categories": ["auth", "session", "gameplay"], // optional - omit or [] for every category
"ttl_seconds": 900,                                        // optional - 60 to 86400, default 900
"max_uses": 1000,                                          // optional - events it may submit, default 1000, null for no cap
"bind_to_origin": "https://app.example.com"                // optional - browser Origin must match exactly
}
camelCase aliases (vendorData, entityType, allowedEventCategories, ttlSeconds, maxUses, bindToOrigin) are also accepted.

Behavior:
\- The subject is bound server-side: whatever subject the app sends is overwritten with vendor_data.
\- One use per submitted event, also inside a batch: a 500-event flush spends 500 uses, and events the device lane rejects spend uses too.
\- An event outside allowed_event_categories is rejected by the device lane with 400.
\- With bind_to_origin set, a device request with a different Origin, or none, is refused.
\- Minting does not create a user.
\- Event ingestion must be switched on for the application, otherwise this call returns 403 with code event_monitoring_disabled.

Example call:
curl -X POST "https://verification.didit.me/v3/events/sdk-token/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"vendor_data":"user-42","allowed_event_categories":["auth","session","gameplay"],"ttl_seconds":900,"max_uses":1000}'

What to read from the response:
\- monitoring_token - hand it to the app; treat it as a secret for its lifetime.
\- expires_at - mint a fresh credential per user session before it expires.
\- allowed_event_categories ([] means every category), max_uses (null means no cap), bind_to_origin.

Failure modes:
\- 400 - missing vendor_data, ttl_seconds outside 60-86400, max_uses below 1, or an unknown category.
\- 401 - the API key has expired.
\- 403 - missing API key (a wrong, revoked or expired key gets 401), a scoped key without transactions: write, or code event_monitoring_disabled.

Side effects: creates one credential. Nothing else changes.

For the full client-side submission guide, see /transaction-monitoring/sdk-event-submission.`

\
Coller dans L'identifiant d'authentification est utilisé par le canal des appareils, décrit dans [Envoi des événements SDK](https://docs.didit.me/fr/transaction-monitoring/sdk-event-submission.md), qui énumère également les règles que le serveur impose à chaque requête émise depuis un appareil, ainsi que les événements qui peuvent être abandonnés sans risque en cas de saturation. ## OpenAPI ````yaml fr/openapi-25.json POST /v3/events/sdk-token/ openapi: 3.0.0 info: version: 3.0.0 title: Didit Verification API description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key. servers: - url: https://verification.didit.me security: [] tags: [] paths: /v3/events/sdk-token/: post: tags: - Monitoring Events summary: Émettre un token SDK de surveillance description: >- Émettez un identifiant d'appareil à courte durée de vie lié à un sujet, afin que votre application web ou mobile puisse envoyer les événements de cet utilisateur directement à Didit sans clé API. L'application transmet le `monitoring_token` retourné dans l'en-tête `X-Monitoring-Token` au canal d'appareil (`POST /v1/events/` et `POST /v1/events/batch/`), où le sujet est toujours écrasé par ce `vendor_data`, les événements en dehors de `allowed_event_categories` sont rejetés, chaque événement envoyé consomme une utilisation, et une requête dont l'`Origin` n'est pas égal à `bind_to_origin` est refusée. Appelez-le uniquement depuis votre backend ; l'émission crée l'identifiant et rien d'autre (aucun utilisateur n'est créé). L'ingestion d'événements doit être activée pour l'application, sinon cet endpoint renvoie `403` avec `code: event_monitoring_disabled` au lieu d'émettre un identifiant qui ne pourrait jamais écrire. Une clé API avec restriction de portée nécessite `transactions: write`. Voir [Soumission d'événements par le SDK](https://docs.didit.me/fr/transaction-monitoring/sdk-event-submission). operationId: create_monitoring_event_sdk_token requestBody: required: true content: application/json: schema: type: object description: "Les alias en camelCase sont acceptés\_: `vendorData`, `entityType`, `allowedEventCategories`, `ttlSeconds`, `maxUses`, `bindToOrigin`." required: - vendor_data properties: vendor_data: type: string minLength: 1 maxLength: 255 description: >- Votre identifiant pour le sujet auquel appartient chaque événement soumis avec cet identifiant d'accès. entity_type: type: string maxLength: 32 default: individual description: >- `company` associe un sujet de type entreprise ; toute autre valeur (`individual` par défaut) associe un individu. allowed_event_categories: type: array items: type: string enum: - auth - session - gameplay - bonus - affiliate - payment - dispute - security - responsible_gambling - custom description: >- Catégories que l'identifiant peut soumettre. Omettez-le ou envoyez `[]` pour autoriser toutes les catégories. ttl_seconds: type: integer minimum: 60 maximum: 86400 default: 900 description: Durée de vie des informations d'identification en secondes. max_uses: type: integer minimum: 1 nullable: true default: 1000 description: >- Nombre d'événements que l'identifiant peut soumettre (un lot consomme une utilisation par événement). Envoyez `null` pour ne pas appliquer de plafond pendant la durée de validité. bind_to_origin: type: string maxLength: 255 nullable: true description: >- Lorsqu'il est défini, l'en-tête `Origin` du navigateur de chaque requête de l'appareil doit correspondre exactement à cette valeur ; une requête sans `Origin` est refusée. example: vendor_data: user-42 allowed_event_categories: - auth - session - gameplay ttl_seconds: 900 max_uses: 1000 bind_to_origin: https://app.example.com responses: '201': description: >- L'identifiant d'authentification a été créé. Transmettez `monitoring_token` à l'application et traitez-le comme un secret jusqu'à `expires_at`. content: application/json: schema: type: object required: - monitoring_token - expires_at - allowed_event_categories - max_uses - bind_to_origin properties: monitoring_token: type: string description: >- L'identifiant d'authentification de l'appareil (un token de 43 caractères compatible avec les URL). Envoyez-le dans l'en-tête `X-Monitoring-Token`. expires_at: type: string format: date-time description: >- Date et heure à partir desquelles le justificatif cesse d'être accepté. allowed_event_categories: type: array items: type: string enum: - auth - session - gameplay - bonus - affiliate - payment - dispute - security - responsible_gambling - custom description: >- Catégories que l'identifiant peut soumettre ; `[]` signifie toutes les catégories. max_uses: type: integer nullable: true description: >- Budget d'événements de l'identifiant ; null signifie sans plafond. bind_to_origin: type: string nullable: true description: >- Origine à laquelle l'élément d'authentification est lié, ou null. example: monitoring_token: q7ZtR2xKp9VbN4mWc8LdH1sYfJ3gT6uEaQ0oPiXzBkC expires_at: '2026-10-17T09:30:02.481000Z' allowed_event_categories: - auth - session - gameplay max_uses: 1000 bind_to_origin: https://app.example.com '400': description: >- Échec de la validation : `vendor_data` manquant, `ttl_seconds` en dehors de 60 à 86400, `max_uses` inférieur à 1 ou une catégorie inconnue (indexée par sa position dans le tableau). content: application/json: examples: Missing vendor_data: value: vendor_data: - This field is required. ttl_seconds too short: value: ttl_seconds: - Ensure this value is greater than or equal to 60. Unknown category: value: allowed_event_categories: '1': - '"login" is not a valid choice.' '401': description: >- La clé API restreinte a expiré. Seule une clé expirée renvoie `401` ; une clé manquante ou invalide renvoie `403`. content: application/json: examples: Expired key: value: detail: This API key has expired. '403': description: >- Un en-tête `x-api-key` manquant (une clé erronée, révoquée ou expirée renvoie `401`), une clé restreinte sans `transactions: write`, une clé limitée à certains workflows ou à des sessions approuvées (une telle clé n'accède jamais aux données de surveillance des transactions), ou une requête provenant de l'extérieur de la liste d'autorisation IP de la clé. Également renvoyé avec `code: event_monitoring_disabled` lorsque l'ingestion d'événements est désactivée pour l'application ; rien n'est stocké dans ce cas, et la vérification s'exécute avant que le corps ne soit validé. content: application/json: examples: Event monitoring disabled: value: detail: >- Event monitoring is not enabled for this application. Turn on event ingestion in the transaction monitoring settings before submitting events. code: event_monitoring_disabled Missing or invalid API key: value: detail: You do not have permission to perform this action. Scoped key without access: value: detail: This API key has no write access to transactions. Key limited to workflows or approved sessions: value: detail: >- This API key only reaches sessions inside its workflow or status limits, so it can't use this endpoint. IP not allowed: value: detail: This API key can't be used from this IP address. '429': description: >- Limite de débit dépassée : les requêtes d'écriture (`POST`, `PATCH`, `DELETE`) partagent un quota de 300 requêtes par minute par clé API. Attendez `Retry-After` secondes, puis réessayez. headers: Retry-After: description: Secondes à attendre avant de réessayer. schema: type: integer minimum: 1 example: 30 content: application/json: examples: Throttled: value: detail: >- Write request rate limit exceeded. You can make up to 300 requests per minute. security: - ApiKeyAuth: [] x-codeSamples: - lang: curl label: curl source: |- curl -X POST 'https://verification.didit.me/v3/events/sdk-token/' \ -H 'x-api-key: YOUR_API_KEY' \ -H 'Content-Type: application/json' \ -d '{ "vendor_data": "user-42", "allowed_event_categories": ["auth", "session", "gameplay"], "ttl_seconds": 900, "max_uses": 1000, "bind_to_origin": "https://app.example.com" }' - lang: python label: Python source: |- from didit import Didit # Reads DIDIT_API_KEY. client = Didit() result = client.monitoring_events.create_sdk_token( vendor_data="user-42", allowed_event_categories=["auth", "session", "gameplay"], ttl_seconds=900, max_uses=1000, bind_to_origin="https://app.example.com", ) print(result) - lang: javascript label: Node.js source: |- import Didit from "@didit-protocol/sdk-node"; // Reads DIDIT_API_KEY. const didit = new Didit(); const result = await didit.monitoringEvents.createSdkToken({ vendor_data: "user-42", allowed_event_categories: ["auth", "session", "gameplay"], ttl_seconds: 900, max_uses: 1000, bind_to_origin: "https://app.example.com", }); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.MonitoringEvents.CreateSDKToken(ctx, didit.MonitoringEventsCreateSDKTokenParams{\n\tVendorData: \"user-42\",\n\tAllowedEventCategories: didit.Some([]didit.MonitoringEventsCreateSDKTokenParamsAllowedEventCategories{\"auth\", \"session\", \"gameplay\"}),\n\tTTLSeconds: didit.Int(900),\n\tMaxUses: didit.Int(1000),\n\tBindToOrigin: didit.String(\"https://app.example.com\"),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)" - lang: java label: Java source: >- import java.util.List; import me.didit.Didit; import me.didit.types.MonitoringEventsCreateSdkTokenParams; // Reads DIDIT_API_KEY. Didit client = new Didit(); var result = client.monitoringEvents().createSdkToken(MonitoringEventsCreateSdkTokenParams.builder() .vendorData("user-42") .allowedEventCategories(List.of(MonitoringEventsCreateSdkTokenParams.AllowedEventCategories.of("auth"), MonitoringEventsCreateSdkTokenParams.AllowedEventCategories.of("session"), MonitoringEventsCreateSdkTokenParams.AllowedEventCategories.of("gameplay"))) .ttlSeconds(900L) .maxUses(1000L) .bindToOrigin("https://app.example.com") .build()); System.out.println(result); - lang: php label: PHP source: |- monitoringEvents->createSdkToken([ 'vendor_data' => 'user-42', 'allowed_event_categories' => ['auth', 'session', 'gameplay'], 'ttl_seconds' => 900, 'max_uses' => 1000, 'bind_to_origin' => 'https://app.example.com', ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Reads DIDIT_API_KEY. didit = Didit::Client.new result = didit.monitoring_events.create_sdk_token( vendor_data: "user-42", allowed_event_categories: ["auth", "session", "gameplay"], ttl_seconds: 900, max_uses: 1000, bind_to_origin: "https://app.example.com" ) puts result.to_h - lang: csharp label: .NET source: >- using System; using System.Text.Json; using Didit; // Reads DIDIT_API_KEY. using var client = new DiditClient(); var result = await client.MonitoringEvents.CreateSdkTokenAsync(new MonitoringEventsCreateSdkTokenParams { VendorData = "user-42", AllowedEventCategories = new MonitoringEventsCreateSdkTokenParamsAllowedEventCategories[] { "auth", "session", "gameplay" }, TtlSeconds = 900, MaxUses = 1000, BindToOrigin = "https://app.example.com", }); Console.WriteLine(JsonSerializer.Serialize(result)); components: securitySchemes: ApiKeyAuth: type: apiKey in: header name: x-api-key description: >- La clé API de votre application, issue de Développeurs -> Clés API dans la Business Console. La clé principale dispose d'un accès complet. Une clé nommée peut être restreinte : aucun, lecture ou écriture par ressource, limitée à certains workflows ou aux sessions approuvées, à une liste d'adresses IP et à une date d'expiration. 401 signifie que la clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a été envoyée, que la clé n'a pas accès à cette ressource ou action, ou que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur une route de session signifie que la session est hors des workflows ou des statuts de la clé. Une clé sans accès aux médias reçoit les URL d'images, de vidéos et de PDF à null, et une clé sans accès en écriture aux sessions reçoit les liens et tokens de session à null. Voir https://docs.didit.me/console/api-keys. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.