> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dfns.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Go SDK

> Server-side SDK for integrating Dfns into Go backends

The Go SDK is designed for **server-side/backend** applications. It handles request signing and provides typed access to the Dfns API.

You can find the repository [here](https://github.com/dfns/dfns-sdk-go).

## Installation

```bash theme={null}
go get github.com/dfns/dfns-sdk-go/v2
```

## Quick start

### 1. Read-only operations

For read-only operations (listing wallets, fetching balances, etc.), you only need an auth token:

```go theme={null}
package main

import (
    "context"
    "fmt"
    "log"

    dfns "github.com/dfns/dfns-sdk-go/v2"
)

func main() {
    client, err := dfns.NewClient(dfns.Options{
        AuthToken: "your-auth-token",
    })
    if err != nil {
        log.Fatal(err)
    }

    wallets, err := client.Wallets.ListWallets(context.Background(), nil)
    if err != nil {
        log.Fatal(err)
    }
    for _, w := range wallets.Items {
        address := ""
        if w.Address != nil {
            address = *w.Address
        }
        fmt.Printf("%s: %s %s\n", w.ID, w.Network, address)
    }
}
```

<Tip>
  For a quick test you can get your login token (short-lived) from the [Dfns Dashboard](https://app.dfns.io/) under `Settings` > `Personal Access Tokens`.
</Tip>

### 2. Signing requests

State-changing operations (creating wallets, signing transactions, etc.) require cryptographic request signing:

```go theme={null}
package main

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

    dfns "github.com/dfns/dfns-sdk-go/v2"
    "github.com/dfns/dfns-sdk-go/v2/signer"
    "github.com/dfns/dfns-sdk-go/v2/wallets"
)

func main() {
    privateKeyPEM, err := os.ReadFile("private_key.pem")
    if err != nil {
        log.Fatal(err)
    }

    keySigner, err := signer.NewKeySigner(
        "cr-...",                  // credential ID
        string(privateKeyPEM),     // PEM-encoded private key
    )
    if err != nil {
        log.Fatal(err)
    }

    client, err := dfns.NewClient(dfns.Options{
        AuthToken: "your-auth-token",
        Signer:    keySigner,
    })
    if err != nil {
        log.Fatal(err)
    }

    wallet, err := client.Wallets.CreateWallet(context.Background(), wallets.CreateWalletRequest{
        Network: "EthereumSepolia",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Created wallet: %s\n", wallet.ID)
}
```

## Next steps

* **[Create a service account](/guides/developers/service-account)** for server-to-server authentication with long-lived tokens
* **[Development guide](/sdks/backend/go/development)** for detailed request signing architecture