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

# KYC और AML के लिए Node.js और TypeScript SDK

> Didit का आधिकारिक Node.js और TypeScript SDK: सर्वर APIs के लिए टाइप्ड कॉल, webhook सत्यापन और प्रमाणीकरण टोकन जाँच। त्वरित शुरुआत गाइड।

Node.js और TypeScript के लिए Didit की आधिकारिक लाइब्रेरी। यह Node.js 18 या उसके बाद के संस्करण, Bun, Deno और `fetch` वाले एज रनटाइम पर चलती है, ES module और CommonJS दोनों बिल्ड देती है, और इसकी कोई रनटाइम डिपेंडेंसी नहीं है। सभी SDK में साझा चीज़ों के लिए [सर्वर SDK अवलोकन](https://docs.didit.me/hi/integration/server-sdks/overview.md) देखें।

## इंस्टॉल

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

पैकेज [npm पर `@didit-protocol/sdk-node`](https://www.npmjs.com/package/@didit-protocol/sdk-node) है। इसका सोर्स और चेंजलॉग GitHub पर [didit-protocol/sdk-node](https://github.com/didit-protocol/sdk-node) में हैं।

## क्लाइंट कॉन्फ़िगर करें

Node.js, Bun और Deno पर `new Didit()` एनवायरनमेंट से `DIDIT_API_KEY` पढ़ता है (Deno में `--allow-env` के साथ)। एज रनटाइम में कोई प्रोसेस एनवायरनमेंट नहीं होता, इसलिए वहाँ कुंजी एक विकल्प के रूप में दें: `new Didit({ apiKey: env.DIDIT_API_KEY })`। विकल्प देकर इसे ओवरराइड किया जा सकता है, या संगठन और एप्लिकेशन ID सेट किए जा सकते हैं, जो एप्लिकेशन-स्कोप वाले कॉल (केस, नेटवर्क, नियामक रिपोर्ट) के लिए ज़रूरी हैं। टाइमआउट मिलीसेकंड में है।

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

CommonJS के साथ `const { Didit } = require("@didit-protocol/sdk-node");` का उपयोग करें।

## सत्र बनाएँ

किसी वर्कफ़्लो के लिए एक [सत्यापन सत्र](https://docs.didit.me/hi/sessions-api/create-session.md) बनाएँ और अपने उपयोगकर्ता को उसके URL पर भेजें। अनुरोध के फ़ील्ड 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);
```

## निर्णय पढ़ें

जब उपयोगकर्ता अपना काम पूरा कर ले (या जब webhook आए), तब [निर्णय पढ़ें](https://docs.didit.me/hi/sessions-api/retrieve-session.md)। हर फ़ीचर का परिणाम एक सूची होता है, जिसमें वर्कफ़्लो के हर नोड के लिए एक एंट्री होती है, और दिनांक-समय `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);
}
```

## webhook सत्यापित करें

कच्ची बॉडी (पार्स किया हुआ JSON नहीं) और अनुरोध हेडर पास करें: Node.js या Express का `req.headers` ऑब्जेक्ट, Fetch का `Headers` ऑब्जेक्ट, या `[name, value]` जोड़े (`WebhookHeaders` टाइप)। `verify` एक प्रॉमिस लौटाता है और किसी भी ऐसी डिलीवरी पर `WebhookVerificationError` के साथ reject करता है जो मान्य और ताज़ा न हो।

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

Express के साथ `express.raw({ type: "application/json" })` से body पढ़ें और `handleWebhook(req.body, req.headers)` कॉल करें। सीक्रेट रोटेट करते समय दोनों पास करें: `[newSecret, oldSecret]`। इवेंट और हस्ताक्षर स्कीम के लिए [Webhooks](https://docs.didit.me/hi/integration/webhooks.md) देखें।

## लेन-देन की स्क्रीनिंग करें

भुगतान, निकासी या क्रिप्टो ट्रांसफ़र को [लेन-देन निगरानी](https://docs.didit.me/hi/transaction-monitoring/overview.md) पर सबमिट करें; रिस्पॉन्स में उसकी स्थिति और जोखिम स्कोर होता है।

```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 टोकन सत्यापित करें

`Authentication` आपके बैकएंड में, हर अनुरोध के लिए Didit को कॉल किए बिना, उन एक्सेस टोकन की जाँच करता है जिन्हें आपका [Authentication](https://docs.didit.me/hi/authentication/overview.md) जारीकर्ता साइन करता है। यह कोड का आदान-प्रदान करता है, टोकन रीफ़्रेश करता है, सत्रों की जाँच और उन्हें रद्द करता है, और स्टेप-अप चलाता है।

> [!NOTE]
>
> टोकन सत्यापन [अपने सर्वर पर टोकन सत्यापित करें](https://docs.didit.me/hi/authentication/tokens-and-jwks.md#अपने-सर्वर-पर-टोकन-सत्यापित-करें) में दी गई जाँचें करता है, जो आपके एप्लिकेशन के जारीकर्ता और हस्ताक्षर कुंजियों के विरुद्ध होती हैं।

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

## त्रुटियाँ

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

## सूचियाँ और फ़ाइलें

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

[API संदर्भ](https://docs.didit.me/hi/api-reference/overview.md) के सर्वर endpoint पेज में उनके ऑपरेशन का Node.js नमूना होता है, सिवाय उन endpoints और फ़ील्ड के जो अभी किसी 1.0.1 रिलीज़ में नहीं हैं, जिन्हें [अवलोकन](https://docs.didit.me/hi/integration/server-sdks/overview.md) में नाम दिया गया है।


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