Skip to main content

Strategy Signals

With a general integrator key you can read the target-weight books of the copy-trading strategies Treasures publishes to integrators, and ask Treasures for the orders that bring one of your users' wallets, on Solana or BNB Smart Chain, to a book, or out of it. Treasures never signs for you: every order is a normal quote, signed by the wallet's owner and submitted through POST /trade/submit like any other trade.

How it works​

  1. Read the catalog. GET /signals/strategies lists the strategies you may read, each with the identity of its latest book. One call tells you which books changed since you last looked.
  2. Read a book. GET /signals/strategies/{id} returns the strategy and its current book: every ticker it holds and the fraction of the portfolio each should be. GET /signals/strategies/{id}/history pages through the past books.
  3. Plan the orders. POST /signals-orders/rebalance/plan returns the sells and buys that move a wallet's positions to the book; POST /signals-orders/exit/plan returns the sells that leave it. Both read the wallet and return orders only: nothing is quoted and nothing expires.
  4. Quote, sign and submit. Quote each order through POST /quote/sell or POST /quote/buy when the signer is ready, then submit the signed quotes, one at a time through POST /trade/submit or together through POST /trade/submit/batch.
  5. Wait for every order to finish. Poll GET /quote/{quote_id}/status until each is final before you plan again.

The two inline routes, POST /signals-orders/rebalance and POST /signals-orders/exit, fold steps 3 and the quoting half of step 4 into one call: the same orders, each already carrying its signable quote. They are for programmatic signers only; see Plan first, or quote inline.

Every route on this page requires your general tik_ key. A read-only trk_ reporting key is refused with 403 insufficient_scope, because the books are the product and that key is made to be forwarded.

What a book is​

A book is a strategy's complete target portfolio: one weight per ticker, as decimal strings that sum to at most one. It is a snapshot, never a change. deployed_weight is the sum of the weights and cash_weight the remainder, which the strategy holds as USDC.

A book is the replicated book, not the source filing. The source portfolio (a quarterly 13F, a legislator's transaction reports, a manager's published weights) is cut down to the names Treasures can trade on chain and renormalised to them. Each strategy carries a replication block so you can see how partial the result is: names_total positions in the source, names_replicated carried into the book, skipped_source_weight the share of the source's weight left out, and universe the chains the book was cut against with how many names each could buy.

Three fields identify a book:

FieldMeaning
signal_idOne publication of a book. A source that restates an unchanged portfolio daily produces a new signal_id each day
book_hashA SHA-256 over the book's contents. Two books with the same weights have the same hash whatever their signal_id, so compare hashes to know whether the weights moved
as_ofUnix seconds. When Treasures ingested the book, not the date of the underlying filing or disclosure

source_kind says what the book is derived from. Treat an unknown value as opaque; new ones may be added.

source_kindDerived from
institutional_13fAn institution's quarterly 13F holdings
congressional_disclosureA legislator's periodic transaction reports
media_inverseThe inverse of a broadcast pundit's calls
social_accountA public social-media account's posts
manager_publishedA fund manager publishes the book to Treasures directly, through the Manager API

A strategy's status is active (new books are expected), paused or halted (no new books for now; the last one stays readable). The catalog lists active and paused strategies only. A halted strategy leaves the catalog but stays readable by id or slug on the detail and history routes, and the exit routes still serve it; the rebalance routes refuse it.

strategy_id is the stable key. slug is a convenience that may be renamed; every route that takes an id accepts either, and every response carries the canonical id.

Reading books​

The catalog​

GET /signals/strategies returns one page, newest first, of the strategies published to you. Only strategies published to integrators appear, so a strategy you can see in the Treasures app may be absent here. truncated says whether the page cap of 100 cut it short.

curl https://api.treasures.io/public/v1/signals/strategies \
-H "X-API-Key: tik_..."
{
"data": [
{
"strategy_id": "cst_01J7W3M9P2K5R8XV6T4H0B1C7D",
"slug": "example-13f",
"name": "Example 13F",
"tagline": "A large institution's quarterly holdings, replicated on chain",
"description": "Follows the institution's 13F filing, cut to the names tradable on Solana.",
"portrait_url": "https://treasures.io/strategies/example-13f.png",
"status": "active",
"source_kind": "institutional_13f",
"listed_at": 1759795200,
"replication": {
"as_of": 1760947200,
"names_total": 41,
"names_replicated": 18,
"skipped_source_weight": "0.31280000",
"universe": { "chains": ["sol"], "buyable_by_chain": { "sol": 18 } }
},
"book_hash": "3f2a9c1e5b7d4a6f8e0c2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a",
"book_as_of": 1760947200,
"signal_id": "csg_01J8ZK6Q2M7R4XW9V3T5H2B6NE"
}
],
"truncated": false
}

Each row carries its latest book's book_hash, book_as_of and signal_id (all null while the strategy has no book yet), the same values the detail route serves. Keep the hash you last acted on per strategy and re-read a book only when it differs.

One strategy and its book​

GET /signals/strategies/{id} returns the strategy and book: the newest book the source produced that Treasures has finished acting on, or null when there is none yet. An older book is never substituted for a newer one that cannot be read.

curl https://api.treasures.io/public/v1/signals/strategies/example-13f \
-H "X-API-Key: tik_..."
{
"strategy": {
"strategy_id": "cst_01J7W3M9P2K5R8XV6T4H0B1C7D",
"slug": "example-13f",
"name": "Example 13F",
"tagline": "A large institution's quarterly holdings, replicated on chain",
"description": "Follows the institution's 13F filing, cut to the names tradable on Solana.",
"portrait_url": "https://treasures.io/strategies/example-13f.png",
"status": "active",
"source_kind": "institutional_13f",
"listed_at": 1759795200,
"replication": {
"as_of": 1760947200,
"names_total": 41,
"names_replicated": 18,
"skipped_source_weight": "0.31280000",
"universe": { "chains": ["sol"], "buyable_by_chain": { "sol": 18 } }
}
},
"book": {
"signal_id": "csg_01J8ZK6Q2M7R4XW9V3T5H2B6NE",
"as_of": 1760947200,
"book_hash": "3f2a9c1e5b7d4a6f8e0c2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a",
"position_count": 3,
"deployed_weight": "0.85",
"cash_weight": "0.15",
"weights": [
{ "ticker": "AAPL", "weight": "0.45" },
{ "ticker": "MSFT", "weight": "0.25" },
{ "ticker": "NVDA", "weight": "0.15" }
]
}
}

The example is shortened; a real book carries every replicated name.

History​

GET /signals/strategies/{id}/history returns every book the source produced that Treasures finished acting on, as full weight vectors, newest first. Each entry is a book plus trading_day, the US trading day (YYYY-MM-DD) it was acted on. Treasures' own weekly restatements of an unchanged book are not rows here; a source that re-publishes an unchanged portfolio daily is, so consecutive rows often share a book_hash.

Page with limit (1 to 100, default 20) and cursor: pass each response's next_cursor back as cursor while has_more is true. data may be shorter than limit while has_more is still true.

Caching, limits and refusals​

  • The catalog's book_hash per row is the change signal: keep the last hash you acted on per strategy and re-read a book only when it differs.
  • The three read routes share two buckets: 1,200 calls a minute per organisation (all of your keys together) and 600 a minute per key. There is no per-IP bucket. A 429 carries Retry-After in seconds.
  • An unknown id, a strategy that is not published to integrators and a typo all answer the same 404 strategy_not_found, so a response never reveals whether an id exists.

Acting on a book from a wallet​

Four routes turn a book into orders for one of your users' wallets. Each takes the same core body: the strategy (strategy_id, as id or slug), the wallet (sol_wallet) and an ownership proof with sol_signature. The two plan routes also take a BNB Smart Chain wallet with chain: "bnb"; what differs there is in On BNB Smart Chain, and the rest of this section describes Solana. The orders come back ranked and sized; you quote, sign and submit them.

RouteReturnsQuotes anything?
POST /signals-orders/exit/planOne full-share sell per name the wallet holds in the bookNo
POST /signals-orders/exitThe same sells, each with its signable /quote/sell answerYes
POST /signals-orders/rebalance/planThe sells and buys that bring the wallet's positions in the book's names to the book, plus a funding blockNo
POST /signals-orders/rebalanceThe same orders, each with its signable /quote/sell or /quote/buy answerYes

Every response carries the book it planned against (book_hash, signal_id, as_of), nav_usdc (the value of what the wallet holds in scope), usdc_available (the wallet's whole Solana USDC balance), orders[] and skipped[]. An order is {ticker, side, shares, notional_usdc}: a sell carries shares (floored to 18 decimal places, never rounded up) and its USD value; a buy carries shares: null and the USDC it spends in notional_usdc (floored to 6 decimal places). At most 25 orders come back per call, largest notional first, sells before buys on a rebalance.

Plan first, or quote inline​

The plan routes are the default. They read the wallet and return orders only. Nothing is quoted and nothing expires, so a human can review the orders and a hardware wallet can sign each one when ready. Quote each order yourself when the signer is ready, with the same wallet and a fresh proof:

  • A sell is POST /quote/sell with { "ticker", "amount_shares": <shares>, "chain": "sol", "sol_wallet", "ownership_proof", "max_slippage_bps" }.
  • A buy is POST /quote/buy with { "ticker", "amount_usdc": <notional_usdc>, "chain": "sol", "sol_wallet", "ownership_proof", "max_slippage_bps" }.

The inline routes are for programmatic signers only. They return the same orders, each with quote: exactly the /quote/sell or /quote/buy answer for that order, signable payloads included, to sign and submit through POST /trade/submit unchanged. A Solana leg is signable for about 45 seconds after the response; each quote's own expires_at binds, the top-level expires_at is the earliest of them and signing_window_sec the seconds left until it. max_slippage_bps is required on the inline routes (nothing is quoted without it) and optional on the plan routes.

Three rules apply to every call:

  • Solana unless you say otherwise. Without chain: "bnb", a body carrying eth_wallet is refused with 400 invalid_request. The inline routes are Solana only.
  • One wallet per strategy. Holdings are not tracked per strategy: every name of the book the wallet holds counts, whichever strategy (or none) it was bought for. Two strategies sharing a name in one wallet would sell or resize each other's position, so give each strategy its own wallet.
  • Pin the book you planned against. Send expected_book_hash and the call is refused with 409 book_changed (carrying the hash served now) if the book moved, before the wallet is read or anything is quoted. Re-read the book and decide again.

On the inline routes, one call at a time per wallet and strategy: while a quote from an earlier call for the same wallet and strategy is neither final nor five minutes past its expires_at, a new call is refused with 409 orders_in_flight naming those quote_ids (an empty list while the earlier call is still quoting) and Retry-After in seconds. A submitted quote counts as final once its status has been read as final, so poll every quote you submit. The plan routes are never refused this way; wait for every order yourself before planning again.

Exiting a book​

POST /signals-orders/exit/plan returns one full-share sell per name the wallet holds in the strategy's current book. Add tickers (up to 25) for positions you hold that have since left the book; each is sold only if held. protocol narrows which Solana venues are read and sold, as on /quote/sell, and must include a Solana protocol; a pinned exit covers the pinned venues only, so repeat the call per venue to exit fully.

curl -X POST https://api.treasures.io/public/v1/signals-orders/exit/plan \
-H "X-API-Key: tik_..." \
-H "Content-Type: application/json" \
-d '{
"strategy_id": "example-13f",
"sol_wallet": "7xKXtg2C…",
"ownership_proof": { "issued_at": 1760947200, "sol_signature": "<base64 Ed25519 signature>" },
"expected_book_hash": "3f2a9c1e5b7d4a6f8e0c2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a"
}'
{
"strategy_id": "cst_01J7W3M9P2K5R8XV6T4H0B1C7D",
"book_hash": "3f2a9c1e5b7d4a6f8e0c2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a",
"signal_id": "csg_01J8ZK6Q2M7R4XW9V3T5H2B6NE",
"as_of": 1760947200,
"nav_usdc": "1250.40",
"usdc_available": "310.25",
"orders": [
{ "ticker": "AAPL", "side": "sell", "shares": "2.5", "notional_usdc": "612.50" },
{ "ticker": "MSFT", "side": "sell", "shares": "1.25", "notional_usdc": "520.00" },
{ "ticker": "NVDA", "side": "sell", "shares": "0.9", "notional_usdc": "117.90" }
],
"skipped": []
}

nav_usdc counts the priced names held in scope only; an unpriced holding is still an order, with notional_usdc: null, ranked after the priced ones. A holding worth under $0.01 reads as not held. A holding that could not be read is skipped as holdings_unknown, never assumed absent. The plan applies no minimum size, but a sell too small to route can still be refused at quote time as no_routes.

Rebalancing to a book​

POST /signals-orders/rebalance/plan returns the sells and buys that move the wallet's positions in the book's names to the book. It takes the exit body minus protocol (every Solana venue counts), plus an optional amount_usdc.

Scoped nav. Every order is sized against nav_usdc: the value of what the wallet holds in the book's names (plus any tickers you add), plus amount_usdc. Each name's target is its book weight times that nav. The book's cash_weight stays as USDC and is never ordered; a tickers name outside the book has weight zero and is sold in full. Holdings outside the scope and the rest of the wallet's USDC are never touched.

Funding. Buys spend only amount_usdc, never the rest of the wallet's USDC, and are never larger than it. When the buys need more than that, each is scaled down pro rata and rounded down, and a scaled buy under $1 is skipped. A buy that cannot be funded is skipped as awaiting_sell_proceeds when the plan also sells, or insufficient_balance when it does not. The funding block says what happened:

FieldMeaning
usdc_spendableamount_usdc, or "0" when omitted: the only USDC this plan's buys spend
buys_required_usdcEvery buy the book asks for, ordered or not, excluding gaps under $1 and names that cannot be bought
buys_scaledtrue when the buys were scaled down to fit usdc_spendable
buys_deferred_usdcbuys_required_usdc less the buys in orders. Not the next round's amount_usdc
buys_deferred_until_sells_settletrue when buys are deferred and this plan sells: submit the sells, wait, call again
next_amount_usdcThe next call's amount_usdc: usdc_spendable plus the sells ordered, less the buys ordered. Send the smaller of it and usdc_available

A rebalance that only reshuffles what the wallet holds is therefore two rounds:

  1. Call with amount_usdc omitted. Submit the sells.
  2. Once every sell is final, call again with amount_usdc set to the smaller of funding.next_amount_usdc and usdc_available (proceeds land net of fees and slippage). Omit amount_usdc when that is zero: "0" is refused with 400. Submit the buys.

Use next_amount_usdc, not buys_deferred_usdc: it is the strategy's cash after the round, so it keeps the book's cash_weight and the weight of any name that cannot be bought inside nav. Without amount_usdc, the book's cash weight is sold on every call: nav is then only what the wallet holds, and the targets sum to the book's deployed share of it, so a book that is 15% cash sells about 15% of the held value each time it is planned without amount_usdc. Carry next_amount_usdc forward to keep that cash in nav.

Buying in from cash. Call with amount_usdc on a wallet that holds none of the book's names: every order is a buy, sized by its book weight of amount_usdc. A book with many names may take more than one round under the 25-order cap; submit the buys, wait for them to settle, and call again with next_amount_usdc.

curl -X POST https://api.treasures.io/public/v1/signals-orders/rebalance/plan \
-H "X-API-Key: tik_..." \
-H "Content-Type: application/json" \
-d '{
"strategy_id": "example-13f",
"sol_wallet": "7xKXtg2C…",
"ownership_proof": { "issued_at": 1760947200, "sol_signature": "<base64 Ed25519 signature>" },
"expected_book_hash": "3f2a9c1e5b7d4a6f8e0c2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a"
}'
{
"strategy_id": "cst_01J7W3M9P2K5R8XV6T4H0B1C7D",
"book_hash": "3f2a9c1e5b7d4a6f8e0c2b4d6f8a1c3e5b7d9f1a3c5e7b9d1f3a5c7e9b1d3f5a",
"signal_id": "csg_01J8ZK6Q2M7R4XW9V3T5H2B6NE",
"as_of": 1760947200,
"nav_usdc": "1250.40",
"usdc_available": "310.25",
"funding": {
"usdc_spendable": "0",
"buys_required_usdc": "187.56",
"buys_scaled": true,
"buys_deferred_usdc": "187.56",
"buys_deferred_until_sells_settle": true,
"next_amount_usdc": "187.50"
},
"orders": [
{ "ticker": "AAPL", "side": "sell", "shares": "0.765306", "notional_usdc": "187.50" }
],
"skipped": [
{ "ticker": "MSFT", "side": "buy", "reason": "awaiting_sell_proceeds", "detail": null },
{ "ticker": "NVDA", "side": "buy", "reason": "awaiting_sell_proceeds", "detail": null }
]
}

This is round one of a reshuffle: the wallet is overweight AAPL, so it sells down to the target, and the two buys wait for the proceeds. Round two sends amount_usdc: "187.50" and orders the buys.

Unlike an exit, which skips a name it cannot read, a rebalance refuses the whole request when any name in scope cannot be read (422 holdings_unknown) or a held one cannot be priced (422 price_unavailable), because one mis-sized name would mis-size every other order. The refusal lists the tickers to retry or remove.

A book name Treasures cannot buy on Solana is skipped as not_tradable and its weight stays in USDC; a gap under $1 is skipped as below_min_notional. A halted strategy answers 422 strategy_halted on both rebalance routes before anything is read, while the exit routes still serve it.

Wait for every order to finish before calling again. The plan reads holdings as they stand, and the plan route never refuses an early or repeated call, so it would return the same sells again and both sets could execute. Each order from the previous round must have reached a final status on GET /quote/{quote_id}/status first. The inline route refuses such a call with 409 orders_in_flight.

Quoting and submitting the orders​

Each order becomes one quote: a sell through /quote/sell with shares sent as amount_shares, a buy through /quote/buy with notional_usdc sent as amount_usdc, both with chain: "sol", the same wallet and a fresh proof. On a rebalance send no protocol. The inline routes return these quotes for you.

Submit each signed quote through POST /trade/submit, or up to 25 at once through POST /trade/submit/batch: one /trade/submit body per submission, same-chain Solana legs only, no quote_id twice. The batch answers every submission in request order with the http_status and body the single route would have given, so the batch's own 200 says nothing about any item. A submission the batch could not start in time answers 503 batch_deadline_exceeded: submit it again while its quote is live.

On the inline routes a partial result is normal. An order whose quote is refused moves to skipped with the error code its quote route would have answered (for example no_routes or holdings_insufficient), detail carrying the rest of that error body, and the response is still 200. An order whose quote expired before the response was sent is skipped as quote_stale.

A buy skipped at quote time is counted in buys_deferred_usdc and spends nothing from next_amount_usdc; a sell skipped at quote time adds nothing to it. When no sell is quoted, a buy held as awaiting_sell_proceeds is relabelled insufficient_balance, since no proceeds are coming.

On BNB Smart Chain​

The two plan routes take chain: "bnb" and plan the orders for a wallet on BNB Smart Chain. The inline routes do not: POST /signals-orders/exit and POST /signals-orders/rebalance refuse chain: "bnb" with 400 invalid_request, because a quote there must be signed within about 14 seconds, too short to quote a whole plan at once. Plan once, then quote, sign and submit each order on its own. Copying a Strategy on BNB Smart Chain walks through it with sample code.

curl -X POST https://api.treasures.io/public/v1/signals-orders/rebalance/plan \
-H "X-API-Key: tik_..." \
-H "Content-Type: application/json" \
-d '{
"strategy_id": "example-13f",
"chain": "bnb",
"eth_wallet": "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
"ownership_proof": { "issued_at": 1760947200, "eth_signature": "0x<EIP-191 signature>" },
"amount_usdc": "100"
}'

The body. Send chain: "bnb", eth_wallet in place of sol_wallet, and a proof carrying eth_signature. A sol_wallet in a bnb body is refused. On an exit, a protocol pin must include ondo or xstocks.

What the plan reads. The wallet's ondo and xstocks tokens on BNB Smart Chain, read live, and its Binance-Peg USDC, served as usdc_available floored to 6 decimal places. amount_usdc is in that USDC.

  • bStocks is never read or planned. A book name the wallet holds as bStocks reads as not_held: a rebalance buys its full target again, an exit leaves it in the wallet, and its value is not in nav_usdc. Sell it yourself first if you do not want both.
  • A book name with no ondo or xstocks listing on BNB Smart Chain is skipped as not_tradable and its weight stays in USDC.

Quoting each order. Use the same quote routes as on Solana, pinned to the venues the plan read:

  • A sell is POST /quote/sell with { "ticker", "amount_shares": <shares>, "chain": "bnb", "protocol": ["ondo", "xstocks"], "eth_wallet", "ownership_proof", "max_slippage_bps" }.
  • A buy is POST /quote/buy with { "ticker", "amount_usdc": <notional_usdc>, "chain": "bnb", "protocol": ["ondo", "xstocks"], "eth_wallet", "ownership_proof", "max_slippage_bps" }.
  • Always send protocol: ["ondo", "xstocks"], or the pin you sent on the exit plan. An unpinned bnb quote can route to bStocks, a listing the plan never read.
  • Submit each quote on its own POST /trade/submit. The batch route takes same-chain Solana legs only.
  • Slippage. Outside the US session, xStocks quotes on BNB Smart Chain often need a max_slippage_bps near 300; Ondo quotes measured under 100.

Venue minimums. On bnb the plan applies each name's venue floor: $10 for a name buyable (or, on a sell, held) on xStocks alone, $1 otherwise.

  • A rebalance gap under the floor is skipped as below_min_notional. So is a held name worth less than its floor on an exit plan, which applies no minimum on Solana.
  • On an exit plan, a held name with no price is skipped as price_unavailable, since its floor cannot be checked. On Solana it is still an order.
  • A plan can order no buys, with no error. When amount_usdc is short, each buy is scaled down and a scaled buy under its floor is skipped; the USDC that frees is not spread over the others. $30 over five xStocks-only names scales each to $6 and buys nothing. The shortfall stays in funding.buys_deferred_usdc.

No quote-call cap. The 25-order cap applies; the quote-call budget does not, so leg_cap on bnb means past 25 orders.

approvals. A bnb plan carries approvals[], absent on Solana: one row for USDC when the plan buys, then one per token a planned sell spends.

FieldMeaning
tokenThe token's address on BNB Smart Chain: Binance-Peg USDC on the USDC row, otherwise the held stock token
spenderThe settlement contract a gasless order pulls the token through, the same address as in Approvals by chain
approval_requiredtrue when the wallet's allowance falls short (of amount_usdc for USDC, of the balance for a held token): approve before submitting, or the order cannot fill. false when it covers. null when it could not be read: unknown, never approved, so check the allowance yourself

It is advisory: no approval is built for you, and the plan is served either way. Approvals are ordinary transactions paid in BNB; the trades themselves are gasless.

Skip reasons​

skipped[] entries are {ticker, side, reason, detail}. The plan-time reasons:

reasonMeaning
leg_capMore orders than fit in one call: past 25 orders, or on Solana past the quote-call budget (below). On an exit the smallest by notional go first, unpriced first; on a rebalance sells are admitted before buys. Call again once these have executed
not_heldNo position in the name on the venue, or one worth under $0.01, or one that floors to zero shares. On bnb, a name held only as bStocks
holdings_unknownThe holding could not be read, so it is never assumed absent. Exit only; a rebalance refuses the whole request instead
below_min_notionalA rebalance gap under $1. On bnb, a gap or an exit sell under the name's venue floor
awaiting_sell_proceedsA rebalance buy that amount_usdc cannot fund while the plan also sells. Call again with the proceeds once the sells settle
not_tradableA book name Treasures cannot buy on the venue: Solana, or ondo and xstocks on BNB Smart Chain. Its weight stays in USDC
insufficient_balanceA rebalance buy that amount_usdc cannot fund, with no sell to wait on
price_unavailableBnb exit plans only: a held name with no price, so its venue floor cannot be checked

On the inline routes reason can also be quote_stale or any error code /quote/sell or /quote/buy answers.

Refusals​

ResponseMeaningWhat to do
400 invalid_requesteth_wallet without chain: "bnb", sol_wallet with it, chain: "bnb" on an inline route, protocol on a rebalance or naming no protocol the venue reads on an exit, amount_usdc: "0", a missing max_slippage_bps on an inline route, or a malformed bodyFix the body
400 invalid_slippagemax_slippage_bps out of rangeSend a value in range
401A missing, malformed or unknown key, or an ownership proof failureCheck the key and sign a fresh proof
403 address_blockedSanctions screening flagged the walletNothing to retry
403 insufficient_scopeA trk_ reporting keyUse your tik_ key
404 strategy_not_foundUnknown, unpublished, or a typoRead the catalog
409 book_changedexpected_book_hash is not the book served now; the response carries the current book_hash. Nothing was read or quotedRe-read the book and plan again
409 orders_in_flightInline routes only: an earlier call's quotes for this wallet and strategy are neither final nor five minutes past expiry; quote_ids lists themPoll those quotes, then retry after Retry-After seconds
422 book_unavailableThe strategy has no book yetWait for its first book
422 holdings_unknown, 422 price_unavailableRebalance only: the listed tickers could not be read or priced, so no plan is offered. Usually transient, but a book name that is no longer tradable refuses every rebalance until the next bookRetry, or exit instead
422 insufficient_balanceamount_usdc is more than the wallet's USDC on the venueSend at most usdc_available
422 strategy_haltedRebalance only: the strategy is haltedUse the exit routes if you want out
429A bucket is spent; see belowSleep Retry-After seconds
503 holdings_unavailable, 503 balance_unavailable, 503 screening_unavailableThe wallet's holdings, its USDC balance or the screening check could not be read. A balance is never reported as zero when it could not be read. When the reads behind the plan did not answer within 15 seconds the call answers this way with Retry-After: 15Retry after Retry-After

Limits on the inline routes​

The inline routes, which are Solana only, count upstream quote calls, not requests. A sell held on one Solana venue costs 1 point, on two venues 3, on three 6; a buy costs at most 1 point per Solana venue it can buy on. Points are charged only after the wallet is admitted and only when there is something to quote, from a per-organisation bucket of 30 a minute and then a bucket of 90 a minute shared by every caller.

A Solana plan never costs more than 30 points: orders past that are skipped as leg_cap, so the plan route and its inline twin always answer the same split and a large exit or buy-in completes over a few calls. A plan costing more than the points left this minute is refused whole with 429 before any order is quoted. A 429 from the shared bucket can be another integrator's traffic and spends none of your own points; the X-RateLimit-* headers on these routes describe the shared bucket.

For fund managers​

A strategy run through the Manager API can be published to integrators as well, in which case its books are served here with source_kind: manager_published. Whether a strategy is published to integrators is decided by Treasures per strategy, not by the manager key.

Where to go next​