> ## 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. # Token de transaction SDK : API de gestion Didit > Générez un token éphémère et restreint pour que les SDK Didit envoient des transactions depuis votre app. Liaison au sujet appliquée côté serveur. Prompt de l'API de token de transaction du SDK Mint Copier le prompt dans le presse-papiers \

\`Mint a short-lived scoped token that lets the Didit SDKs submit monitored transactions directly from an end-user's device.

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

Authentication:
Use the x-api-key header with my Didit API key. This call runs on YOUR BACKEND only - the API key must never ship in an app. Only the returned sdk_token travels to the device.

Goal:
\- Get an sdk_token scoped to one end user (vendor_data). The app passes it to the SDK's submitTransaction method (or directly to POST /v1/transactions/ via the X-Transaction-Token header).
\- The token binds the subject identity server-side: every transaction submitted with it has its subject forced to the token's vendor_data, so a tampered client cannot submit on behalf of another user.

Request body (application/json):
\{
"vendor_data": "user-042",   // required - your internal id for the end user
"ttl_seconds": 900,          // optional - default 900 (15 min), max 86400 (24 h)
"max_uses": 3                // optional - max successful submissions; omit for unlimited within the TTL
}
camelCase aliases (vendorData, ttlSeconds, maxUses) are also accepted.

Example call:
curl -X POST "https://verification.didit.me/v3/transactions/sdk-token/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"vendor_data":"user-042","ttl_seconds":900,"max_uses":3}'

What to read from the response:
\- sdk_token - hand this to your app; it authenticates POST /v1/transactions/ via the X-Transaction-Token header.
\- expires_at - ISO-8601 expiry; mint a fresh token per user session rather than reusing long-lived ones.

Failure modes:
\- 400 - missing vendor_data or invalid ttl_seconds/max_uses.
\- 401 - missing or malformed x-api-key.

Best practice:
\- Mint per user session, keep max_uses tight when the number of expected submissions is known.
\- A 401 from POST /v1/transactions/ whose detail contains the word "expired" means the token aged out - mint a new one and retry.

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

\
Coller dans ## OpenAPI ````yaml fr/openapi-25.json POST /v3/transactions/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/transactions/sdk-token/: post: tags: - Transactions summary: Émettre un token de transaction SDK description: >- Émettez un token à portée limitée et à courte durée de vie que votre application transmet aux SDK Didit afin qu'ils puissent soumettre des transactions directement depuis l'appareil de l'utilisateur final via `POST /v1/transactions/`. Le token est lié à un `vendor_data` (votre identifiant d'utilisateur) : l'identité du sujet de chaque transaction soumise avec celui-ci est appliquée côté serveur à partir de cette liaison, de sorte qu'un client altéré ne peut pas soumettre pour le compte d'un autre utilisateur. Émettez les tokens depuis votre backend – n'intégrez jamais la clé API elle-même dans une application. Les alias en camelCase (`vendorData`, `ttlSeconds`, `maxUses`) sont également acceptés. operationId: createTransactionSdkToken requestBody: required: true content: application/json: schema: type: object properties: vendor_data: type: string description: >- Votre identifiant interne pour l'utilisateur final auquel ce token est limité. Appliqué comme identité du sujet de chaque transaction soumise avec le token. example: user-042 ttl_seconds: type: integer default: 900 maximum: 86400 description: >- Durée de vie du token en secondes. Vaut par défaut 900 (15 minutes) ; maximum 86400 (24 heures). max_uses: type: integer nullable: true description: >- Nombre maximal de soumissions réussies autorisées avec ce token. Omettre ou définir sur null pour des utilisations illimitées dans la limite du TTL. required: - vendor_data example: vendor_data: user-042 ttl_seconds: 900 max_uses: 3 responses: '201': description: "Le token généré. Transmettez `sdk_token` à votre application\_; il authentifie les endpoints `/v1/transactions/` côté appareil via l'en-tête `X-Transaction-Token` jusqu'à `expires_at`." content: application/json: schema: type: object properties: sdk_token: type: string description: Le token de transaction restreint à transmettre au SDK. expires_at: type: string format: date-time description: Date et heure auxquelles le token cesse d'être accepté. example: sdk_token: q7Zt...urlsafe expires_at: '2026-07-07T12:15:00Z' '400': description: >- Échec de la validation : `vendor_data` manquant, ou `ttl_seconds` en dehors de la plage autorisée. content: application/json: examples: Missing vendor_data: value: vendor_data: - This field is required. '403': description: Clé API manquante, invalide ou révoquée. content: application/json: examples: Invalid API Key: value: detail: Invalid API Key. security: - ApiKeyAuth: [] x-codeSamples: - lang: curl label: curl source: >- curl -X POST https://verification.didit.me/v3/transactions/sdk-token/ \ -H 'x-api-key: YOUR_API_KEY' -H 'Content-Type: application/json' \ -d '{"vendor_data": "user-042", "ttl_seconds": 900, "max_uses": 3}' - lang: python label: Python source: |- from didit import Didit # Reads DIDIT_API_KEY. client = Didit() result = client.transactions.create_sdk_token( vendor_data="user-042", ttl_seconds=900, max_uses=3, ) 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.transactions.createSdkToken({ vendor_data: "user-042", ttl_seconds: 900, max_uses: 3, }); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Transactions.CreateSDKToken(ctx, didit.TransactionsCreateSDKTokenParams{\n\tVendorData: \"user-042\",\n\tTTLSeconds: didit.Int(900),\n\tMaxUses: didit.Int(3),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)" - lang: java label: Java source: >- import me.didit.Didit; import me.didit.types.TransactionsCreateSdkTokenParams; // Reads DIDIT_API_KEY. Didit client = new Didit(); var result = client.transactions().createSdkToken(TransactionsCreateSdkTokenParams.builder() .vendorData("user-042") .ttlSeconds(900L) .maxUses(3L) .build()); System.out.println(result); - lang: php label: PHP source: |- transactions->createSdkToken([ 'vendor_data' => 'user-042', 'ttl_seconds' => 900, 'max_uses' => 3, ]); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Reads DIDIT_API_KEY. didit = Didit::Client.new result = didit.transactions.create_sdk_token( vendor_data: "user-042", ttl_seconds: 900, max_uses: 3 ) 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.Transactions.CreateSdkTokenAsync(new TransactionsCreateSdkTokenParams { VendorData = "user-042", TtlSeconds = 900, MaxUses = 3, }); 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.