Skip to main content

​
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.com",
        "lr_live_xxxx",
    )

    resp, err := client.ChatCompletion(context.Background(), arouter.ChatCompletionRequest{
        Model: "gpt-4o",
        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-20250514",
    Messages: []arouter.Message{
        {Role: "user", Content: "Hello!"},
    },
})

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

​
Streaming

stream, err := client.ChatCompletionStream(context.Background(), arouter.ChatCompletionRequest{
    Model: "gpt-4o",
    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.com", "lr_mgmt_xxxx")

key, err := mgmtClient.CreateKey(ctx, &arouter.CreateKeyRequest{
    Name:             "production-backend",
    AllowedProviders: []string{"openai", "anthropic"},
    AllowedModels:    []string{"gpt-4o", "claude-sonnet-4-20250514"},
    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-4o",
    "messages": []map[string]string{{"role": "user", "content": "Hello!"}},
})

​
Client Options

client := arouter.NewClient(
    "https://api.arouter.com",
    "lr_live_xxxx",
    arouter.WithTimeout(30 * time.Second),
    arouter.WithHTTPClient(customHTTPClient),
)

​
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")
        }
    }
}