> ## 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.

# SDK Node.js et TypeScript pour KYC et AML

> Démarrez avec le SDK Node.js et TypeScript Didit : appels d'API typés, vérification des webhooks et validation des tokens.

La bibliothèque officielle Didit pour Node.js et TypeScript. Elle fonctionne sur Node.js 18 ou version ultérieure, Bun, Deno et les runtimes edge avec `fetch`, fournit des builds ES module et CommonJS, et ne comporte aucune dépendance d'exécution. Consultez la [vue d'ensemble des SDK serveur](https://docs.didit.me/fr/integration/server-sdks/overview.md) pour connaître les éléments communs à tous les SDK.

## Installer

```bash theme={null}
npm install @didit-protocol/sdk-node
```

Le paquet est [`@didit-protocol/sdk-node` sur npm](https://www.npmjs.com/package/@didit-protocol/sdk-node). Son code source et son journal des modifications se trouvent dans [didit-protocol/sdk-node](https://github.com/didit-protocol/sdk-node) sur GitHub.

## Configurer le client

`new Didit()` lit `DIDIT_API_KEY` depuis l'environnement sur Node.js, Bun et Deno (avec `--allow-env`). Les runtimes edge n'ont pas d'environnement de processus, vous devez donc y transmettre la clé en option : `new Didit({ apiKey: env.DIDIT_API_KEY })`. Transmettez des options pour la remplacer, ou pour définir les identifiants d'organisation et d'application nécessaires aux appels limités à une application (dossiers, réseaux, rapports réglementaires). Le délai d'expiration est exprimé en millisecondes.

```typescript theme={null}
import Didit from "@didit-protocol/sdk-node";

const didit = new Didit({
  apiKey: process.env.DIDIT_API_KEY,
  organizationId: process.env.DIDIT_ORGANIZATION_ID,
  applicationId: process.env.DIDIT_APPLICATION_ID,
  timeout: 30_000,
  maxRetries: 2,
});

// Options for a single call.
const fast = didit.withOptions({ timeout: 5_000, maxRetries: 0 });
console.log(await fast.sessions.retrieveDecision("11111111-2222-3333-4444-555555555555"));
```

Avec CommonJS, utilisez `const { Didit } = require("@didit-protocol/sdk-node");`.

## Créer une session

Créez une [session de vérification](https://docs.didit.me/fr/sessions-api/create-session.md) pour un workflow et redirigez votre utilisateur vers son URL. Les champs de la requête conservent les noms définis par l'API.

```typescript theme={null}
import Didit from "@didit-protocol/sdk-node";

const didit = new Didit();

const session = await didit.sessions.create({
  workflow_id: "11111111-2222-3333-4444-555555555555",
  vendor_data: "user-123",
  callback: "https://example.com/verification/done",
});
console.log(session.url);
```

## Lire la décision

Lorsque l'utilisateur termine (ou à l'arrivée du webhook), [lisez la décision](https://docs.didit.me/fr/sessions-api/retrieve-session.md). Chaque résultat de fonctionnalité est une liste contenant une entrée par nœud de workflow, et les dates et heures sont des objets `Date`.

```typescript theme={null}
import Didit from "@didit-protocol/sdk-node";

const didit = new Didit();

const decision = await didit.sessions.retrieveDecision("11111111-2222-3333-4444-555555555555");
console.log(decision.status);
for (const verification of decision.id_verifications ?? []) {
  console.log(verification.first_name, verification.last_name);
}
```

## Vérifier un webhook

Transmettez le corps brut (pas le JSON analysé) et les en-têtes de la requête : un objet `req.headers` Node.js ou Express, un objet `Headers` Fetch ou des paires `[name, value]` (le type `WebhookHeaders`). `verify` renvoie une promesse et la rejette avec `WebhookVerificationError` pour tout ce qui n'est pas une livraison valide et récente.

```typescript theme={null}
import { webhooks, WebhookVerificationError, type WebhookHeaders } from "@didit-protocol/sdk-node";

const secret = process.env.DIDIT_WEBHOOK_SECRET ?? "";

export async function handleWebhook(rawBody: Buffer, headers: WebhookHeaders): Promise<number> {
  try {
    const event = await webhooks.verify(rawBody, headers, secret);
    if (event.webhook_type === "status.updated") {
      console.log(event.session_id, event.status);
    }
    return 200;
  } catch (error) {
    if (error instanceof WebhookVerificationError) return 400;
    throw error;
  }
}
```

Avec Express, lisez le corps avec `express.raw({ type: "application/json" })` et appelez `handleWebhook(req.body, req.headers)`. Pendant la rotation du secret, transmettez les deux : `[newSecret, oldSecret]`. Consultez [Webhooks](https://docs.didit.me/fr/integration/webhooks.md) pour connaître les événements et le mécanisme de signature.

## Analyser une transaction

Soumettez un paiement, un retrait ou un transfert crypto à la [surveillance des transactions](https://docs.didit.me/fr/transaction-monitoring/overview.md) ; la réponse contient son statut et son score de risque.

```typescript theme={null}
import Didit from "@didit-protocol/sdk-node";

const didit = new Didit();

const transaction = await didit.transactions.create({
  transaction_id: "txn-1001",
  transaction_category: "finance",
  transaction_details: { direction: "outbound", amount: 1500, currency: "EUR" },
  subject: { entity_type: "individual", vendor_data: "user-123", full_name: "Maria Garcia" },
});
console.log(transaction.status, transaction.score);
```

## Vérifier les tokens Authentication

`Authentication` vérifie les tokens d'accès signés par l'émetteur de votre [Authentication](https://docs.didit.me/fr/authentication/overview.md), sur votre backend, sans appeler Didit pour chaque requête. Il permet également d'échanger des codes, de rafraîchir des tokens, de vérifier et révoquer des sessions, et d'exécuter des étapes de renforcement de l'authentification.

> [!NOTE]
>
> La vérification de token applique les contrôles décrits dans [Vérifier un token sur votre serveur](https://docs.didit.me/fr/authentication/tokens-and-jwks.md#vérifier-un-jeton-sur-votre-serveur), par rapport à l'émetteur et aux clés de signature de votre application.

```typescript theme={null}
import { Authentication, TokenVerificationError } from "@didit-protocol/sdk-node";

// The publishable key (pk_live_... or pk_test_...) carries your issuer URL.
const auth = Authentication.fromPublishableKey("pk_live_...", { clientId: "your-application-id" });

export async function currentUser(accessToken: string): Promise<string | null> {
  try {
    const claims = await auth.verifyAccessToken(accessToken);
    return claims.sub;
  } catch (error) {
    if (error instanceof TokenVerificationError) return null;
    throw error;
  }
}
```

## Erreurs

```typescript theme={null}
import Didit, { APIStatusError, NotFoundError, RateLimitError } from "@didit-protocol/sdk-node";

const didit = new Didit();

try {
  await didit.sessions.retrieveDecision("11111111-2222-3333-4444-555555555555");
} catch (error) {
  if (error instanceof NotFoundError) console.log("no such session");
  else if (error instanceof RateLimitError) console.log("slow down, request", error.requestId);
  else if (error instanceof APIStatusError) console.log(error.status, error.body);
  else throw error;
}
```

## Listes et fichiers

```typescript theme={null}
import Didit, { fileFromPath } from "@didit-protocol/sdk-node";

const didit = new Didit();

// Lists page through every result.
for await (const session of didit.sessions.list({ status: "Approved" })) {
  console.log(session.session_id);
}

// Uploads take a Blob, a Buffer, a stream or fileFromPath.
const result = await didit.idVerification.verify({
  front_image: await fileFromPath("id-front.jpg"),
  back_image: await fileFromPath("id-back.jpg"),
});
console.log(result.id_verification);
```

Les pages des endpoints serveur de la [référence API](https://docs.didit.me/fr/api-reference/overview.md) proposent un exemple Node.js pour leur opération, à l'exception des endpoints et champs pas encore inclus dans une version 1.0.1, mentionnés dans la [vue d'ensemble](https://docs.didit.me/fr/integration/server-sdks/overview.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.