Build a client SDK

The Client Builder turns a client — a named bundle of marketplace nodes and flows you assemble in the console — into a typed SDK in any of six languages: Python, Go, TypeScript, Java, C#, and Rust. The SDK uses real Protocol Buffers types and exposes one method per bundled node or flow. This guide creates a client, adds members from the marketplace, builds and downloads an SDK, and calls it.

Prerequisites#

• An Axiom account you can sign in to the editor with.
• Something to bundle: a published package (yours via axiom push, or any marketplace package) and/or a saved flow owned by your account.
• An API key for runtime calls — the generated SDK authenticates every request with one (see API keys).

Create a client#

1. In the app, go to Console → Client Builder (/console/client-builder): click Console in the top header — Client Builder is the first entry in the console sub-nav. It is also reachable from the command palette (⌘K, then "Client Builder").
2. Click New client.
3. Enter a Name — the name your code will know the SDK by, such as billing — and click Create client.

A client starts empty, and no language is chosen at creation: you pick the languages per build, and you can build the same client in more languages later.

Add nodes and flows#

A client's members are the nodes and flows its SDK exposes — each member becomes one method. In the client's detail view:

1. Click + Add nodes & flows. The page splits in two: the client's configuration on the left, the marketplace on the right.
2. Pick members in the marketplace panel:
   • Packages tab — click + Add all on a package card to take every node in the package, or open the package and add nodes one at a time. A version dropdown on the card (and in the package detail) selects which package version to add.
   • Flows tab — click + Add on a flow. Flows already in the client show In client.
3. Picked members collect in the tray at the bottom of the panel. Each has an alias — the method name the SDK will generate — prefilled from the node or flow name and editable inline. Aliases must be non-empty and unique within the client.
4. Click Add N members.

The Members list groups node members by their package, with a Remove all per package and a Remove per member; flow members are listed individually. Removing members changes only future builds — an already-built version is never altered (see the next section).

Build a version#

1. In the Build a version section, select one or more languages — Python, Go, TypeScript, Java, C#, Rust. Every language you select shares one version of the bundle.
2. Click Build.

The build allocates the next version number, snapshots the client's current members (with their pinned package versions), and compiles each selected language from that snapshot. The version appears in the Versions list with a per-language status — pending, building, then succeeded (or failed, with the error shown inline); the page refreshes statuses automatically. A version is an immutable snapshot: editing the client's members later never changes an existing version, only the next build.

To add a language to an existing version, use the + language… dropdown under that version. It compiles the new language from the version's frozen snapshot, so SDKs of the same version match exactly even if the client's members have changed since.

Download and install the SDK#

Each succeeded language row has a Download button that saves a ZIP (for a client named billing, billing-sdk-py.zip). The ZIP is a ready-to-build package for the language's standard toolchain. Every SDK ships with a README.md covering install, authentication, and the full method list, and a manifest.json recording exactly which nodes, flows, and package versions the version contains.

Call the SDK#

No API key is embedded in a generated SDK. Every language's client reads the AXIOM_API_KEY environment variable at construction (or takes the key as an explicit constructor argument) and sends it as a bearer token on every request:

export AXIOM_API_KEY="<your 64-character key>"

# app.py — after installing the Python SDK of a client named "billing"
from billing_sdk import Client

client = Client()  # reads AXIOM_API_KEY from the environment
result = client.summarize(req)  # one method per member, named by its alias

Methods take the member's typed input message and return its typed output message — the message classes are the generated protobuf types listed in the SDK's README.md. Method names derive from the alias in the language's own convention (summarize_invoice in Python and Rust, summarizeInvoice in Go, TypeScript, and Java, SummarizeInvoiceAsync in C#). A node member invokes that node directly by its human-readable URL (/v1/nodes/{owner}/{package}/{version}/{node}); a flow member invokes the flow's compiled artifact and returns its result. Pipeline (streaming) members return a stream of typed frames — a generator in Python, an async iterator in TypeScript, and the language's equivalent elsewhere.

The deployment origin the SDK calls is baked in at build time from the deployment you downloaded it from; every constructor accepts a base-URL override for pointing the same SDK at another deployment. A 401 response means a missing, invalid, or revoked API key — see API keys.