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

> SDK Go officiel de Didit : appels typés vers les API serveur (bibliothèque standard uniquement), vérification des webhooks et des tokens.

Le module officiel Didit pour Go. Il nécessite Go 1.22 ou une version ultérieure et n'utilise que la bibliothèque standard. 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.

## Installation

```bash theme={null}
go get github.com/didit-protocol/sdk-go
```

Le module est [`github.com/didit-protocol/sdk-go` sur pkg.go.dev](https://pkg.go.dev/github.com/didit-protocol/sdk-go). Ses sources et son journal des modifications se trouvent dans [didit-protocol/sdk-go](https://github.com/didit-protocol/sdk-go) sur GitHub.

Le package s'appelle `didit`. Les webhooks se trouvent dans `github.com/didit-protocol/sdk-go/webhook`, l'Authentication dans `.../authentication` et les options du client dans `.../option`.

L'exemple de chaque page de [référence de l'API](https://docs.didit.me/fr/api-reference/overview.md) est le corps d'une fonction : il utilise `context`, `fmt` et `log` de la bibliothèque standard, ainsi que ce module.

## Configurer le client

`didit.NewClient()` 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 les appels à portée application (dossiers, réseaux, rapports réglementaires) ont besoin. Toute option fonctionne aussi sur un seul appel.

```go theme={null}
package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/didit-protocol/sdk-go"
	"github.com/didit-protocol/sdk-go/option"
)

func main() {
	client := didit.NewClient(
		option.WithAPIKey(os.Getenv("DIDIT_API_KEY")),
		option.WithOrganizationID(os.Getenv("DIDIT_ORGANIZATION_ID")),
		option.WithApplicationID(os.Getenv("DIDIT_APPLICATION_ID")),
		option.WithTimeout(30*time.Second),
		option.WithMaxRetries(2),
	)

	// Options for a single call.
	decision, err := client.Sessions.RetrieveDecision(context.Background(), "11111111-2222-3333-4444-555555555555",
		didit.SessionsRetrieveDecisionParams{}, option.WithTimeout(5*time.Second))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(decision.Status)
}
```

Les champs de requête facultatifs sont des valeurs `didit.Opt` : définissez-les avec `didit.String`, `didit.Int`, `didit.Bool`, `didit.Float` ou `didit.Some`, et omettez-les pour ne rien envoyer.

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

```go theme={null}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	session, err := client.Sessions.Create(context.Background(), didit.SessionsCreateParams{
		WorkflowID: "11111111-2222-3333-4444-555555555555",
		VendorData: didit.String("user-123"),
		Callback:   didit.String("https://example.com/verification/done"),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(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 tranche comportant une entrée par nœud du workflow.

```go theme={null}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	decision, err := client.Sessions.RetrieveDecision(context.Background(), "11111111-2222-3333-4444-555555555555",
		didit.SessionsRetrieveDecisionParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(decision.Status)
	for _, verification := range decision.IDVerifications {
		fmt.Println(verification.Status)
	}
}
```

## Vérifier un webhook

Transmettez les octets bruts du corps et les en-têtes de la requête. `webhook.Verify` renvoie un `*didit.WebhookVerificationError` pour toute livraison qui n'est pas à la fois valide et récente, et un événement typé sinon.

```go theme={null}
package main

import (
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	"github.com/didit-protocol/sdk-go"
	"github.com/didit-protocol/sdk-go/webhook"
)

func main() {
	secret := os.Getenv("DIDIT_WEBHOOK_SECRET")
	http.HandleFunc("POST /webhooks/didit", func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1<<20))
		if err != nil {
			http.Error(w, "bad body", http.StatusBadRequest)
			return
		}
		event, err := webhook.Verify(body, r.Header, secret)
		var invalid *didit.WebhookVerificationError
		if errors.As(err, &invalid) {
			http.Error(w, string(invalid.Reason), http.StatusBadRequest)
			return
		} else if err != nil {
			http.Error(w, "error", http.StatusInternalServerError)
			return
		}
		if e, ok := event.(*webhook.StatusUpdatedEvent); ok {
			fmt.Println(e.SessionID, e.Status)
		}
		w.WriteHeader(http.StatusOK)
	})
	log.Fatal(http.ListenAndServe(":8080", nil))
}
```

Pendant la rotation du secret, ajoutez l'ancien avec `webhook.WithSecrets`. 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.

```go theme={null}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	transaction, err := client.Transactions.Create(context.Background(), didit.TransactionsCreateParams{
		TransactionID:       "txn-1001",
		TransactionCategory: "finance",
		TransactionDetails: didit.TransactionsCreateParamsTransactionDetails{
			Direction: "outbound",
			Amount:    1500,
			Currency:  "EUR",
		},
		Subject: didit.TransactionsCreateParamsSubject{
			EntityType: didit.String("individual"),
			VendorData: "user-123",
			FullName:   "Maria Garcia",
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(transaction.Status, transaction.Score)
}
```

## Vérifier les tokens Authentication

Le package `authentication` vérifie, dans votre backend et sans appeler Didit pour chaque requête, les tokens d'accès que votre émetteur [Authentication](https://docs.didit.me/fr/authentication/overview.md) signe. Il permet aussi d'échanger des codes, de rafraîchir des tokens, de vérifier et révoquer des sessions, et d'exécuter des authentifications renforcées.

> [!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.

```go theme={null}
package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
	"github.com/didit-protocol/sdk-go/authentication"
)

func main() {
	// The publishable key (pk_live_... or pk_test_...) carries your issuer URL.
	auth, err := authentication.NewFromPublishableKey("pk_live_...", authentication.WithClientID("your-application-id"))
	if err != nil {
		log.Fatal(err)
	}

	claims, err := auth.VerifyAccessToken(context.Background(), "the bearer token")
	var invalid *didit.TokenVerificationError
	if errors.As(err, &invalid) {
		fmt.Println("rejected:", invalid.Reason)
		return
	} else if err != nil {
		log.Fatal(err)
	}
	fmt.Println(claims.Subject)
}
```

## Erreurs

```go theme={null}
package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	_, err := client.Sessions.RetrieveDecision(context.Background(), "11111111-2222-3333-4444-555555555555",
		didit.SessionsRetrieveDecisionParams{})
	var notFound *didit.NotFoundError
	var status *didit.APIStatusError
	switch {
	case errors.As(err, &notFound):
		fmt.Println("no such session")
	case errors.As(err, &status):
		fmt.Println(status.StatusCode, status.RequestID, status.Body)
	case err != nil:
		fmt.Println("no response:", err)
	}
}
```

## Listes et fichiers

```go theme={null}
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	ctx := context.Background()
	client := didit.NewClient()

	// Lists page through every result.
	iter := client.Sessions.ListAutoPaging(ctx, didit.SessionsListParams{Status: didit.String("Approved")})
	for iter.Next() {
		fmt.Println(iter.Current().SessionID)
	}
	if err := iter.Err(); err != nil {
		log.Fatal(err)
	}

	// Uploads take didit.FileFromPath, FileFromBytes or FileFromReader.
	result, err := client.IDVerification.Verify(ctx, didit.IDVerificationVerifyParams{
		FrontImage: didit.FileFromPath("id-front.jpg"),
		BackImage:  didit.Some(didit.FileFromPath("id-back.jpg")),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(result.IDVerification.Status)
}
```

## Endpoints absents du SDK Go pour l'instant

Go 1.0.1 a été généré avant l'ajout de ces endpoints à l'API. Il n'a donc pas de méthode pour eux, et leurs pages ne contiennent pas d'exemple Go :

* [Valider une adresse](https://docs.didit.me/fr/standalone-apis/address-validation.md)
* [Supprimer des transactions en lot](https://docs.didit.me/fr/management-api/transactions/delete.md)
* Réseaux Travel Rule : [obtenir les réseaux](https://docs.didit.me/fr/management-api/travel-rule/get-networks.md), [demander l'accès à un réseau](https://docs.didit.me/fr/management-api/travel-rule/request-network.md), et [obtenir](https://docs.didit.me/fr/management-api/travel-rule/get-network-questionnaire.md), [enregistrer](https://docs.didit.me/fr/management-api/travel-rule/update-network-questionnaire.md) ou [soumettre](https://docs.didit.me/fr/management-api/travel-rule/submit-network-questionnaire.md) le questionnaire du réseau
* Preuves de portefeuille Travel Rule : [lister les preuves de portefeuille par capture d'écran](https://docs.didit.me/fr/management-api/travel-rule/list-wallet-proofs.md) et [approuver ou rejeter une preuve](https://docs.didit.me/fr/management-api/travel-rule/decide-wallet-proof.md)
* Google Wallet, qu'aucune version 1.0.1 ne contient encore : [démarrer une vérification Google Wallet](https://docs.didit.me/fr/api-reference/digital-id-wallets/google-wallet.md) et [soumettre une réponse de portefeuille](https://docs.didit.me/fr/standalone-apis/digital-id-wallet-response.md)

Il ne peut pas non plus envoyer ces champs de requête plus récents :

* `biometric_consent`, `tags` et `user_state` lors de la [création d'une session](https://docs.didit.me/fr/sessions-api/create-session.md)
* `biometric_consent_mode` lors de la [mise à jour de la configuration des webhooks](https://docs.didit.me/fr/management-api/webhook/update-config.md)
* `beneficiary_vasp` lors de la [mise à jour d'un transfert Travel Rule](https://docs.didit.me/fr/management-api/travel-rule/update-transfer.md)
* `confirm_delete`, requis pour [supprimer un rapport finalisé](https://docs.didit.me/fr/management-api/regulatory-reports/delete.md)
* les 16 champs plus récents de Validation en base de données qu'aucune version 1.0.1 ne contient

Jusqu'à ce qu'une version ultérieure du SDK Go les ajoute, appelez-les en HTTP comme le montre la requête cURL de chaque page. Toutes les autres pages d'endpoints serveur de la [référence de l'API](https://docs.didit.me/fr/api-reference/overview.md) disposent d'un exemple Go pour leur opération.


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