> ## 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 C# et .NET pour le KYC, l'AML et les transactions

> Intégrez Didit avec le SDK C# et .NET officiel : appels typés asynchrones, injection de dépendances, webhooks et vérification de tokens.

La bibliothèque officielle Didit pour C# et .NET. Elle cible .NET 8 et .NET Standard 2.0, et chaque méthode d'API est `async`. Sur .NET Framework, utilisez C# 11 ou une version ultérieure. Consultez la [vue d'ensemble des SDK serveur](https://docs.didit.me/fr/integration/server-sdks/overview.md) pour découvrir ce que tous les SDK partagent.

## Installation

```bash theme={null}
dotnet add package Didit
```

Pour l'injection de dépendances ASP.NET Core, ajoutez également `Didit.Extensions.DependencyInjection` et enregistrez le client avec `services.AddDidit()`.

Les packages sont [`Didit`](https://www.nuget.org/packages/Didit) et [`Didit.Extensions.DependencyInjection`](https://www.nuget.org/packages/Didit.Extensions.DependencyInjection) sur NuGet. Leur code source et leur journal des modifications sont disponibles dans [didit-protocol/sdk-dotnet](https://github.com/didit-protocol/sdk-dotnet) sur GitHub.

## Configurer le client

`new DiditClient()` lit `DIDIT_API_KEY` à partir de l'environnement. Transmettez `DiditClientOptions` pour le remplacer, ou pour définir les identifiants d'organisation et d'application requis par les appels à portée application (dossiers, réseaux, rapports réglementaires). Créez un seul client et réutilisez-le.

```csharp theme={null}
using System;
using Didit;

using var client = new DiditClient(new DiditClientOptions
{
    ApiKey = Environment.GetEnvironmentVariable("DIDIT_API_KEY"),
    OrganizationId = Environment.GetEnvironmentVariable("DIDIT_ORGANIZATION_ID"),
    ApplicationId = Environment.GetEnvironmentVariable("DIDIT_APPLICATION_ID"),
    Timeout = TimeSpan.FromSeconds(30),
    MaxRetries = 2,
});

// Options for a single call.
var decision = await client.Sessions.RetrieveDecisionAsync(
    "11111111-2222-3333-4444-555555555555",
    requestOptions: new RequestOptions { Timeout = TimeSpan.FromSeconds(5), MaxRetries = 0 });
Console.WriteLine(decision.Status);
```

Les propriétés de requête obligatoires sont marquées comme `required`, de sorte qu'une propriété manquante empêche la compilation. Les propriétés facultatives que vous laissez non définies ne sont pas envoyées.

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

```csharp theme={null}
using System;
using Didit;

using var client = new DiditClient();

var session = await client.Sessions.CreateAsync(new SessionsCreateParams
{
    WorkflowId = "11111111-2222-3333-4444-555555555555",
    VendorData = "user-123",
    Callback = "https://example.com/verification/done",
});
Console.WriteLine(session.Url);
```

## Lire la décision

Lorsque l'utilisateur a terminé (ou à la réception 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 du workflow.

```csharp theme={null}
using System;
using Didit;

using var client = new DiditClient();

var decision = await client.Sessions.RetrieveDecisionAsync("11111111-2222-3333-4444-555555555555");
Console.WriteLine(decision.Status);
foreach (var verification in decision.IdVerifications ?? Array.Empty<SessionDecisionIdVerifications>())
{
    Console.WriteLine(verification.Status);
}
```

## Vérifier un webhook

Transmettez le corps brut, exactement tel qu'il a été reçu, ainsi qu'un moyen de lire les en-têtes de la requête. `DiditWebhooks.Verify` lève une exception `WebhookVerificationException` pour tout ce qui n'est pas une livraison valide et récente, et renvoie sinon un événement typé.

```csharp theme={null}
using System;
using Didit;

var secret = Environment.GetEnvironmentVariable("DIDIT_WEBHOOK_SECRET") ?? "";

int HandleWebhook(string rawBody, Func<string, string?> header)
{
    try
    {
        var evt = DiditWebhooks.Verify(rawBody, header, secret);
        if (evt is SessionStatusUpdatedEvent updated)
        {
            Console.WriteLine($"{updated.SessionId} {updated.Status}");
        }
        return 200;
    }
    catch (WebhookVerificationException error)
    {
        Console.WriteLine($"rejected: {error.Reason}");
        return 400;
    }
}
```

Dans une API minimale ASP.NET Core, lisez le corps avec un `StreamReader` et transmettez `name => request.Headers[name].FirstOrDefault()`. Pendant la rotation du secret, transmettez les deux : `new[] { newSecret, oldSecret }`. Consultez [Webhooks](https://docs.didit.me/fr/integration/webhooks.md) pour connaître les événements et le mécanisme de signature.

## Effectuer le filtrage d'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.

```csharp theme={null}
using System;
using Didit;

using var client = new DiditClient();

var transaction = await client.Transactions.CreateAsync(new TransactionsCreateParams
{
    TransactionId = "txn-1001",
    TransactionCategory = "finance",
    TransactionDetails = new()
    {
        Direction = "outbound",
        Amount = 1500,
        Currency = "EUR",
    },
    Subject = new()
    {
        EntityType = "individual",
        VendorData = "user-123",
        FullName = "Maria Garcia",
    },
});
Console.WriteLine($"{transaction.Status} {transaction.Score}");
```

## Vérifier les tokens Authentication

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

> [!NOTE]
>
> La vérification de token effectue 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.

```csharp theme={null}
using System;
using System.Threading.Tasks;
using Didit;

// The publishable key (pk_live_... or pk_test_...) carries your issuer URL.
var auth = Authentication.FromPublishableKey("pk_live_...");

async Task<string?> CurrentUserAsync(string accessToken)
{
    try
    {
        var claims = await auth.VerifyAccessTokenAsync(accessToken, audience: "your-application-id");
        return claims.Subject;
    }
    catch (TokenVerificationException error)
    {
        Console.WriteLine($"rejected: {error.Reason}");
        return null;
    }
}
```

## Erreurs

```csharp theme={null}
using System;
using Didit;

using var client = new DiditClient();

try
{
    await client.Sessions.RetrieveDecisionAsync("11111111-2222-3333-4444-555555555555");
}
catch (NotFoundException)
{
    Console.WriteLine("no such session");
}
catch (ApiStatusException error)
{
    Console.WriteLine($"{error.StatusCode} {error.RequestId}");
}
```

## Listes et fichiers

```csharp theme={null}
using System;
using Didit;

using var client = new DiditClient();

// Lists page through every result.
await foreach (var session in await client.Sessions.ListAsync(new SessionsListParams { Status = "Approved" }))
{
    Console.WriteLine(session.SessionId);
}

// Uploads take FileUpload.FromPath, FromBytes or FromStream.
var result = await client.IdVerification.VerifyAsync(new IdVerificationVerifyParams
{
    FrontImage = FileUpload.FromPath("id-front.jpg"),
    BackImage = FileUpload.FromPath("id-back.jpg"),
});
Console.WriteLine(result.IdVerification?.Status);
```

Les pages des endpoints serveur de la [référence d'API](https://docs.didit.me/fr/api-reference/overview.md) comportent un exemple .NET pour leur opération, à l'exception des endpoints et des champs qu'aucune version 1.0.1 n'intègre encore, listé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.