Rust SDK

cargo add truto
cargo add tokio --features macros,rt-multi-thread
cargo add serde_json
cargo add futures-util               # for streaming a Pager
cargo add serde --features derive    # for decoding into your own types

use serde_json::json;
 
#[tokio::main]
async fn main() -> Result<(), truto::Error> {
    let client = truto::Client::new(std::env::var("TRUTO_API_TOKEN").unwrap());
 
    // Installed integrations in the environment
    let installed = client.environment_integrations().list().collect_all().await?;
    for integration in &installed {
        println!("{:?}", integration.id);
    }
 
    // Integrated accounts for a tenant
    let accounts = client
        .integrated_accounts()
        .list()
        .query(json!({ "tenant_id": "acme-1" }))
        .collect_all()
        .await?;
 
    // A Unified API call
    let Some(account) = accounts.first() else { return Ok(()) };
    let account_id = account.id.clone().unwrap_or_default();
    let contacts = client
        .unified_api()
        .list("crm", "contacts", &account_id)
        .collect_all()
        .await?;
    for contact in &contacts {
        println!("{:?}", contact.get("first_name"));
    }
    Ok(())
}

use std::time::Duration;
 
let client = truto::Client::builder()
    .token(std::env::var("TRUTO_API_TOKEN").unwrap())
    .base_url("https://api.truto.one") // default
    .timeout(Duration::from_secs(30)) // per attempt, default 30s
    .max_retries(3) // default 3
    .default_retry_after(Duration::from_secs(10)) // 429 without Retry-After
    .on_retry(|n, status| eprintln!("retry {n} after {status:?}"))
    .on_rate_limited(|after, n| eprintln!("rate limited, waiting {after}s (retry {n})"))
    .build()?;

use truto::Error;
 
match client.tenants().get("acme-1").await {
    Ok(tenant) => println!("{tenant:?}"),
    Err(e) if e.is_not_found() => println!("no such tenant"), // also is_unauthorized, is_rate_limited
    Err(Error::Api(api)) => {
        // status, status_text, parsed body (JSON or text), response headers
        println!("{} {}: {:?}", api.status, api.status_text, api.body);
    }
    Err(Error::Timeout) => println!("timed out"),
    Err(Error::Transport(e)) => println!("network: {e}"),
    Err(Error::Decode { message, .. }) => println!("unexpected response: {message}"),
    Err(e) => println!("{e}"),
}

use std::time::Duration;
 
let account = client
    .integrated_accounts()
    .get("ia-id")
    .timeout(Duration::from_secs(5))
    .max_retries(5)
    .retry_status_codes([500]) // in addition to the defaults
    .header("x-request-tag", "nightly-sync")
    .on_retry(|n, status| eprintln!("retry {n} ({status:?})"))
    .await?;
 
let once = client.integrated_accounts().get("ia-id").no_retry().await?;

use futures_util::TryStreamExt;
 
let mut runs = client
    .sync_job_runs()
    .list()
    .query(json!({ "sync_job_id": "sync-job-id" }))
    .into_stream();
while let Some(run) = runs.try_next().await? {
    println!("{:?} {:?}", run.id, run.status);
}

let tenants = client.tenants().list().collect_all().await?;
let first = client.tenants().list().first().await?; // Option<TenantResponse>

let mut pager = client.tenants().list().query(json!({ "limit": 50 }));
while let Some(page) = pager.next_page().await? {
    println!("{} tenants, next cursor {:?}", page.items.len(), page.next_cursor);
}

let ia = "766cc1ee-...";
let api = client.unified_api();
 
let contacts = api.list("crm", "contacts", ia).query(json!({ "limit": 50 })).collect_all().await?;
let contact = api.get("crm", "contacts", "123", ia).await?;
let created = api.create("crm", "contacts", ia, json!({ "first_name": "Ada" })).await?;
api.update("crm", "contacts", "123", ia, json!({ "first_name": "Grace" })).await?;
api.delete("crm", "contacts", "123", ia).await?;
 
// Custom methods: POST /unified/{model}/{resource}/{method}
let results = api
    .custom_method("crm", "contacts", "search", ia)
    .body(json!({ "query": "acme" }))
    .await?;

let meta = client.unified_api().meta("crm", "contacts", "hubspot", "list").await?;
let crm_on_hubspot = client.unified_api().model_meta("crm", "hubspot").await?;

#[derive(serde::Deserialize)]
struct Contact {
    id: String,
    first_name: Option<String>,
}
 
let contacts: Vec<Contact> = client
    .unified_api()
    .list("crm", "contacts", ia)
    .typed::<Contact>()
    .collect_all()
    .await?;
 
let record = client.unified_api().get("crm", "contacts", "123", ia).await?;
let contact: Contact = truto::decode(record)?;

let ia = "766cc1ee-...";
let api = client.proxy_api();
 
let tickets = api.list("tickets", ia).collect_all().await?;
let ticket = api.get("tickets", "123", ia).await?;
api.create("tickets", ia, json!({ "subject": "Help" })).await?;
api.update("tickets", "123", ia, json!({ "status": "closed" })).await?;
api.delete("tickets", "123", ia).await?;
api.custom_method("tickets", "merge", ia).body(json!({ "ids": ["1", "2"] })).await?;

let result = client.custom_api().get("my/custom/path", ia).await?;
client.custom_api().post("my/custom/path", ia, json!({ "key": "value" })).await?;
 
// Non-JSON responses, such as files: use .raw()
let report = client.custom_api().get("reports/export.csv", ia).raw().await?;
println!("{} bytes of {:?}", report.body.len(), report.content_type());

let mcp_token = "your-mcp-token";
 
client.mcp().initialize(mcp_token, "my-client", "1.0.0").await?;
let tools = client.mcp().list_tools(mcp_token).await?;
let result = client.mcp().call_tool(mcp_token, "list_tickets", json!({ "status": "open" })).await?;
 
// Any other JSON-RPC message
client.mcp().call(mcp_token, json!({ "jsonrpc": "2.0", "method": "tools/list", "id": 3 })).await?;

let accounts = client
    .integrated_accounts()
    .list()
    .query(json!({ "tenant_id": "acme-1" }))
    .collect_all()
    .await?;
let account = client.integrated_accounts().get("ia-id").await?;
 
client.integrated_accounts().validate("ia-id").await?;
client.integrated_accounts().bulk_delete(json!({ "tenant_id": "acme-1" })).await?;
let capabilities = client.integrated_accounts().capabilities("ia-id").await?;

use truto::models::{IntegratedAccountMcpCreateRequest, IntegratedAccountMcpCreateRequestConfig};
 
let server = client
    .integrated_accounts()
    .create_mcp_server(
        "ia-id",
        &IntegratedAccountMcpCreateRequest {
            name: "Support agent".into(),
            config: IntegratedAccountMcpCreateRequestConfig {
                methods: Some(vec!["list".into(), "get".into()]),
                ..Default::default()
            },
            ..Default::default()
        },
    )
    .await?;
let servers = client.integrated_accounts().list_mcp_servers("ia-id").collect_all().await?;

use truto::models::LinkTokenRequest;
 
let token = client
    .link_tokens()
    .create(&LinkTokenRequest {
        tenant_id: Some("acme-1".into()),
        ..Default::default()
    })
    .await?;
println!("{:?}", token.link_token);

use truto::models::SessionTokenRequest;
 
let session = client
    .session_tokens()
    .create(&SessionTokenRequest {
        tenant_id: "acme-1".into(),
        ..Default::default()
    })
    .await?;

use truto::models::{TenantCreateRequest, TenantUpdateRequest};
 
client
    .tenants()
    .create(&TenantCreateRequest {
        id: "acme-1".into(),
        name: Some("Acme".into()),
        ..Default::default()
    })
    .await?;
client
    .tenants()
    .update("acme-1", &TenantUpdateRequest {
        name: Some("Acme Inc".into()),
        ..Default::default()
    })
    .await?;

let integration = client.integrations().get("integration-id").await?;
let capabilities = client.integrations().capabilities("hubspot").await?; // ID or name
 
client.integrations().install("integration-id", true).await?;
client.integrations().uninstall("integration-id").await?;

let overrides = client
    .environment_unified_model_resource_methods()
    .list()
    .query(json!({ "environment_unified_model_id": "..." }))
    .collect_all()
    .await?;

use truto::models::SyncJobRunCreateRequest;
 
let run = client
    .sync_job_runs()
    .create(&SyncJobRunCreateRequest {
        sync_job_id: "sync-job-id".into(),
        integrated_account_id: "766cc1ee-...".into(),
        ..Default::default()
    })
    .await?;
client.sync_job_runs().delete(run.id.as_deref().unwrap_or_default()).await?; // stops the run

use truto::models::{WebhookCreateRequest, WebhookTestRequest};
 
let webhook = client
    .webhooks()
    .create(&WebhookCreateRequest {
        target_url: "https://example.com/truto".into(),
        ..Default::default()
    })
    .await?;
client
    .webhooks()
    .test(&WebhookTestRequest {
        id: webhook.id.clone().unwrap_or_default(),
        ..Default::default()
    })
    .await?;

let runs = client
    .workflow_runs()
    .list()
    .query(json!({ "workflow_id": "workflow-id" }))
    .collect_all()
    .await?;
for run in &runs {
    println!("{:?}", run.status);
}

use truto::models::ObservabilityDestinationTestRequest;
 
client
    .observability_destinations()
    .test("observability-destination-id", &ObservabilityDestinationTestRequest::default())
    .await?;

let dashboard = client.analytics().dashboard().query(json!({ "range": "7d" })).await?;
let series = client
    .analytics()
    .timeseries()
    .query(json!({
        "environment_id": "environment-id",
        "metric": "api_calls",
        "from": "2026-10-01",
        "to": "2026-10-08",
    }))
    .await?;

let logs = client.logs().list("unified_proxy_api").first().await?;