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

# Node.js- und TypeScript-SDK für KYC und AML

> Das offizielle Didit Node.js- und TypeScript-SDK bietet typisierte Aufrufe für Server-APIs, Webhook-Prüfung und Auth-Token-Checks.

Die offizielle Didit-Bibliothek für Node.js und TypeScript. Sie läuft auf Node.js 18 oder höher, Bun, Deno sowie Edge-Runtimes mit `fetch`, stellt ES-Modul- und CommonJS-Builds bereit und hat keine Laufzeitabhängigkeiten. In der [Übersicht über die Server-SDKs](https://docs.didit.me/de/integration/server-sdks/overview.md) erfahren Sie, was alle SDKs gemeinsam haben.

## Installieren

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

Das Paket ist [`@didit-protocol/sdk-node` auf npm](https://www.npmjs.com/package/@didit-protocol/sdk-node). Der Quellcode und das Changelog befinden sich unter [didit-protocol/sdk-node](https://github.com/didit-protocol/sdk-node) auf GitHub.

## Client konfigurieren

`new Didit()` liest `DIDIT_API_KEY` unter Node.js, Bun und Deno (mit `--allow-env`) aus der Umgebung aus. Da Edge-Runtimes keine Prozessumgebung besitzen, übergeben Sie den Schlüssel dort als Option: `new Didit({ apiKey: env.DIDIT_API_KEY })`. Übergeben Sie Optionen, um ihn zu überschreiben oder um die Organisations- und Anwendungs-IDs festzulegen, die Aufrufe auf Anwendungsebene (Fälle, Netzwerke, behördliche Berichte) benötigen. Das Timeout wird in Millisekunden angegeben.

```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"));
```

Unter CommonJS verwenden Sie `const { Didit } = require("@didit-protocol/sdk-node");`.

## Sitzung erstellen

Erstellen Sie eine [Verifizierungssitzung](https://docs.didit.me/de/sessions-api/create-session.md) für einen Workflow und leiten Sie Ihren Benutzer zu dessen URL weiter. Anfragefelder behalten die Namen der API bei.

```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);
```

## Entscheidung abrufen

Sobald der Benutzer fertig ist (oder wenn der Webhook eintrifft), [rufen Sie die Entscheidung ab](https://docs.didit.me/de/sessions-api/retrieve-session.md). Jedes Funktionsergebnis ist eine Liste mit einem Eintrag pro Workflow-Knoten, und Datums- und Zeitangaben sind `Date`-Objekte.

```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);
}
```

## Webhook verifizieren

Übergeben Sie den rohen Body (kein geparstes JSON) und die Anfrage-Header: ein Node.js- oder Express-`req.headers`-Objekt, ein Fetch-`Headers`-Objekt oder `[name, value]`-Paare (der Typ `WebhookHeaders`). `verify` gibt ein Promise zurück und schlägt mit `WebhookVerificationError` für alles fehl, was keine gültige, aktuelle Zustellung ist.

```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;
  }
}
```

Lesen Sie den Body unter Express mit `express.raw({ type: "application/json" })` aus und rufen Sie `handleWebhook(req.body, req.headers)` auf. Wenn Sie das Secret rotieren, übergeben Sie beide: `[newSecret, oldSecret]`. Unter [Webhooks](https://docs.didit.me/de/integration/webhooks.md) finden Sie die Ereignisse und das Signaturschema.

## Transaktion prüfen

Übermitteln Sie eine Zahlung, eine Auszahlung oder einen Krypto-Transfer an die [Transaktionsüberwachung](https://docs.didit.me/de/transaction-monitoring/overview.md); die Antwort enthält den Status und den Risiko-Score.

```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);
```

## Authentication-Tokens verifizieren

`Authentication` prüft die Zugriffstoken, die Ihr [Authentication](https://docs.didit.me/de/authentication/overview.md)-Aussteller signiert, in Ihrem Backend, ohne Didit bei jeder Anfrage aufzurufen. Es tauscht außerdem Codes aus, aktualisiert Tokens, prüft und widerruft Sitzungen und führt Step-up-Authentifizierungen durch.

> [!NOTE]
>
> Die Token-Prüfung führt die unter [Token auf Ihrem Server verifizieren](https://docs.didit.me/de/authentication/tokens-and-jwks.md#token-auf-ihrem-server-prüfen) beschriebenen Prüfungen anhand des Ausstellers und der Signaturschlüssel Ihrer Anwendung durch.

```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;
  }
}
```

## Fehler

```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;
}
```

## Listen und Dateien

```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);
```

Die Server-Endpoint-Seiten der [API-Referenz](https://docs.didit.me/de/api-reference/overview.md) enthalten ein Node.js-Beispiel für ihre jeweilige Operation, mit Ausnahme der in der [Übersicht](https://docs.didit.me/de/integration/server-sdks/overview.md) genannten Endpoints und Felder, die in keinem 1.0.1-Release enthalten sind.


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