Build on Vertalo.

One typed GraphQL endpoint over a Shared Ledger that acts as a single Golden Source of truth. Typed SDKs, webhooks, a sandbox with realistic data, and AI scaffolding — so your developers, and your AI agents, integrate in weeks, not months or years.

Get sandbox access Read the API docs →

● Typed SDKs · TypeScript & Python · Single GraphQL endpoint · Webhooks

first_issuance.ts@vertalo/sdk

// Typed end to end — your IDE and your AI agent
// both know the domain model.
import { Vertalo } from'@vertalo/sdk';
const v = newVertalo({ env: 'sandbox' });
const tx = await v.transfers.create({
  type: 'issuance',  // 'secondary' | 'redemption'
  chain: 'aptos',
  issuer: 'iss_8x42',
  holders: capTable.accredited(),
});
→ { id: 'tx_19f…', status: 'settled', onchain: true }

Your first transfer in an afternoon.

The first thirty minutes of integration should feel like working with Stripe. Install, authenticate against a sandbox that's already full of realistic data, and make a real call.

STEP 01

Install the SDK

npm i @vertalo/sdk

Typed clients for TypeScript and Python. The types are the documentation.

STEP 02

Authenticate to the sandbox

Point at the sandbox with your key. It's preloaded with cap tables and investor records — so you're not prototyping against empty data.

STEP 03

Make a real call

Create an issuance, run a transfer, subscribe to a webhook. Watch it settle on-chain in the sandbox before you write a line of production code.

Make the first thirty minutes feel like working with Stripe.

One endpoint. One Golden Source. Built to be integrated.

Vertalo treats itself as a third party to its own Shared Ledger, then exposes that ledger through a single, strongly-typed surface. The result is an API designed for integration first — by your developers and by AI agents.

Single GraphQL endpoint

One strongly-typed, introspective schema. Ask for exactly the data you need in one round-trip — no stitching together a dozen REST routes.

Shared Ledger · Golden Source

A single canonical record of ownership, with on-chain and off-chain positions reconciled. Build your own Shared Ledger inside your cloud, or use ours.

Rolled-up calls

Bundle multiple operations into one request, so common multi-step workflows don't become multi-trip integrations.

Create-or-get

Idempotent calls that create a record or return the existing one — simpler, safer integration logic with less defensive code.

Role-based access below the API

Permissions are enforced beneath the API surface. Every party sees only the data it is party to — uniformly, without per-query guesswork.

Webhooks & async events

React to settlement, blockchain confirmations, and position changes without polling — the backbone for AI-orchestrated, multi-step workflows.

A foundation that scales with you.

A raw API is where most platforms stop. Vertalo adds two layers above it — acceleration and ecosystem — so each engagement starts further along than the last.

The hardest domain problems — multi-class cap table state, blockchain confirmation UX, settlement reconciliation across on-chain and off-chain positions — are extracted from our own production frontend into components and reference apps you can fork.

LAYER 3 — ECOSYSTEM

Community · Partner Program · Developer Portal

Shared prompts and integration patterns that compound across the community.

LAYER 2 — ACCELERATION

Component Library · Reference Apps · AI Scaffolding

Fork a complete, runnable transfer-agent app, wired to the sandbox.

LAYER 1 — FOUNDATION

Typed SDK · Webhooks · Sandbox

AI-readable interfaces that generate correct code on the first try.

Well-typed interfaces, correct on the first try.

Verbose, intentional type names — like TransferRequestType: 'issuance' | 'secondary' | 'redemption' — let an AI assistant reason over the domain model and generate working code, where ambiguous types produce hallucinations and rework.

Well-typed SDK→AI generates correct code→Developers ship faster→More integrations→Platform improves

↻ a self-reinforcing loop

Fork a working app, not a blank page.

Complete, runnable reference applications for common client archetypes — wired to the sandbox and designed to be forked.