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

# Go-SDK für KYC, AML und Transaktionen

> Schnellstart für das Didit Go-SDK: typisierte API-Aufrufe ohne Drittanbieter-Pakete, Webhook-Prüfung und Token-Validierung.

Das offizielle Didit-Modul für Go. Es setzt Go 1.22 oder höher voraus und nutzt ausschließlich die Standardbibliothek. In der [Übersicht der Server-SDKs](https://docs.didit.me/de/integration/server-sdks/overview.md) erfahren Sie, was alle SDKs gemeinsam haben.

## Installation

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

Das Modul ist [`github.com/didit-protocol/sdk-go` auf pkg.go.dev](https://pkg.go.dev/github.com/didit-protocol/sdk-go). Der Quellcode und das Changelog befinden sich unter [didit-protocol/sdk-go](https://github.com/didit-protocol/sdk-go) auf GitHub.

Das Paket heißt `didit`. Webhooks befinden sich in `github.com/didit-protocol/sdk-go/webhook`, Authentifizierung in `.../authentication` und Client-Optionen in `.../option`.

Das Codebeispiel auf jeder Seite der [API-Referenz](https://docs.didit.me/de/api-reference/overview.md) stellt den Rumpf einer Funktion dar: Es verwendet `context`, `fmt` und `log` aus der Standardbibliothek sowie dieses Modul.

## Client konfigurieren

`didit.NewClient()` liest `DIDIT_API_KEY` aus den Umgebungsvariablen. Übergeben Sie Optionen, um diesen Wert zu überschreiben oder um die Organisations- und Anwendungs-IDs zu setzen, die für Aufrufe auf Anwendungsebene (Fälle, Netzwerke, regulatorische Berichte) erforderlich sind. Jede Option kann auch bei einem einzelnen Aufruf übergeben werden.

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

Optionale Anfragefelder sind `didit.Opt`-Werte: Setzen Sie diese mit `didit.String`, `didit.Int`, `didit.Bool`, `didit.Float` oder `didit.Some`, und lassen Sie sie weg, um nichts zu senden.

## 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 auf deren URL weiter.

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

## Entscheidung abrufen

Sobald der Benutzer fertig ist (oder wenn der Webhook eingeht), [rufen Sie die Entscheidung ab](https://docs.didit.me/de/sessions-api/retrieve-session.md). Das Ergebnis jeder Funktion ist ein Slice mit einem Eintrag pro Workflow-Knoten.

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

## Webhook verifizieren

Übergeben Sie die unveränderten Body-Bytes und die Request-Header. `webhook.Verify` gibt für alles, was keine gültige, frische Zustellung ist, einen `*didit.WebhookVerificationError` zurück, andernfalls ein typisiertes Ereignis.

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

Wenn Sie das Secret rotieren, fügen Sie das alte mit `webhook.WithSecrets` hinzu. 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.

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

## Authentifizierungs-Token verifizieren

Das Paket `authentication` prüft die von Ihrem [Authentication](https://docs.didit.me/de/authentication/overview.md)-Issuer signierten Access-Tokens direkt in Ihrem Backend, ohne für jede Anfrage Didit aufzurufen. Es tauscht zudem Codes um, 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 Issuers und der Signaturschlüssel Ihrer Anwendung durch.

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

## Fehler

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

## Listen und Dateien

```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, die noch nicht im Go-SDK enthalten sind

Go 1.0.1 wurde generiert, bevor diese Endpoints zur API hinzugefügt wurden. Daher enthält es keine Methode für sie und ihre Seiten verfügen über kein Go-Beispiel:

* [Adresse validieren](https://docs.didit.me/de/standalone-apis/address-validation.md)
* [Transaktionen im Batch löschen](https://docs.didit.me/de/management-api/transactions/delete.md)
* Travel Rule-Netzwerke: [Netzwerke abrufen](https://docs.didit.me/de/management-api/travel-rule/get-networks.md), [Zugang zu einem Netzwerk anfordern](https://docs.didit.me/de/management-api/travel-rule/request-network.md) sowie den Netzwerkfragebogen [abrufen](https://docs.didit.me/de/management-api/travel-rule/get-network-questionnaire.md), [speichern](https://docs.didit.me/de/management-api/travel-rule/update-network-questionnaire.md) oder [einreichen](https://docs.didit.me/de/management-api/travel-rule/submit-network-questionnaire.md)
* Travel Rule-Wallet-Nachweise: [Screenshot-Wallet-Nachweise auflisten](https://docs.didit.me/de/management-api/travel-rule/list-wallet-proofs.md) und [einen Nachweis genehmigen oder ablehnen](https://docs.didit.me/de/management-api/travel-rule/decide-wallet-proof.md)
* Google Wallet, das in keinem 1.0.1-Release enthalten ist: [Google-Wallet-Verifizierung starten](https://docs.didit.me/de/api-reference/digital-id-wallets/google-wallet.md) und [Wallet-Antwort übermitteln](https://docs.didit.me/de/standalone-apis/digital-id-wallet-response.md)

Zudem können diese neueren Anfragefelder nicht gesendet werden:

* `biometric_consent`, `tags` und `user_state` beim [Erstellen einer Sitzung](https://docs.didit.me/de/sessions-api/create-session.md)
* `biometric_consent_mode` beim [Aktualisieren der Webhook-Konfiguration](https://docs.didit.me/de/management-api/webhook/update-config.md)
* `beneficiary_vasp` beim [Aktualisieren eines Travel Rule-Transfers](https://docs.didit.me/de/management-api/travel-rule/update-transfer.md)
* `confirm_delete`, was beim [Löschen eines finalisierten Berichts](https://docs.didit.me/de/management-api/regulatory-reports/delete.md) erforderlich ist
* die 16 neueren Felder der Datenbankvalidierung, die in keinem 1.0.1-Release enthalten sind

Bis ein späteres Go-Release diese unterstützt, rufen Sie sie über HTTP auf, wie es im cURL-Beispiel der jeweiligen Seite gezeigt wird. Jede andere Seite eines Server-Endpoints in der [API-Referenz](https://docs.didit.me/de/api-reference/overview.md) enthält ein Go-Beispiel für die entsprechende Operation.


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