Go SDK

go get github.com/trutohq/truto-go-sdk@latest

import truto "github.com/trutohq/truto-go-sdk"

package main
 
import (
	"context"
	"fmt"
	"log"
	"os"
 
	truto "github.com/trutohq/truto-go-sdk"
)
 
func main() {
	ctx := context.Background()
	client := truto.NewClient(os.Getenv("TRUTO_API_TOKEN"))
 
	// Installed integrations in the environment
	for integration, err := range client.EnvironmentIntegrations.List(ctx).Seq() {
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(*integration.ID)
	}
 
	// Integrated accounts for a tenant
	accounts, err := client.IntegratedAccounts.List(ctx,
		truto.WithQuery(truto.Params{"tenant_id": "acme-1"})).All()
	if err != nil {
		log.Fatal(err)
	}
 
	// A Unified API call
	contacts := client.Unified.List(ctx, truto.UnifiedResource{
		Model:               "crm",
		Resource:            "contacts",
		IntegratedAccountID: *accounts[0].ID,
	})
	for contact, err := range contacts.Seq() {
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(contact["id"], contact["first_name"])
	}
}

client := truto.NewClient(os.Getenv("TRUTO_API_TOKEN"),
	truto.WithTimeout(20*time.Second),
	truto.WithMaxRetries(5),
)

_, err := client.IntegratedAccounts.Get(ctx, "missing-id")
 
var apiErr *truto.Error
switch {
case truto.IsNotFound(err): // also truto.IsUnauthorized, truto.IsRateLimited
	fmt.Println("not found")
case errors.Is(err, truto.ErrTimeout):
	fmt.Println("timed out")
case errors.As(err, &apiErr):
	fmt.Println(apiErr.StatusCode, apiErr.Message(), apiErr.Body)
}

account, err := client.IntegratedAccounts.Get(ctx, "ia-id",
	truto.WithTimeout(5*time.Second),
	truto.WithMaxRetries(5),
	truto.WithOnRetry(func(r truto.RetryInfo) {
		log.Printf("retry %d after status %d, waiting %s", r.RetryCount, r.StatusCode, r.Wait)
	}),
	truto.WithOnRateLimited(func(r truto.RateLimitInfo) {
		log.Printf("rate limited, waiting %s", r.RetryAfter)
	}),
)

runs := client.SyncJobRuns.List(ctx, truto.WithQuery(truto.Params{"sync_job_id": "sync-job-id"}))
for run, err := range runs.Seq() {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*run.ID, *run.Status)
}

tenants, err := client.Tenants.List(ctx).All()
first, err := client.Tenants.List(ctx).First() // truto.Done if there are none

it := client.Tenants.List(ctx, truto.WithQuery(truto.Params{"limit": 50}))
for {
	page, err := it.NextPage() // page.Items, page.NextCursor
	if errors.Is(err, truto.Done) {
		break
	}
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(len(page.Items))
}
 
item, err := it.Next() // one item at a time; truto.Done at the end

contacts := truto.UnifiedResource{Model: "crm", Resource: "contacts", IntegratedAccountID: "766cc1ee-..."}
 
it := client.Unified.List(ctx, contacts, truto.WithQuery(truto.Params{"limit": 50}))
contact, err := client.Unified.Get(ctx, contacts, "123")
created, err := client.Unified.Create(ctx, contacts, map[string]any{"first_name": "Ada"})
_, err = client.Unified.Update(ctx, contacts, "123", map[string]any{"first_name": "Grace"})
_, err = client.Unified.Delete(ctx, contacts, "123")
 
// Custom methods: POST /unified/{model}/{resource}/{method}
results, err := client.Unified.CustomMethod(ctx, contacts, "search", map[string]any{"query": "acme"})

meta, err := client.Unified.Meta(ctx, "crm", "contacts", "hubspot", "list")
crmOnHubSpot, err := client.Unified.ModelMeta(ctx, "crm", "hubspot")

type Contact struct {
	ID        string `json:"id"`
	FirstName string `json:"first_name"`
}
 
record, err := client.Unified.Get(ctx, contacts, "123")
c, err := truto.Decode[Contact](*record)
 
records, err := client.Unified.List(ctx, contacts).All()
all, err := truto.DecodeAll[Contact](records)

tickets := truto.ProxyResource{Resource: "tickets", IntegratedAccountID: "766cc1ee-..."}
 
it := client.Proxy.List(ctx, tickets)
ticket, err := client.Proxy.Get(ctx, tickets, "123")
_, err = client.Proxy.Create(ctx, tickets, map[string]any{"subject": "Help"})
_, err = client.Proxy.Update(ctx, tickets, "123", map[string]any{"status": "closed"})
_, err = client.Proxy.Delete(ctx, tickets, "123")
_, err = client.Proxy.CustomMethod(ctx, tickets, "merge", map[string]any{"ids": []string{"1", "2"}})

res, err := client.Custom.Get(ctx, "766cc1ee-...", "my/custom/path")
fmt.Println(res.ContentType, string(res.Body))
 
_, err = client.Custom.Post(ctx, "766cc1ee-...", "my/custom/path", map[string]any{"key": "value"})

mcpToken := "your-mcp-token"
 
_, err := client.MCP.Initialize(ctx, mcpToken, "my-client", "1.0.0")
tools, err := client.MCP.ListTools(ctx, mcpToken)
result, err := client.MCP.CallTool(ctx, mcpToken, "list_tickets", map[string]any{"status": "open"})
 
// Any other JSON-RPC message
_, err = client.MCP.Call(ctx, mcpToken, map[string]any{"jsonrpc": "2.0", "method": "tools/list", "id": 3})

it := client.IntegratedAccounts.List(ctx, truto.WithQuery(truto.Params{"tenant_id": "acme-1"}))
account, err := client.IntegratedAccounts.Get(ctx, "ia-id")
 
_, err = client.IntegratedAccounts.Validate(ctx, "ia-id")
_, err = client.IntegratedAccounts.BulkDelete(ctx, truto.Record{"tenant_id": "acme-1"})
capabilities, err := client.IntegratedAccounts.Capabilities(ctx, "ia-id")

server, err := client.IntegratedAccounts.CreateMCPServer(ctx, "ia-id", truto.IntegratedAccountMcpCreateRequest{
	Name:   "Support agent",
	Config: truto.IntegratedAccountMcpCreateRequestConfig{Methods: []string{"list", "get"}},
})
servers, err := client.IntegratedAccounts.ListMCPServers(ctx, "ia-id").All()

token, err := client.LinkTokens.Create(ctx, truto.LinkTokenRequest{TenantID: truto.Ptr("acme-1")})
fmt.Println(*token.LinkToken)

session, err := client.SessionTokens.Create(ctx, truto.SessionTokenRequest{TenantID: "acme-1"})

_, err := client.Tenants.Create(ctx, truto.TenantCreateRequest{ID: "acme-1", Name: truto.Ptr("Acme")})
_, err = client.Tenants.Update(ctx, "acme-1", truto.TenantUpdateRequest{Name: truto.Ptr("Acme Inc")})

integration, err := client.Integrations.Get(ctx, "integration-id")
capabilities, err := client.Integrations.Capabilities(ctx, "hubspot") // ID or name
 
_, err = client.Integrations.Install(ctx, "integration-id", true)
_, err = client.Integrations.Uninstall(ctx, "integration-id")

overrides := client.EnvironmentUnifiedModelResourceMethods.List(ctx,
	truto.WithQuery(truto.Params{"environment_unified_model_id": "..."}))
for override, err := range overrides.Seq() {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(*override.ID)
}

run, err := client.SyncJobRuns.Create(ctx, truto.SyncJobRunCreateRequest{
	SyncJobID:           "sync-job-id",
	IntegratedAccountID: "766cc1ee-...",
})
_, err = client.SyncJobRuns.Delete(ctx, *run.ID) // stops the run

webhook, err := client.Webhooks.Create(ctx, truto.WebhookCreateRequest{TargetURL: "https://example.com/truto"})
_, err = client.Webhooks.Test(ctx, truto.WebhookTestRequest{ID: *webhook.ID})

runs := client.WorkflowRuns.List(ctx, truto.WithQuery(truto.Params{"workflow_id": "workflow-id"}))
for run, err := range runs.Seq() {
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(run.Status)
}

_, err := client.ObservabilityDestinations.Test(ctx, "observability-destination-id",
	truto.ObservabilityDestinationTestRequest{})

dashboard, err := client.Analytics.Dashboard(ctx, truto.WithQuery(truto.Params{"range": "7d"}))
series, err := client.Analytics.Timeseries(ctx, truto.WithQuery(truto.Params{
	"environment_id": "environment-id",
	"metric":         "api_calls",
	"from":           "2026-10-01",
	"to":             "2026-10-08",
}))

logs := client.Logs.List(ctx, truto.WithQuery(truto.Params{"log_type": "unified_proxy_api"}))

var out map[string]any
err := client.Do(ctx, "GET", "/some/path", nil, &out, truto.WithQuery(truto.Params{"a": 1}))