> ## 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 de Go para KYC, AML y transacciones

> SDK oficial de Didit para Go: llamadas tipadas a las APIs de servidor solo con la biblioteca estándar, verificación de webhooks y tokens.

El módulo oficial de Didit para Go. Requiere Go 1.22 o posterior y usa solo la biblioteca estándar. Consulta la [visión general de los SDK de servidor](https://docs.didit.me/es/integration/server-sdks/overview.md) para ver lo que comparten todos los SDK.

## Instalación

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

El módulo es [`github.com/didit-protocol/sdk-go` en pkg.go.dev](https://pkg.go.dev/github.com/didit-protocol/sdk-go). Su código fuente y su registro de cambios están en [didit-protocol/sdk-go](https://github.com/didit-protocol/sdk-go) en GitHub.

El paquete se llama `didit`. Los webhooks están en `github.com/didit-protocol/sdk-go/webhook`, la autenticación está en `.../authentication` y las opciones del cliente en `.../option`.

El ejemplo de cada página de la [referencia de la API](https://docs.didit.me/es/api-reference/overview.md) es el cuerpo de una función: usa `context`, `fmt` y `log` de la biblioteca estándar y este módulo.

## Configurar el cliente

`didit.NewClient()` lee `DIDIT_API_KEY` del entorno. Pasa opciones para sobrescribirla o para establecer los ids de la organización y de la aplicación que requieren las llamadas específicas de la aplicación (casos, redes, informes regulatorios). Cualquier opción también funciona en una sola llamada.

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

Los campos opcionales de la solicitud son valores `didit.Opt`: establécelos con `didit.String`, `didit.Int`, `didit.Bool`, `didit.Float` o `didit.Some`, y omítelos para no enviar nada.

## Crear una sesión

Crea una [sesión de verificación](https://docs.didit.me/es/sessions-api/create-session.md) para un workflow y envía a tu usuario a su 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)
}
```

## Leer la decisión

Cuando el usuario haya terminado (o cuando llegue el webhook), [lee la decisión](https://docs.didit.me/es/sessions-api/retrieve-session.md). Cada resultado de función es un slice con una entrada por cada nodo del flujo.

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

## Verificar un webhook

Pasa los bytes del cuerpo sin procesar y los encabezados de la solicitud. `webhook.Verify` devuelve un `*didit.WebhookVerificationError` para todo lo que no sea una entrega válida y reciente, y un evento tipado en caso contrario.

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

Mientras rotas el secreto, añade el anterior con `webhook.WithSecrets`. Consulta [Webhooks](https://docs.didit.me/es/integration/webhooks.md) para conocer los eventos y el esquema de firma.

## Analizar una transacción

Envía un pago, una retirada o una transferencia de criptomonedas a [monitorización de transacciones](https://docs.didit.me/es/transaction-monitoring/overview.md); la respuesta incluye su estado y su puntuación de riesgo.

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

## Verificar tokens de Authentication

El paquete `authentication` comprueba los tokens de acceso que firma tu emisor de [Authentication](https://docs.didit.me/es/authentication/overview.md), en tu backend, sin consultar a Didit en cada solicitud. También intercambia códigos, renueva tokens, comprueba y revoca sesiones, y ejecuta verificaciones adicionales (step-ups).

> [!NOTE]
>
> La verificación de tokens realiza las comprobaciones de [Verificar un token en tu servidor](https://docs.didit.me/es/authentication/tokens-and-jwks.md#verificar-un-token-en-tu-servidor), con el emisor y las claves de firma de tu aplicación.

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

## Errores

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

## Listas y archivos

```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 que aún no están en el SDK de Go

Go 1.0.1 se generó antes de que estos endpoints se añadieran a la API, así que no tiene ningún método para ellos y sus páginas no tienen ejemplo en Go:

* [Validar una dirección](https://docs.didit.me/es/standalone-apis/address-validation.md)
* [Eliminar transacciones en lote](https://docs.didit.me/es/management-api/transactions/delete.md)
* Redes de Travel Rule: [obtener las redes](https://docs.didit.me/es/management-api/travel-rule/get-networks.md), [solicitar acceso a una red](https://docs.didit.me/es/management-api/travel-rule/request-network.md), y [obtener](https://docs.didit.me/es/management-api/travel-rule/get-network-questionnaire.md), [guardar](https://docs.didit.me/es/management-api/travel-rule/update-network-questionnaire.md) o [enviar](https://docs.didit.me/es/management-api/travel-rule/submit-network-questionnaire.md) el cuestionario de la red
* Pruebas de wallet de Travel Rule: [listar las pruebas de wallet por captura de pantalla](https://docs.didit.me/es/management-api/travel-rule/list-wallet-proofs.md) y [aprobar o rechazar una](https://docs.didit.me/es/management-api/travel-rule/decide-wallet-proof.md)
* Google Wallet, que todavía no está disponible en ninguna versión 1.0.1: [iniciar una verificación de Google Wallet](https://docs.didit.me/es/api-reference/digital-id-wallets/google-wallet.md) y [enviar una respuesta de wallet](https://docs.didit.me/es/standalone-apis/digital-id-wallet-response.md)

Tampoco puede enviar estos campos de solicitud más recientes:

* `biometric_consent`, `tags` y `user_state` cuando [crea una sesión](https://docs.didit.me/es/sessions-api/create-session.md)
* `biometric_consent_mode` cuando [actualiza la configuración de webhooks](https://docs.didit.me/es/management-api/webhook/update-config.md)
* `beneficiary_vasp` cuando [actualiza una transferencia de Travel Rule](https://docs.didit.me/es/management-api/travel-rule/update-transfer.md)
* `confirm_delete`, que se necesita para [eliminar un informe finalizado](https://docs.didit.me/es/management-api/regulatory-reports/delete.md)
* los 16 campos más recientes de Validación de base de datos que no tiene ninguna versión 1.0.1

Hasta que una versión posterior de Go los añada, invócalos mediante HTTP como muestra la solicitud cURL de cada página. Todas las demás páginas de endpoints de servidor de la [referencia de la API](https://docs.didit.me/es/api-reference/overview.md) tienen un ejemplo en Go para su operación.


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