Does Lattix provide SDKs and APIs?

Yes. Lattix provides Rust, Go, and Python SDKs plus a metadata-only Platform API for teams that need direct HTTP integration. The public contract is published as OpenAPI and is also exposed through the API Explorer.

What is the Lattix Platform API used for?

The Platform API is the metadata-only control plane behind the SDKs. Teams use it to discover caller identity, resolve policy, request key-access guidance, register protected artifacts, and emit evidence while keeping plaintext enforcement local to the workload.

When should an organization use the SDK instead of the API directly?

Use the SDK when your workload is in a supported language and you want typed local helpers for protection, access, rewrap, and evidence flows. Use the API directly when an unsupported language, orchestration layer, or existing platform control plane already owns the HTTP client behavior.

Can teams keep plaintext local when integrating with Lattix?

Yes. The public Lattix integration model is metadata-only on the wire. The SDKs and API are designed so applications can protect and access data locally while the platform handles identity, policy, key authorization, registration, and evidence decisions.

/DEVELOPERS

SDKs + Platform API for teams that keep enforcement close to the workload.

Lattix gives engineering teams a metadata-only control plane for identity, policy, key access, registration, and evidence — while the workload protects, unwraps, rewraps, and verifies data locally.

That means you can adopt Lattix through shipped products and connectors, embed the SDKs directly into applications and services, or integrate unsupported stacks through the same Platform API and published OpenAPI contract.

Explore SDKs View Platform API Open API Explorer

/CURRENT SURFACE

Public contract snapshot

GET /v1/sdk/capabilities

GET /v1/sdk/whoami

GET /v1/sdk/bootstrap

POST /v1/sdk/protection-plan

POST /v1/sdk/policy-resolve

POST /v1/sdk/key-access-plan

POST /v1/sdk/artifact-register

POST /v1/sdk/evidence

SDKs

Rust, Go, and Python ship against the same control-plane semantics.

Wire model

Metadata-only requests and responses; plaintext stays local to the workload.

Reference

API Explorer plus a published OpenAPI YAML for generators and linters.

Outcomes

Policy resolution, key guidance, artifact registration, and governance evidence.

OpenAPI YAML →Explorer →

/01Implementation Paths

/01Application teams, service owners, data pipelines, and agent runtimes.

SDK-first embedded enforcement

Use the Lattix SDKs when you want typed helpers for local protect, access, rewrap, signing, and CID-binding flows while keeping policy, identity, and key guidance in sync with the platform.

>Rust, Go, and Python bindings
>Local protect / access / rewrap helpers
>Consistent behavior across languages

Explore SDKs→

/02Platform teams, unsupported runtimes, and orchestration layers that already own HTTP clients.

API-direct orchestration

Use the Platform API directly when you need the same control-plane decisions in a language or workflow outside the shipped SDKs. The public contract stays small, explicit, and generator-friendly.

>Eight public /v1/sdk/* routes
>Metadata-only request / response model
>Published OpenAPI contract

View Platform API→

/03Security programs that want quick wins through products and connectors before custom code.

Product-led rollout

Start with Trust Fabric, Passport, Data Rooms, and connectors, then extend the same policy, evidence, and governance model into your own workloads where deeper integration matters.

>Adopt products first, integrate where it counts
>Re-use one policy and evidence model
>Bridge prebuilt and custom workflows

See Products→

/04Integrators, MSPs, coalition programs, and regulated multi-organization deployments.

Partner and SI delivery

Use the same SDK/API surfaces to package repeatable implementations, tenant-specific orchestration, and controlled rollout patterns for environments that cannot standardize on one stack overnight.

>Works for brownfield environments
>Supports partner-led implementation models
>Fits defense and regulated delivery motions

Partner With Lattix→

/02Organization Fit

Application Teams

Embed protection and access decisions directly inside applications so plaintext stays close to the workload and policy checks stay consistent across environments.

Platform & Security Teams

Standardize identity, policy resolution, key-authority planning, and evidence without forcing every business system into one runtime or language.

Systems Integrators

Package Lattix into repeatable solution blueprints for customers that need both productized controls and environment-specific orchestration.

Regulated Multi-Party Programs

Support provenance, evidence, revocation, and post-quantum-aware integration patterns for coalition, defense, and cross-organization exchange scenarios.

/03Developer Surfaces

Rust SDK

Canonical native implementation with the full control-plane contract and local helper surface.

Rust quickstart→

Go SDK

Ideal for sidecars, gateways, services, and mesh-friendly control paths that want the same native semantics.

Go quickstart→

Python SDK

A strong fit for pipelines, notebooks, orchestrators, and AI workflows that need typed local helpers plus async control-plane calls.

Python quickstart→

Platform API

The metadata-only HTTP control plane that powers the SDKs and supports unsupported languages or API-direct orchestration.

Platform API→

API Explorer

Browse the shipped route shapes, request bodies, response models, and tags from the same normalized OpenAPI document the SDKs align to.

Open Explorer→

OpenAPI Contract

Download the published YAML contract for generators, validation, linting, and internal integration governance.

Download spec→

/04Control Plane

Discover

Resolve who the caller is, what the deployment supports, and which auth model is active before a workload starts work.

capabilitieswhoamibootstrap

Decide

Ask the platform for policy, protection, and key-handling guidance without sending protected plaintext over the wire.

protection_planpolicy_resolvekey_access_plan

Prove

artifact_registerevidence

Enforce Locally

Use local helpers for TDF, envelope, detached signature, CID-binding, and managed key-provider flows inside your own runtime.

tdfenvelopedetached_signaturecid_binding

/START HERE

Bring the docs upstairs.

If you already know Lattix from the product side, this page is the shortest path into the SDKs, the Platform API, the API Explorer, and the OpenAPI contract. If you are meeting us from the engineering side first, it is the fastest way to understand how Lattix fits into your implementation model.

Explore SDKs Open API Explorer Talk to Engineering