> ## 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 Python Didit pour KYC, AML et transactions

> Démarrage avec le SDK Python officiel de Didit : clients sync et async typés, vérification des webhooks et des jetons d'authentification.

La bibliothèque Python officielle de Didit. Elle nécessite Python 3.10 ou une version ultérieure et propose un client synchrone, `Didit`, et un client asynchrone, `AsyncDidit`, dotés des mêmes méthodes. Consultez la [vue d'ensemble des SDK serveur](https://docs.didit.me/fr/integration/server-sdks/overview.md) pour savoir ce que tous les SDK ont en commun.

## Installation

```bash theme={null}
pip install didit-sdk
```

Le package est [`didit-sdk` sur PyPI](https://pypi.org/project/didit-sdk/). Ses sources et son journal des modifications se trouvent dans [didit-protocol/sdk-python](https://github.com/didit-protocol/sdk-python) sur GitHub.

Pour vérifier les tokens [Authentication](#vérifier-les-tokens-d’authentication), installez l'extra qui ajoute la vérification de signature :

```bash theme={null}
pip install "didit-sdk[auth]"
```

## Configurer le client

`Didit()` lit `DIDIT_API_KEY` depuis l'environnement. Passez des options pour le remplacer, ou pour définir les identifiants d'organisation et d'application dont ont besoin les appels à portée applicative (dossiers, réseaux, rapports réglementaires).

```python theme={null}
import os

from didit import Didit

client = Didit(
    api_key=os.environ["DIDIT_API_KEY"],
    organization_id=os.environ.get("DIDIT_ORGANIZATION_ID"),
    application_id=os.environ.get("DIDIT_APPLICATION_ID"),
    timeout=30,
    max_retries=2,
)

# Options for a single call.
fast = client.with_options(timeout=5, max_retries=0)
```

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

```python theme={null}
from didit import Didit

client = Didit()

session = client.sessions.create(
    workflow_id="11111111-2222-3333-4444-555555555555",
    vendor_data="user-123",
    callback="https://example.com/verification/done",
)
print(session.url)
```

## Lire la décision

Lorsque l'utilisateur a terminé (ou lorsque le webhook arrive), [lisez la décision](https://docs.didit.me/fr/sessions-api/retrieve-session.md). Chaque résultat de fonctionnalité est une liste comportant une entrée par nœud du workflow.

```python theme={null}
from didit import Didit

client = Didit()

decision = client.sessions.retrieve_decision("11111111-2222-3333-4444-555555555555")
print(decision.status)
for verification in decision.id_verifications or []:
    print(verification.first_name, verification.last_name)
```

## Vérifier un webhook

Transmettez les octets bruts exacts du corps de la requête ainsi que les en-têtes de la requête. `verify` lève `WebhookVerificationError` pour toute livraison qui n'est pas à la fois valide et récente. Il suffit donc d'intercepter cette seule classe.

```python theme={null}
import os

import didit

WEBHOOK_SECRET = os.environ["DIDIT_WEBHOOK_SECRET"]


def handle_webhook(raw_body: bytes, headers: didit.webhooks.HeadersLike) -> int:
    try:
        event = didit.webhooks.verify(raw_body, headers, WEBHOOK_SECRET)
    except didit.WebhookVerificationError as error:
        print("rejected:", error.reason)
        return 400
    if isinstance(event, didit.webhooks.SessionStatusUpdatedEvent):
        print(event.session_id, event.status)
    return 200
```

Avec Flask, cela donne `handle_webhook(request.get_data(), dict(request.headers))` ; avec FastAPI, `handle_webhook(await request.body(), request.headers)`. Pendant la rotation du secret, transmettez les deux : `[new_secret, old_secret]`. Consultez [Webhooks](https://docs.didit.me/fr/integration/webhooks.md) pour les événements et le schéma de signature.

## Filtrer une transaction

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

```python theme={null}
from didit import Didit

client = Didit()

transaction = client.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"},
)
print(transaction.status, transaction.score)
```

## Vérifier les tokens d'Authentication

`didit.authentication` vérifie les tokens d'accès signés par votre émetteur [Authentication](https://docs.didit.me/fr/authentication/overview.md), côté backend, sans appeler Didit pour chaque requête. Il permet aussi d'échanger des codes, de rafraîchir des tokens, de vérifier et de révoquer des sessions, et d'effectuer des élévations du niveau d'authentification (step-up).

> [!NOTE]
>
> La vérification des tokens 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), avec l'émetteur et les clés de signature de votre application.

```python theme={null}
from didit.authentication import Authentication, TokenVerificationError

# The publishable key (pk_live_... or pk_test_...) carries your issuer URL.
auth = Authentication.from_publishable_key("pk_live_...", client_id="your-application-id")


def current_user(access_token: str) -> str | None:
    try:
        claims = auth.verify_access_token(access_token)
    except TokenVerificationError as error:
        print("rejected:", error.reason)
        return None
    return claims.sub
```

## Erreurs

```python theme={null}
import didit
from didit import Didit

client = Didit()

try:
    client.sessions.retrieve_decision("11111111-2222-3333-4444-555555555555")
except didit.NotFoundError:
    print("no such session")
except didit.RateLimitError as error:
    print("slow down, request", error.request_id)
except didit.APIStatusError as error:
    print(error.status_code, error.body)
```

## Listes, fichiers et opérations asynchrones

```python theme={null}
import asyncio
from pathlib import Path

from didit import AsyncDidit, Didit

client = Didit()

# Lists page through every result.
for session in client.sessions.list(status="Approved"):
    print(session.session_id)

# Uploads take a path, bytes or an open file.
result = client.id_verification.verify(front_image=Path("id-front.jpg"), back_image=Path("id-back.jpg"))
print(result.id_verification)


async def main() -> None:
    async with AsyncDidit() as aclient:
        session = await aclient.sessions.create(workflow_id="11111111-2222-3333-4444-555555555555")
        print(session.url)


asyncio.run(main())
```

Les pages d'endpoints serveur de la [référence API](https://docs.didit.me/fr/api-reference/overview.md) comportent un exemple Python pour leur opération, sauf pour les endpoints et les champs qu'aucune version 1.0.1 ne contient 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.