Go SDK

go get github.com/knoxcall/sdk-go@v1.0.0

import "github.com/knoxcall/sdk-go/knoxcall"

// Zero-option — credentials from `knoxcall login` or the environment
// (KNOXCALL_CLIENT_ID, KNOXCALL_CLIENT_SECRET):
client, err := knoxcall.New(knoxcall.Options{})

// Or OAuth client credentials inline — tenant auto-discovered from the credential.
client, err = knoxcall.New(knoxcall.Options{ClientID: "tk_xxxxxxxx", ClientSecret: "..."})

client, err := knoxcall.New(knoxcall.Options{}) // zero config — tenant and base URL come from the login

ctx := context.Background()

route, err := client.Routes.Create(ctx, knoxcall.CreateRouteInput{Name: "orders", TargetBaseURL: "https://api.example.com"})

page, err := client.Routes.List(ctx, &knoxcall.ListParams{Page: 2, PerPage: 50})
fmt.Println(page.Meta.Total, page.Meta.TotalPages, page.Meta.RequestID)

// Walk every page in one call:
all, err := client.Secrets.ListAll(ctx, nil)

// GET
resp, err := client.Call(ctx, "api-orders", &knoxcall.CallOptions{Path: "/users"})
defer resp.Body.Close()

// POST with a body, targeting a specific environment
resp, err = client.Call(ctx, "api-orders", &knoxcall.CallOptions{
    Method:      "POST",
    Path:        "/v1/charges",
    Body:        map[string]any{"amount": 2000, "currency": "usd"},
    Environment: "staging",
})

printnode := client.Route("api-printnode", &knoxcall.BoundRouteOptions{Environment: "production"})

resp, err := printnode.Get(ctx, "/computers", nil)
resp, err = printnode.Post(ctx, "/printjobs", &knoxcall.CallOptions{Body: job})
resp, err = printnode.Request(ctx, "DELETE", "/printjobs/42", nil)
// per-call options still override the bound defaults:
resp, err = printnode.Get(ctx, "/computers", &knoxcall.CallOptions{Environment: "staging"})

stop, err := client.Wrap.Intercept(ctx, knoxcall.WithHosts("api.resend.com")) // listed hosts with NO Route go through the ephemeral proxy
if err != nil {
    log.Fatal(err)
}
defer stop.Stop()
<-stop.Ready() // first manifest loaded

// Any code — or SDK — on http.DefaultClient, untouched:
res, err := http.DefaultClient.Get("https://api.hubapi.com/crm/v3/objects/contacts") // via the Route that covers api.hubapi.com

func handler(w http.ResponseWriter, r *http.Request) {
    body, _ := io.ReadAll(r.Body)
    event, err := knoxcall.ConstructWebhookEvent(body, r.Header, endpointSecret, nil)
    if err != nil {
        var ve *knoxcall.WebhookSignatureVerificationError
        if errors.As(err, &ve) {
            http.Error(w, "bad signature", http.StatusBadRequest)
            return
        }
    }
    switch event.Event {
    case "audit.event":
        audit, _ := event.AuditData()
        log.Println("audit:", audit.Action)
    default: // request.*
        data, _ := event.RequestData()
        log.Println(data.RouteName, data.Response.Status)
    }
}

_, err := client.Routes.Create(ctx, input)
var rl *knoxcall.RateLimitError
var ve *knoxcall.ValidationError
switch {
case errors.As(err, &rl):
    time.Sleep(time.Duration(rl.RetryAfter) * time.Second)
case errors.As(err, &ve):
    log.Println("validation failed:", ve.Fields)
}

client, err := knoxcall.New(knoxcall.Options{Tenant: "acme", DPoP: "always"})