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

# Go

> Use ARouter with the official Go SDK.

## Installation

```bash theme={null}
go get github.com/arouter-ai/arouter-go
```

## Quick Start

```go theme={null}
package main

import (
    "context"
    "fmt"
    "log"

    arouter "github.com/arouter-ai/arouter-go"
)

func main() {
    client := arouter.NewClient(
        "https://api.arouter.ai",
        "lr_live_xxxx",
    )

    resp, err := client.ChatCompletion(context.Background(), arouter.ChatCompletionRequest{
        Model: "openai/gpt-5.4",
        Messages: []arouter.Message{
            {Role: "user", Content: "Hello!"},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}
```

## Multi-Provider

```go theme={null}
// Anthropic via ARouter
resp, _ := client.ChatCompletion(ctx, arouter.ChatCompletionRequest{
    Model: "anthropic/claude-sonnet-4.6",
    Messages: []arouter.Message{
        {Role: "user", Content: "Hello!"},
    },
})

// DeepSeek via ARouter
resp, _ = client.ChatCompletion(ctx, arouter.ChatCompletionRequest{
    Model: "deepseek/deepseek-v3.2",
    Messages: []arouter.Message{
        {Role: "user", Content: "Hello!"},
    },
})
```

## Streaming

```go theme={null}
stream, err := client.ChatCompletionStream(context.Background(), arouter.ChatCompletionRequest{
    Model: "openai/gpt-5.4",
    Messages: []arouter.Message{
        {Role: "user", Content: "Write a haiku about Go."},
    },
})
if err != nil {
    log.Fatal(err)
}
defer stream.Close()

for {
    chunk, err := stream.Recv()
    if err == arouter.ErrStreamDone {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
    fmt.Print(chunk.Choices[0].Delta.Content)
}
```

## Key Management

Use a management key (`lr_mgmt_`) to create and manage API keys programmatically.

### Create API Key

```go theme={null}
mgmtClient := arouter.NewClient("https://api.arouter.ai", "lr_mgmt_xxxx")

key, err := mgmtClient.CreateKey(ctx, &arouter.CreateKeyRequest{
    Name:             "production-backend",
    AllowedProviders: []string{"openai", "anthropic"},
    AllowedModels:    []string{"gpt-5.4", "claude-sonnet-4.6"},
    Limit:            float64Ptr(150),
    LimitReset:       "monthly",
})
if err != nil {
    log.Fatal(err)
}
fmt.Println("API Key:", key.Key)
```

### List API Keys

```go theme={null}
keys, err := mgmtClient.ListKeys(ctx, &arouter.ListKeysOptions{
    PageSize: 20,
})
if err != nil {
    log.Fatal(err)
}
for _, k := range keys.Data {
    fmt.Printf("- %s (%s) disabled=%t\n", k.Name, k.Hash, k.Disabled)
}
```

### Update API Key

```go theme={null}
_, err := mgmtClient.UpdateKey(ctx, "KEY_HASH", &arouter.UpdateKeyRequest{
    Disabled: boolPtr(true),
})
```

### Delete API Key

```go theme={null}
err := mgmtClient.DeleteKey(ctx, "KEY_HASH")
```

## Provider Proxy

For direct upstream access without model-field routing:

```go theme={null}
resp, err := client.ProxyRequest(ctx, "openai", "v1/chat/completions", map[string]any{
    "model":    "gpt-5.4",
    "messages": []map[string]string{{"role": "user", "content": "Hello!"}},
})
```

## Client Options

```go theme={null}
client := arouter.NewClient(
    "https://api.arouter.ai",
    "lr_live_xxxx",
    arouter.WithTimeout(30 * time.Second),
    arouter.WithHTTPClient(customHTTPClient),
)
```

## Wallet JWT + x402 Payments

AI agents with crypto wallets can authenticate via SIWx and pay for credits via x402.
The SDK caches a wallet JWT and uses it as the Bearer token for subsequent requests.

### EVM (Base)

```go theme={null}
import (
    "github.com/ethereum/go-ethereum/crypto"
    arouter "github.com/arouter-ai/arouter-go"
)

key, _ := crypto.HexToECDSA("your-private-key-hex")

// One call sets up wallet JWT refresh + automatic x402 payment
client := arouter.NewClient(
    "https://api.arouter.ai",
    "",  // no API key needed
    arouter.WithX402CoinbasePayment(key),
)

resp, err := client.ChatCompletion(ctx, arouter.ChatCompletionRequest{
    Model:    "openai/gpt-5.4",
    Messages: []arouter.Message{{Role: "user", Content: "Hello"}},
})
```

### Solana

```go theme={null}
solanaKey := ed25519.PrivateKey(yourKeyBytes)

client := arouter.NewClient(
    "https://api.arouter.ai",
    "",
    arouter.WithX402SolanaPayment(solanaKey),
)
```

### SIWx Only (No Auto-Payment)

```go theme={null}
signer := arouter.NewEvmWalletSigner(privateKey)
result, err := arouter.AuthenticateWithSIWx(ctx, "https://api.arouter.ai", signer, nil)
client := arouter.NewClient("https://api.arouter.ai", result.JWT)
```

See the [x402 Payments Guide](/en/guides/x402-payments) for the full protocol flow.

## Error Handling

```go theme={null}
resp, err := client.ChatCompletion(ctx, req)
if err != nil {
    var apiErr *arouter.APIError
    if errors.As(err, &apiErr) {
        switch apiErr.StatusCode {
        case 401:
            log.Fatal("Invalid API key")
        case 429:
            log.Println("Rate limited, retrying...")
        case 502:
            log.Println("Upstream provider error")
        }
    }
}
```