Installation
go get github.com/arouter-ai/arouter-go
Quick Start
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
// 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
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
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
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
_, err := mgmtClient.UpdateKey(ctx, "KEY_HASH", &arouter.UpdateKeyRequest{
Disabled: boolPtr(true),
})
Delete API Key
err := mgmtClient.DeleteKey(ctx, "KEY_HASH")
Provider Proxy
For direct upstream access without model-field routing: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
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)
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
solanaKey := ed25519.PrivateKey(yourKeyBytes)
client := arouter.NewClient(
"https://api.arouter.ai",
"",
arouter.WithX402SolanaPayment(solanaKey),
)
SIWx Only (No Auto-Payment)
signer := arouter.NewEvmWalletSigner(privateKey)
result, err := arouter.AuthenticateWithSIWx(ctx, "https://api.arouter.ai", signer, nil)
client := arouter.NewClient("https://api.arouter.ai", result.JWT)
Error Handling
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")
}
}
}