Skip to content
LivePRICE FEED
Developers

Built to be reused.

A public API and TypeScript SDK for the BACKT registry, quotes and evidence records.

Coming soon · v1
API
/v1
Versioned JSON endpoints
SDK
@backt/sdk
TypeScript, one shared contract
Hosted backend
Not required
Runs locally in the SDK
Private keys
Never accepted
Unsigned payloads only
01API reference

Eight endpoints, versioned under /v1.#

Three static resources any host can serve, and five dynamic endpoints that run locally in the SDK or on a server you run.

/v1 endpoints
MethodEndpointPurposeRuns
Static resourcesserved as JSON
GET/v1/assetsList and filter the curated asset registry.Static resourcefiltered client-side
GET/v1/assets/{id}Retrieve a market passport, addresses and evidence.Static resource
GET/v1/agentsRead agent descriptions, capabilities and strategy versions.Static resource
Dynamic endpointslocal SDK or your own server
POST/v1/quotesRequest execution quotes through provider adapters.Local runtimeor a server you run
POST/v1/portfolios/planCalculate an allocation from user constraints.Local runtimeor a server you run
POST/v1/scenariosRun a stress test on live inputs; results return as scenario records.Local runtimeor a server you run
POST/v1/agents/runExecute a scoped agent workflow and return evidence.Local runtimeor a server you run
POST/v1/transactions/preparePrepare unsigned transaction payloads for wallet review.Local runtimeor a server you run

Never your keys. Never a signature.

The API never accepts private wallet keys and never signs for users. Preparation ends at an unsigned payload for wallet review.

Provider limits surface as errors.

Endpoints that call Jupiter or GeckoTerminal inherit their rate limits. A limit reached returns rate_limited, with the provider named.

02Response contract

Labels live on the record, not the response.#

Every result carries a schema version, request ID, status and data payload. Each data record carries its own classification, so a mixed result is labeled line by line.

Shared response fields
FieldMeaning
Every result
schemaVersionVersion of the contract the result conforms to.
requestIdIdentifier for tracing one request through adapters and logs.
statusWhether the request succeeded. Freshness lives on each record.
dataThe payload. Records inside it carry their own classification.
Every data record
classificationLiveDerivedScenarioUnavailableExactly one per record, sent as live, derived, scenario or unavailable.
sourcesReferences to where the value came from — a provider, an issuer document or input records.
observedAt · retrievedAtWhen the value was observed at its source, and when it was fetched.
expiresAtWhen the value stops being usable, such as a quote’s expiry.
assumptionsThe assumptions and shock parameters behind derived or scenario values.
Response

One response, four labels.

A live price, a derived price impact, a stress-test result and a field whose source went stale.

{
  "schemaVersion": "1.0",
  "requestId": "req_7Q5M3X9V",
  "status": "ok",
  "data": {
    "asset": "solana:A1KLoBrKBde8Ty9qtNQUtq3C2ortoC3u7twggz7sEto6",
    "records": [
      {
        "field": "price",
        "classification": "live",
        "value": "1.0931",
        "unit": "USD",
        "sources": [{ "provider": "jupiter", "kind": "token-price" }],
        "observedAt": "2026-10-12T14:02:08Z",
        "retrievedAt": "2026-10-12T14:02:09Z",
        "expiresAt": "2026-10-12T14:02:39Z"
      },
      {
        "field": "priceImpact",
        "classification": "derived",
        "value": "0.0031",
        "method": "abs(priceImpact) from a live quote at trade size",
        "inputTimestamps": { "quote": "2026-10-12T14:02:08Z" },
        "size": {
          "asset": "solana:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
          "baseUnits": "200000000",
          "decimals": 6
        },
        "expiresAt": "2026-10-12T14:02:39Z"
      },
      {
        "field": "stressedValueChange",
        "classification": "scenario",
        "value": "-0.079",
        "inputTimestamps": { "price": "2026-10-12T14:02:08Z" },
        "assumptions": {
          "priceShock": "-0.10",
          "liquidityShock": "-0.40",
          "bridgeDelayMinutes": 30
        }
      },
      {
        "field": "redemptionTerms",
        "classification": "unavailable",
        "value": null,
        "reason": "stale_data",
        "sources": [{ "issuer": "Ondo", "kind": "issuer-document" }],
        "lastObservedAt": "2026-10-03T09:00:00Z"
      }
    ]
  }
}
A failed provider call returns an error with the provider named.
  1. Liveprice

    Named source, observation and retrieval times, and an expiry.

  2. DerivedpriceImpact

    Method and input timestamp, at a stated trade size.

  3. ScenariostressedValueChange

    A stress test on live inputs, with its shock parameters attached.

  4. UnavailableredemptionTerms

    The source went stale, so the value is null with a reason.

Errors

Five error codes, each specific.

Errors distinguish invalid input, unsupported assets or routes, stale data, provider failure and rate limiting.

invalid_input
Invalid input
The request failed validation — a malformed identifier, amount or constraint.
unsupported_asset · unsupported_route
Unsupported asset or route
The asset or the route is outside the supported set.
stale_data
Stale data
A source answered, but beyond the accepted freshness threshold.
provider_failure
Provider failure
An upstream provider failed or returned a response that did not validate.
rate_limited
Rate limited
A provider limit, or a deployment’s own rate limit, was reached.
Money

Exact amounts, or no amounts.

Chain-qualified asset identifiers, decimal strings or integer base units for money, and explicit asset decimals. Token amounts are never calculated with floating-point arithmetic.

Chain-qualified identifiers

An asset is named by its chain and address — never by a ticker alone.

"solana:EPjF…Dt1v""USDC"

Decimal strings

Human-readable amounts travel as strings, so nothing is rounded on the way.

"amount": "200.00""amount": 200.0

Base units, explicit decimals

Or as an integer in the asset’s smallest unit, with its decimals stated alongside.

"baseUnits": "200000000", "decimals": 6"baseUnits": 2e8

No floating point

Token amounts are never calculated with floating-point arithmetic.

BigInt("200000000")0.1 + 0.2 → 0.30000000000000004
03TypeScript SDK

Seven modules, one contract.#

Every module in @backt/sdk returns the response contract above.

backt.registry01

Asset discovery, market passports and source records.

  • listAssets()
  • getAssetPassport()
backt.agents02

Agent manifests and scoped workflow execution.

  • runAgent()
backt.portfolio03

Allocation planning and exposure calculations.

  • planPortfolio()
backt.scenarios04

Stress tests on live inputs, returned as scenario records.

  • runScenario()
backt.routes05

Quote adapters for Jupiter routes on Solana.

  • getQuotes()
backt.transactions06

Unsigned payload preparation and wallet handoff.

  • prepareTransactions()
backt.evidence07

Schema validation, freshness checks and data classification.

  • Applied to every response
By design—

No module holds private keys, signs transactions or spends on its own. transactions stops at an unsigned payload.

Transports

Local, or a deployment you name.

Local mode runs calculations and stress tests in the browser or your own runtime. Remote mode connects to an HTTP deployment you configure.

Local

createClient({ transport: 'local' })
Runs
In the browser or a runtime you control
Needs
Nothing hosted by BACKT
Network
Quote adapters call Jupiter directly

Remote

createClient({ transport: 'remote', endpoint: '<your deployment>' })
Runs
On a server you operate
Needs
An endpoint set in createClient
Network
Same contract and labels, over HTTPS
Quickstart

From registry to wallet in seven calls.

quickstart.ts
import { createClient } from '@backt/sdk'

const USDC = 'solana:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'

// Local transport: calculations and stress tests run in this runtime.
const backt = createClient({ transport: 'local' })

// registry: static JSON, filtered client-side
const assets = await backt.registry.listAssets({ class: 'treasuries', chain: 'solana' })
const passport = await backt.registry.getAssetPassport(assets.data[0].id)

// agents: a scoped workflow that returns its evidence
const scout = await backt.agents.runAgent('scout', { brief: 'Tokenized Treasury products' })

// portfolio: money as decimal strings, never floats
const plan = await backt.portfolio.planPortfolio({
  budget: { amount: '200.00', asset: USDC, decimals: 6 },
  maxWeight: 0.4,
  candidates: scout.data.candidates,
})

// scenarios: stress tests on live inputs; every record comes back 'scenario'
const stress = await backt.scenarios.runScenario({
  plan: plan.data,
  shocks: { price: '-0.10', liquidity: '-0.40', bridgeDelayMinutes: 30 },
})

// routes, then transactions: every quote carries an expiry
const quotes = await backt.routes.getQuotes({ plan: plan.data })
const unsigned = await backt.transactions.prepareTransactions({ quotes: quotes.data })

// Hand the unsigned payload to the user's wallet to sign.
// The SDK never holds keys or signs.
Seven calls, one per step. Every result follows the response contract above.
04Guardrails

Guardrails built into every call.#

The rules that keep scenario results, provider secrets and user funds where they belong.

01

Scenarios can’t trade

Scenario tools are separate from execution adapters, so a scenario result can’t prepare a trade.

02

Validate before preparing

Provider responses and verified token addresses are checked before any transaction is prepared.

03

Bound to what was approved

Prepared actions are bound to the user-approved asset, recipient, amount, slippage and quote expiry.

04

A fresh approval, every time

Every execution requires a fresh wallet approval. Nothing spends on its own.

05

No keys, no signing

The API never accepts private wallet keys and never signs transactions on a user’s behalf.

06

No secrets in the frontend

Provider secrets stay in the user’s local runtime or a creator’s protected server. Shared secrets are never embedded in the frontend.

07

Limits on remote endpoints

Remotely deployed dynamic endpoints get input limits, request cancellation and rate limits.

08

Tested where it matters

Schemas, amount calculations, provider error handling, freshness thresholds — and the separation of scenario outputs from real execution.