Ondo Global Markets

Ondo Global Markets brings tokenized stocks & ETFs on-chain as DeFi strategies (protocol: "Ondo", network: bsc). The market-share position always lives on BSC, but clients can fund a buy from — or receive a sell payout on — another EVM chain. Pods handles the bridge and the async order fill.

Introduction

Item	Value
Strategy ID format	`Ondo-<TICKER>-bsc` (e.g. `Ondo-AAPL-bsc`)
Position chain	BSC (`56`)
Strategy asset	Market-share token on BSC (symbol ends in `ON`, e.g. `AAPLON`)
Underlying reference	Strategy accounting settles in BSC USDC (18 decimals) internally. Funding/payout may use another chain’s USDC — on cross-chain calls, `quote.tokenIn` (buy) / `quote.tokenOut` (sell) are already expressed in that chain’s token, decimals and `chainId`.
Buy / Sell actions	`buy` or `request-lend` / `sell` or `request-withdraw`
Optional limit / expiry	`priceInUsd` (USD cents) and `expireAt` (Unix seconds) on BSC CoW bytecode — details
Minimum buy	`$10` USDC (`strategy.metadata.minRequestLendUsd`)
Auth	Header `x-api-key: <your-key>`

Same-chain (BSC)

Buy:  USDC (BSC)          → [client signs on BSC] → market shares (BSC)
Sell: market share (BSC)  → [client signs on BSC] → USDC (BSC)

Crosschain

Buy:  USDC (origin)      → [client signs on origin chain] → market shares (BSC)
Sell: market share (BSC) → [client signs on BSC]          → USDC (destination chain)

Position: always queried with the wallet on BSC.

Settlement is asynchronous. The on-chain transaction submits the request in seconds; the order reaches SUCCESS only after Ondo fills it (minutes later). For crosschain, the bridge leg settles first, then the order. Track both the on-chain receipt and the action status via WebSocket or history polling.

Quote and bytecode come from the same call. GET /strategies/:id/bytecode returns a priced quote (for your UI) and bytecode[] (to execute on-chain).

Preview quotes without a connected wallet. wallet also accepts the zero address (0x000…0) or a well-known burn address (e.g. 0x000…dEaD, 0x111…, 0x222…). The response is priced exactly like a real request but includes previewOnly: true and omits id, singleUseAddress, and orderUid — no Action is created, and the address is never persisted or synced to Moralis.

A previewOnly response has no bytecode to sign. Use the user’s real, owned wallet address for any request you intend to execute.

Authentication

Every request requires:

x-api-key: <your-api-key>

The key identifies your customer. Fee configuration and strategy catalog are scoped to it.
Success responses are the bare JSON body (HTTP 200). Errors use { "error": { "code", "message", "details?" } }.
Keep the API key on your backend — never expose it in a browser app.

Don’t have a key yet? Get an API key.

Integration flow

Buy and sell share one path — only the bytecode call (step 4) differs by direction.

Check market status

Check tradability — prefer passing a symbol.

GET /ondo/stocks/market-status?symbol=NVDAon

List Global Markets tokens

GET /tokens?category=stock&chainId=56

Resolve the strategy id

GET /strategies?protocol=Ondo&network=bsc

Generate bytecode — the only step that differs

GET /strategies/:id/bytecode

	BUY — `buy` or `request-lend`	SELL — `sell` or `request-withdraw`
`action`	`buy` or `request-lend`	`sell` or `request-withdraw`
Amount param	`amount=<fundingBaseUnits>`	`amountInShares=<shareWei>`
Direction params	`fromChainId` / `fromTokenAddress`	`toChainId` / `toTokenAddress`
Optional	`priceInUsd`, `expireAt` — limit & expiry	same

Show the quote

Buy only: enforce the $10 minimum.

Execute bytecode

Execute bytecode[] on the correct chain.

Track action status

Poll until SUCCESS — via WebSocket, GET /strategies/:id/status, or position/history polling.

Refresh positions

Re-read the wallet position to reflect the settled result.

1. Market status

Gate buy/sell when the market is closed. Optionally pass a Global Markets token symbol to enrich the same response with per-asset tradability under asset.

GET /ondo/stocks/market-status
GET /ondo/stocks/market-status?symbol=NVDAon

The response shape is always the Ondo Global Markets market-wide payload plus an asset field:

without symbol: asset is null — returns the default market status:

{
  "isOpen": true,
  "marketStatus": "regular",
  "nextOpen": "2025-08-21T13:31:00Z",
  "nextClose": "2025-08-20T19:59:00Z",
  "nextOpenSession": "regular",
  "reason": null,
  "timestamp": "2025-08-20T21:03:02Z",
  "asset": null
}

with symbol: asset contains the per-symbol tradability snapshot

Key market fields: isOpen — block new submissions when false. The payload may also include session details (marketStatus, nextOpen, nextClose, offhours). symbol is the Ondo Global Markets token symbol and must end in lowercase on (for example NVDAon, AAPLon). Invalid symbols return 422. When present, asset includes:

"asset": {
  "symbol": "NVDAon",
  "tradable": true,
  "limited": false,
  "blockingReason": null,       // { code, message } when not tradable
  "paused": false,
  "status": null,               // matching pause/limit entry when present
  "marketData": { /* raw Ondo per-asset market data (primary / underlying) */ }
}

Field	Meaning
`symbol`	Echo of the requested Global Markets token symbol
`tradable`	`true` when Deframe considers the symbol safe to trade right now
`limited`	`true` when an active `ASSET_LIMITED` restriction exists (trade still allowed)
`blockingReason`	`null` when tradable; otherwise `{ code, message }` explaining why not
`paused`	Convenience flag for an active `ASSET_PAUSED` restriction
`status`	Matching asset pause/limit entry when present
`marketData`	Raw per-asset market data (primary/underlying), when available

asset.tradable is false when:

The market is closed/paused (ONDO_MARKET_CLOSED / ONDO_MARKET_PAUSED), unless offhours.isOpen is true
The specific asset has an active ASSET_PAUSED restriction (ONDO_ASSET_PAUSED)

An active ASSET_LIMITED restriction does not flip tradable to false; it only sets limited: true. Bytecode generation for Ondo request-lend / request-withdraw uses the same tradability rules and returns 409 with those ONDO_* codes when a trade is blocked. Per-asset eligibility during off-hours can still fail later at CoW quote time with errors such as COW_ASSET_SESSION_CLOSED — see Ondo Global Markets docs.

2. List Stocks & ETFs

GET /tokens?category=stock&chainId=56&limit=300

category accepts comma-separated values (stock, etf).
Each token: { symbol, name, address, decimals, chainId, category, priceInUSD, logoURI? }.
Ondo symbols end in ON (e.g. AAPLON). Strip ON for display if desired.

3. Resolve strategy ID

A market-share token address alone is not enough — you need the strategy id.

GET /strategies?protocol=Ondo&network=bsc

Returns { data: [...], pagination }. Each item’s id is the strategy id you use — a slug in the form {protocol}-{assetName}-{network}:

{
  "data": [
    {
      "id": "Ondo-NVDA-bsc",                // ← the strategy id you pass to the bytecode call
      "protocol": "Ondo",
      "network": "bsc",
      "networkId": "56",                    // string, not number
      "asset": "0x…",                       // ← market-share token address (match this)
      "assetName": "NVDA",
      "assetToken": { "address": "0x…", "symbol": "NVDAon" },
      "availableActions": ["request-lend", "request-withdraw", "buy", "sell"]
    }
  ],
  "pagination": { "page": 1, "limit": 100, "total": 12 }
}

Pick the item where:

asset matches the market-share token address
networkId is "56" (a string)

Then pass its id (e.g. Ondo-NVDA-bsc) to buy / request-lend or sell / request-withdraw from availableActions. buy and sell do the same thing as request-lend and request-withdraw.

4. Buy — `buy` or `request-lend`

GET /strategies/:strategyId/bytecode

Parameter	Required	Description
`action`	yes	`buy` or `request-lend`
`wallet`	yes	Address that signs on the funding chain
`amount`	yes	Funding token in base units on `fromChainId`. Use the token’s decimals (from `fromTokenAddress`), not a fixed 6 — e.g. `10000000` = $10 USDC on Base (6 dec); `10000000000000000000` =$ 10 USDC on BSC (18 dec). Read `quote.tokenIn.decimals` to confirm.
`fromChainId`	yes	Funding chain (`56` for same-chain BSC, or another supported chain)
`fromTokenAddress`	yes	USDC (or supported token) contract on `fromChainId`. Required whenever `fromChainId` is set.
`priceInUsd`	no	Client CoW limit as integer USD cents (`17050` = $170.50). See limit price, expiry, and cancel.
`expireAt`	no	CoW `validTo` as a UTC Unix timestamp in seconds (not ms). Independent of `priceInUsd`.

Same-chain (BSC): fromChainId=56, fromTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d (18 decimals). The client signs on BSC. Buy $10 (USDC has 18 decimals on BSC → amount=10e18):

GET /strategies/Ondo-NVDA-bsc/bytecode?action=request-lend&wallet=0xYourWalletAddress&amount=10000000000000000000&fromChainId=56&fromTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d

Crosschain: fromChainId= origin chain (e.g. 8453 Base). The client signs only on the origin chain; Pods bridges funds to BSC and fills the order asynchronously. Buy $10 from Base (USDC has 6 decimals on Base → amount=10e6):

GET /strategies/Ondo-NVDA-bsc/bytecode?action=request-lend&wallet=0xYourWalletAddress&amount=10000000&fromChainId=8453&fromTokenAddress=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913

Response (relevant fields):

{
  "id": "<actionId>",              // correlate status & WebSocket
  "chainIdIn": 8453,               // number — funding chain (where the client signs)
  "chainIdOut": 56,                // number — position chain (BSC)
  "crossChain": { "isCrossChain": true, "chainIdIn": 8453, "chainIdOut": 56 },
  "singleUseAddress": "0x…",       // ephemeral wallet for async settlement
  "orderUid": "0x…",               // settlement order id
  "quote": {
    // Crosschain: tokenIn is the funding leg (origin token/chain), already merged with the bridge
    // quote — decimals and chainId always match what you actually send on fromChainId.
    "tokenIn":  { "amount", "amountInUSD", "symbol", "decimals", "chainId": 8453, ... },
    // tokenOut stays the settlement leg (market shares on BSC) — unaffected by the funding bridge.
    "tokenOut": { "amount", "minAmountOut", "amountInUSD", "chainId": 56, ... },
    // charges[] adds a bridgeAndSlippage line for the funding bridge alongside the settlement fees.
    "feeBreakdown": { "summary": { "platformFeesTotalInUSD", "bridgeAndSlippageImpactOutUSD" } }
  },
  // Each bytecode leg `chainId` is a decimal string (JSON bigint). Coerce with Number() vs chainIdIn.
  "bytecode": [
    { "to": "0x…", "value": "0", "data": "0x…", "chainId": "8453" }
  ]
}

Client execution

Atomic execution is mandatory. Cross-chain buys may return multiple legs on the funding chain (approve + bridge). Execute every leg where Number(chainId) === Number(chainIdIn) in one transaction — never as separate sends. Partial execution parks funds in escrow with PENDING status and no pipeline progress. See Executing Bytecode and EIP-7702.

Filter bytecode where Number(chainId) === Number(chainIdIn) (same-chain: 56; crosschain: the origin chain).
Batch all filtered legs into one signed transaction (output=bytecode + EIP-7702, or output=userOperation / output=fireblocks per your wallet stack).
Wait for async completion (crosschain: bridge → BSC → market-share fill).

Minimum: $10 USDC (enforced server-side, error REQUEST_LEND_AMOUNT_TOO_LOW). For crosschain the minimum is checked on the bridged USDC amount that lands on BSC.
Use quote for the full pricing UI (funding amount, expected shares, fees). quote.tokenIn always reflects fromChainId — read its decimals/chainId directly, no need to cross-reference §8.

Crosschain: the client only signs on the origin chain. Bridge + market-share purchase are handled by Pods.

5. Sell — `sell` or `request-withdraw`

GET /strategies/:strategyId/bytecode

Parameter	Required	Description
`action`	yes	`sell` or `request-withdraw`
`wallet`	yes	Address on BSC (where market shares are held)
`amountInShares`	yes	Share amount in wei (18 decimals)
`toChainId`	yes	Payout chain (`56` for same-chain BSC, or another supported chain)
`toTokenAddress`	yes	USDC (or supported token) on `toChainId`. Required whenever `toChainId` is set.
`priceInUsd`	no	Client CoW limit as integer USD cents (`17050` = $170.50). See limit price, expiry, and cancel.
`expireAt`	no	CoW `validTo` as a UTC Unix timestamp in seconds (not ms). Independent of `priceInUsd`.

Same-chain (BSC): toChainId=56, toTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d. The client signs on BSC. Sell 5 shares (shares are 18-decimal wei → amountInShares=5e18), receive USDC on BSC:

GET /strategies/Ondo-NVDA-bsc/bytecode?action=request-withdraw&wallet=0xYourWalletAddress&amountInShares=5000000000000000000&toChainId=56&toTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d

Use amountInShares (not amount) for Ondo sells. No minimum sell amount.
Response shape matches buy (id, chainIdIn, chainIdOut, crossChain, singleUseAddress, orderUid, quote, bytecode).

Sell legs are a direct transfer of the market-share token to singleUseAddress, not an approve + pull. If you run a calldata allowlist (e.g. a policy-signer-sponsored paymaster), the sell leg’s call target is the market-share token contract itself — whitelist each ticker token you support as a call target, not just a shared router/spender address.

Crosschain: toChainId= destination chain. The client signs only on BSC (shares live there); Pods sells the market share for USDC on BSC, then bridges the proceeds to the destination chain. Sell 5 shares (amountInShares is still 18-decimal shares → 5e18), receive USDC on Base:

GET /strategies/Ondo-NVDA-bsc/bytecode?action=request-withdraw&wallet=0xYourWalletAddress&amountInShares=5000000000000000000&toChainId=8453&toTokenAddress=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913

quote.tokenIn is always shares on BSC (decimals: 18, chainId: 56) — what the client signs away.
quote.tokenOut reflects the payout leg: on same-chain sells this is BSC USDC (decimals: 18); on cross-chain sells it is already toTokenAddress on toChainId (e.g. Base USDC = decimals: 6, chainId: 8453). Read quote.tokenOut.decimals / quote.tokenOut.chainId directly — never assume BSC decimals for a cross-chain sell, and never cross-reference §8 to guess the payout scale.
quote.feeBreakdown.charges[] includes a bridgeAndSlippage line for the exit and, on cross-chain sells, a second one for the payout bridge — both self-describe their own decimals/symbol, so render each line as-is rather than assuming a shared scale.
The payout bridge is requoted at forward time with the realized settlement balance, so treat quote.tokenOut on cross-chain sells as the estimate at bytecode time, not the final amount.
bytecode[].chainId is a decimal string (e.g. "56"). Compare with Number(leg.chainId) === 56 (or Number(chainIdIn)), never strict-equal to a numeric route field.

Client execution

Batch all BSC legs (Number(chainId) === 56) into one atomic transaction. See Executing Bytecode.

Filter bytecode where Number(chainId) === 56 (always BSC — shares are on BSC).
Batch and sign on BSC in a single transaction.
Wait for async completion (market-share fill → crosschain: bridge USDC to toChainId).

Crosschain: the client only signs on BSC. Market share → USDC redemption and the bridge payout are handled async by Pods.

Limit price, expiry, and cancel

priceInUsd and expireAt are optional on GET /strategies/:id/bytecode for Ondo BSC CoW (Ondo-*-bsc / OndoStockBsc) request-lend and request-withdraw. Ethereum primary Ondo strategies and every other strategy reject them with 400 PRICE_IN_USD_NOT_SUPPORTED / EXPIRE_AT_NOT_SUPPORTED. The two params are independent:

`priceInUsd`	`expireAt`	Price / slippage	CoW `validTo`
no	no	GM / CoinGecko + 100 bps	SLA (1.5× same-chain, 3× cross-chain)
no	yes	GM / CoinGecko + 100 bps	`expireAt`
yes	no	client limit + 10 bps	now + 24h
yes	yes	client limit + 10 bps	`expireAt`

priceInUsd is integer USD cents, not dollars. 17050 = $170.50. When set, the bytecode quote also includes:

Field	Meaning
`quote.clientLimitPriceUsd`	Client limit in dollars (`170.5`)
`quote.spotPriceUsd`	Reference spot used to compute distance
`quote.distanceBps`	Signed distance of the client limit vs spot, in basis points

expireAt is a UTC Unix timestamp in seconds (CoW validTo / uint32). Milliseconds are rejected (INVALID_EXPIRE_AT). The timestamp must be in the future and at most 168 hours from now. Buy

10 of NVDA on BSC with a

320.00 limit that expires in one hour:

GET /strategies/Ondo-NVDA-bsc/bytecode?action=request-lend&wallet=0xYourWalletAddress&amount=10000000000000000000&fromChainId=56&fromTokenAddress=0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d&priceInUsd=32000&expireAt=1778000000

Cancel a client-limit order

Only funded, unfilled client-limit actions (quote / PRESIGN clientLimitPriceUsd > 0) can be cancelled. An expireAt-only market order is not cancellable — it expires and refunds at orderValidTo.

GET /actions/:id/cancel?wallet=0xYourWalletAddress

Auth is x-api-key or a Bearer token. wallet must match the action’s requesting wallet. A 200 means the action is REFUNDED and the SUW refund outbox was queued (or already existed). Poll GET /actions/:id until the refund step / outbox confirms on-chain. The reason ONDO_CLIENT_LIMIT_CANCELLED is stored on the settlement step (steps[].failureReason), not as a top-level Action field.

Code	HTTP	When
`ACTION_CANCEL_WALLET_MISMATCH`	403	`wallet` is not the requesting wallet
`ACTION_CANCEL_NOT_SUPPORTED`	409	Not an Ondo BSC client-limit investment action
`ACTION_CANCEL_NOT_OPEN`	409	Already `SUCCESS`, `REFUNDED`, or `EXPIRED`
`ACTION_CANCEL_NOT_FUNDED`	409	Funding transfer has not confirmed yet
`ACTION_ALREADY_FILLED`	409	CoW already filled (including a fill that races the cancel)
`ACTION_CANCEL_REFUND_QUEUE_FAILED`	502	Cancel recorded `REFUNDED` but the refund outbox could not be queued

6. Positions & pending requests

The wallet is always normalized to BSC (same EVM address regardless of funding/payout chain).

Wallet snapshot (all positions)

GET /v2/wallets/:address?include=all

Stocks & ETFs appear under earn.positions where strategy.protocol === "Ondo" — not at the top level of the response:

{
  "tokens": {
    "positions": [ /* ERC-20 balances, unrelated to Ondo positions */ ],
    "summary": { "totalUsdValue": 128.40 }
  },
  "earn": {
    "positions": [
      {
        "spotPosition": {
          "currentPositionInShares": { "value": "<raw>", "decimals": 18, "symbol": "AAPLON" },
          "underlyingBalanceUSD": 14.98,
          "requestedToLend": [],
          "requestedToLendInShares": [],
          "requestedToWithdraw": [],
          "requestedToWithdrawInShares": [],
          "profitInUSD": 0.12
        },
        "strategy": {
          "protocol": "Ondo",
          "id": "Ondo-AAPL-bsc",
          "asset": "0x…",
          "networkId": 56,
          "metadata": { "ondoSymbol": "AAPL", "minRequestLendUsd": 10 }
        }
      }
    ],
    "summary": { "totalUnderlyingBalanceUSD": 14.98, "totalProfitInUSD": 0.12 }
  },
  "history": { "items": [ /* ... */ ], "pagination": { /* ... */ } }
}

Each entry in earn.positions has the same { spotPosition, strategy } shape as the single-strategy endpoint below — read earn.positions[].strategy.protocol === "Ondo" to filter for stocks & ETFs.

Single strategy position

GET /v2/wallets/:address/strategies/:strategyId

GET /v2/strategies/:strategyId?wallet=<address>

Both forms return the same response. It includes Actions-backed accounting for principal, profit, and in-flight operations. Example response — a settled 5-share AAPLON holding, nothing pending:

{
  "spotPosition": {
    "currentPositionInShares": {
      "value": "5000000000000000000",
      "decimals": 18,
      "symbol": "AAPLON"
    },
    "underlyingBalanceUSD": 14.98,
    "requestedToLend": [],              // pending buy, USDC
    "requestedToLendInShares": [],      // pending buy, shares
    "requestedToWithdraw": [],          // pending sell, USDC
    "requestedToWithdrawInShares": [],  // pending sell, shares
    "profitInUSD": 0.12
  },
  "strategy": {
    "protocol": "Ondo",
    "id": "Ondo-AAPL-bsc",
    "asset": "0x…",
    "networkId": 56,
    "metadata": { "ondoSymbol": "AAPL", "minRequestLendUsd": 10 }
  }
}

In-flight operations

The requestedTo* arrays represent pending async orders not yet settled (same on same-chain and crosschain):

Field	Meaning
`requestedToLend`	USDC committed to a pending buy
`requestedToLendInShares`	Equivalent shares for pending buy
`requestedToWithdraw`	USDC value of a pending sell
`requestedToWithdrawInShares`	Shares committed to a pending sell

Empty arrays mean nothing is pending. Expected states

Buy submitted, shares not yet credited → requestedToLend / requestedToLendInShares populated.
Sell submitted, USDC not yet paid out → requestedToWithdraw / requestedToWithdrawInShares populated.
Settled → all pending arrays empty; currentPositionInShares / underlyingBalanceUSD reflect the real balance.

Suggested polling: every 5–15 s until the pending arrays clear (or use WebSocket/webhook below).

Available balance for sell

Value	How to compute
`availableShares`	`currentPositionInShares.value` − sum of `requestedToWithdrawInShares`
`availableUSD`	`underlyingBalanceUSD` − sum of `requestedToWithdraw` (clamp to ≥ 0)

Do not subtract pending buys from available shares. Use availableShares as amountInShares when selling the full position.

7. Track order status

After submitting bytecode[] on-chain, the action is not complete until status is SUCCESS.

HTTP — pending actions for one strategy

Poll when you want a strategy-scoped snapshot without loading the full wallet or strategy position. The handler refreshes in-flight operations before responding.

GET /strategies/:strategyId/status?wallet=<address>

Parameter	Required	Description
`strategyId`	yes (path)	Strategy slug or id (e.g. `Ondo-AAPL-bsc`)
`wallet`	yes	Same wallet used in the bytecode call

Root response

{
  "strategyId": "Ondo-AAPL-bsc",
  "wallet": "0xUserWalletAddress",
  "hasPending": true,
  "message": "1 pending action(s) for this strategy.",
  "orderBook": { /* Ondo Global Markets only — explained below */ },
  "actions": []
}

Field	Type	Description
`strategyId`	string	Strategy slug
`wallet`	string	Checksummed address from query
`hasPending`	boolean	`true` when `actions.length > 0`
`message`	string	Human-readable summary
`actions`	array	Pending actions only (see below)
`orderBook`	object	CoW tradability probe — BSC Ondo stock strategies only
`gmMarket`	object	Ondo GM market/asset tradability — Ethereum primary strategies only

Orderbook

orderBook (BSC Ondo Global Markets strategies only) is a pre-flight tradability probe — it tells you whether a new request is likely to succeed right now, before you build any bytecode. requestLend covers buys and requestWithdraw covers sells (present only when sell is supported):

"orderBook": {
  "requestLend": {
    "canOpenOrder": true,
    "code": null,
    "errorType": null,
    "message": null,
    "retryable": false,
    "probeSellAmount": "100000000000000000000",
    "probeBuyAmount": "…"
  },
  "requestWithdraw": { /* same shape when sell is supported */ }
}

`orderBook` field	Meaning
`canOpenOrder`	Whether a new buy/sell request is likely to succeed right now
`code`	Stable error code when `canOpenOrder` is `false`
`errorType`	Additional machine-readable reason (nullable)
`message`	Human-readable reason (nullable)
`retryable`	Client may retry later (e.g. market closed)
`probeSellAmount`	Amount used for the availability probe (raw units)
`probeBuyAmount`	Expected output from probe when `canOpenOrder` is `true` (optional)

Present even when actions is empty.

GM market (Ethereum primary)

gmMarket is the equivalent pre-flight probe for Ethereum primary Ondo stock strategies. It comes from the memoized Ondo GM market/asset status, not CoW:

"gmMarket": {
  "source": "ondo-gm",
  "available": true,
  "tradable": true,
  "code": null,
  "message": null,
  "symbol": "NVDAon",
  "marketStatus": "regular",
  "isOpen": true,
  "asset": { "tradable": true, "paused": false, "limited": false }
}

available: false and code: "ONDO_GM_UNAVAILABLE" mean the GM API could not be reached. Closed/paused markets keep available: true and set tradable: false with ONDO_MARKET_CLOSED, ONDO_MARKET_PAUSED, or ONDO_ASSET_PAUSED.

Actions

What appears in actions[]

Action state	Listed?	Where to track instead
`PENDING`	yes	This endpoint
`INITIAL` (user has not sent the funding tx yet)	no	`GET /actions/:id`, WebSocket
`SUCCESS`, `REFUNDED`, `FAILED`, etc.	no	History, wallet position, WebSocket

Each item in actions[] — base fields (every pending action)

{
  "id": "674a1b2c3d4e5f6789012345",
  "type": "SAMECHAIN_INVESTMENT_DEPOSIT",
  "status": "PENDING",
  "createdAt": "2026-05-29T12:00:00.000Z",
  "updatedAt": "2026-05-29T12:10:00.000Z",
  "currentStep": {
    "stepIndex": 2,
    "status": "PENDING",
    "legs": [{ "kind": "SWAP", "status": "PENDING", "operator": null }]
  },
  "steps": [
    { "stepIndex": 0, "status": "SUCCESS", "legs": [] }
  ],
  "suw": { /* Ondo Global Markets same-chain only — explained below */ }
}

Field	Notes
`type`	Buy: `SAMECHAIN_INVESTMENT_DEPOSIT` or `CROSSCHAIN_INVESTMENT_DEPOSIT`. Sell: `SAMECHAIN_INVESTMENT_WITHDRAW` or `CROSSCHAIN_INVESTMENT_WITHDRAW`
`currentStep`	First step still `INITIAL` or `PENDING`. `null` when no step is waiting — the on-chain steps are done but the action is still settling async (track `suw.phase` instead), not a sign it’s finished
`steps`	Full pipeline snapshot
`steps[].legs[]`	`{ kind, status, operator }` — leg kind examples: `SWAP`, `PRESIGN`, `MINT`, `REDEEM`, `TRANSFER`, `BRIDGE`

Cross-chain pending actions include only the base block (no suw).

Same-chain suw

suw block (same-chain only):

"suw": {
  "singleUseAddress": "0x…",
  "phase": "order_in_progress",
  "fundsReturnedToWallet": false,
  "order": { /* posted and unposted shapes explained below */ },
  "balances": {
    "underlying": {
      "address": "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
      "symbol": "USDC",
      "decimals": 18,
      "amountRaw": "10000000000000000000",
      "amountHumanized": "10.0"
    },
    "strategy": {
      "address": "0x…",
      "symbol": "AAPLON",
      "decimals": 18,
      "amountRaw": "0",
      "amountHumanized": "0.0"
    }
  },
  "timing": {
    "requestedAt": "2026-05-29T12:00:00.000Z",
    "ageSeconds": 1800,
    "deadlineSeconds": 7200,
    "refundAt": "2026-05-29T14:00:00.000Z",
    "secondsUntilRefund": 120
  },
  "pricing": {
    "side": "BUY",
    "referencePriceUsd": 200,
    "livePriceUsd": 214,
    "priceSource": "ondo",
    "driftBps": 700,
    "slippageBps": 100
  },
  "suwSteps": [
    {
      "stepIndex": 1,
      "label": "presign",
      "status": "SUCCESS",
      "txHash": "0x…",
      "legs": []
    }
  ]
}

`suw` field	Meaning
`singleUseAddress`	Ephemeral wallet executing the async settlement
`phase`	High-level lifecycle — see table below
`fundsReturnedToWallet`	Final transfer to the user wallet completed
`order`	Settlement order metadata; `null` if not created yet
`balances`	Tokens on the single-use wallet during settlement; `null` after funds returned
`timing`	Request age, SLA, refund countdown
`pricing`	Reference vs live market price; `null` if unavailable
`suwSteps`	Internal settlement substeps (`presign`, `swap_and_settlement`, `forward_to_wallet`)

suw.phase lifecycle

Phase	UI meaning
`awaiting_transfer`	User has not completed the funding transfer
`awaiting_presign`	Funds received; Pods preparing settlement
`order_in_progress`	Settlement order open, awaiting fill
`awaiting_forward`	Fill complete; final transfer to user wallet pending
`completed`	Fully settled
`refunded` / `expired` / `failed` / `cancelled`	Terminal — drops out of `actions[]` on next poll

suw.order shapes All orders share a core, and posted decides the rest of the shape:

{
  "orderUid": "0x…",
  "posted": true,
  "quoteId": "…",
  "action": "request-lend",
  "sellAmount": "…",
  "buyAmount": "…",
  "status": "…"
}

Not posted yet (posted: false) — shows lastPostError, lastPostAttemptAt, canOpenOrder, code, message, retryable:

{
  "orderUid": "0x…",
  "posted": false,
  "quoteId": "…",
  "action": "request-lend",
  "sellAmount": "…",
  "buyAmount": "…",
  "status": "not_posted",
  "lastPostError": null,
  "lastPostAttemptAt": null,
  "canOpenOrder": true,
  "code": null,
  "message": null,
  "retryable": true
}

Posted / live (posted: true) — shows validTo, creationDate, executionDate, executedSellAmount, executedBuyAmount, txHash:

{
  "orderUid": "0x…",
  "posted": true,
  "quoteId": "…",
  "action": "request-lend",
  "sellAmount": "10000000000000000000",
  "buyAmount": "…",
  "status": "open",
  "validTo": 1710000000,
  "creationDate": "…",
  "executionDate": null,
  "executedSellAmount": null,
  "executedBuyAmount": null,
  "txHash": null
}

Non-Ondo strategies return the same root envelope without orderBook or suw.

Empty pending example

{
  "strategyId": "Ondo-AAPL-bsc",
  "wallet": "0x…",
  "hasPending": false,
  "orderBook": {
    "requestLend": { "canOpenOrder": true, "code": null, "errorType": null, "message": null, "retryable": false, "probeSellAmount": "100000000000000000000" },
    "requestWithdraw": { "canOpenOrder": true, "code": null, "errorType": null, "message": null, "retryable": false, "probeSellAmount": "1000000000000000000" }
  },
  "message": "No pending actions for this strategy. You are all caught up.",
  "actions": []
}

Suggested polling: every 5–15 s while hasPending is true, or until suw.phase reaches a terminal value. Example:

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/status?wallet=0xYOUR_WALLET"

WebSocket (recommended)

wss://api.pods.finance/updates

{ "type": "subscribe", "channel": "<walletAddress>" }

Listen for action_update events where action.id matches the bytecode response id:

Status	Meaning
`PENDING`	Awaiting settlement
`SUCCESS`	Order filled
`FAILED`	Order failed
`REFUNDED`	Order refunded

Re-subscribe on reconnect. Alternatively, use your customer webhook (ACTION_UPDATE events).

History

Wallet-wide history is embedded in GET /v2/wallets/:address?include=all. For this strategy’s position and history, use:

GET /v2/strategies/:strategyId?wallet=<address>

Market-share buys appear as SAMECHAIN_INVESTMENT_DEPOSIT; sells as SAMECHAIN_INVESTMENT_WITHDRAW. Ignore INITIAL status (quote artifact).

Refresh positions

Refetch wallet/strategy endpoints after on-chain confirmation and after WebSocket SUCCESS.

8. Supported chains & USDC addresses

Stocks & ETFs settle on BSC; funding (buy) and payout (sell) can use any supported USDC chain.

Network	Chain ID	USDC decimals	USDC address
BSC	`56`	18	`0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d`
Ethereum	`1`	6	`0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48`
Base	`8453`	6	`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`
Arbitrum	`42161`	6	`0xaf88d065e77c8cC2239327C5EDb3A432268e5831`
Polygon	`137`	6	`0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359`

When fromChainId / toChainId are set, fromTokenAddress / toTokenAddress are required — the API does not default to USDC. Omission returns 422 VALIDATION_ERROR. A non-USDC funding or payout token may add an extra same-chain swap leg.

9. Errors

Code	HTTP	When
`ONDO_MARKET_CLOSED`	409	Market closed (off-hours) — buy/sell blocked
`ONDO_MARKET_PAUSED`	409	Market paused by Ondo
`ONDO_ASSET_PAUSED`	409	This ticker is paused (`ASSET_PAUSED`)
`REQUEST_LEND_AMOUNT_TOO_LOW`	422	Buy below $10 USDC
`REQUEST_LEND_AMOUNT_TOO_HIGH`	422	Buy above the allowed max
`REQUEST_WITHDRAW_AMOUNT_TOO_HIGH`	422	Sell more than available shares
`LEND_AMOUNT_TOO_SMALL`	422	Amount too small for quote
`WITHDRAW_AMOUNT_TOO_SMALL`	422	Sell amount too small
`WITHDRAW_AMOUNT_REQUIRED`	400	Missing `amount`/`amountInShares`
`FROM_TOKEN_NOT_SUPPORTED`	400	Funding token not supported
`FROM_TOKEN_REQUIRED`	400	Crosschain buy without funding token
`TO_TOKEN_REQUIRED`	400	Crosschain sell without payout token
`CROSSCHAIN_BRIDGE_NO_OUTPUT`	422	Bridge returned no USDC for the buy
`USDC_NOT_SUPPORTED`	400	USDC not configured for the chain
`UNSUPPORTED_CHAIN`	400	Unknown `fromChainId`/`toChainId`
`QUOTE_NOT_FOUND`	404	Re-quote
`QUOTE_EXPIRED`	400	Re-quote
`BRIDGE_QUOTE_NOT_FOUND`	404	Crosschain bridge quote expired — re-quote
`VALIDATION_ERROR`	422	Missing `fromTokenAddress`/`toTokenAddress` when chain ID set; other schema failures
`INVALID_PRICE_IN_USD`	400	`priceInUsd` is not a positive integer in USD cents
`INVALID_EXPIRE_AT`	400	`expireAt` is not future UTC seconds, is milliseconds, or exceeds 168h
`PRICE_IN_USD_NOT_SUPPORTED`	400	`priceInUsd` on a strategy that is not Ondo BSC CoW
`EXPIRE_AT_NOT_SUPPORTED`	400	`expireAt` on a strategy that is not Ondo BSC CoW
`ACTION_CANCEL_WALLET_MISMATCH`	403	Cancel `wallet` does not match the action
`ACTION_CANCEL_NOT_SUPPORTED`	409	Cancel on a non-client-limit action
`ACTION_CANCEL_NOT_OPEN`	409	Cancel on a terminal action
`ACTION_CANCEL_NOT_FUNDED`	409	Cancel before the funding transfer confirms
`ACTION_ALREADY_FILLED`	409	Cancel after (or racing) a CoW fill
`ACTION_CANCEL_REFUND_QUEUE_FAILED`	502	Cancel recorded but refund outbox could not be queued
`NO_API_KEY` / `INVALID_API_KEY`	401	Auth failure

Preserve error.code in your UI for user-friendly messages.

10. Integration notes

Use the correct actions: buy or request-lend, and sell or request-withdraw. Do not use the generic lend/withdraw.
Sign on the right chain: buy = funding chain (chainIdIn); sell = always BSC; position = BSC wallet.
Atomic bytecode: never send bytecode[] legs as separate transactions — see Executing Bytecode.
Async completion: after the origin tx, Pods completes bridge (if crosschain) + order fill; monitor via the action status, position, or history.
Sells use shares: pass amountInShares (18 decimals), not amount. Gate sells on wallet position (currentPositionInShares) and suw.phase !== 'awaiting_forward'.
Wallet output: EOA → output=bytecode + EIP-7702; smart account → output=userOperation; Fireblocks → output=fireblocks + accountId.
Same EVM wallet works across funding/payout chains; the market-share position always lives on BSC.
Limit vs market: omit both params for a market CoW (100 bps + SLA validTo). Pass priceInUsd for a client limit (10 bps). expireAt only changes validTo and does not make the order cancellable — cancel requires priceInUsd.

Minimal example

Buy $10 of AAPL from Base (crosschain):

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/bytecode\
?action=request-lend&amount=10000000&wallet=0xYOUR_WALLET\
&fromChainId=8453&fromTokenAddress=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"

Buy with a $320.00 client limit (cents + optional expiry):

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/bytecode\
?action=request-lend&amount=10000000&wallet=0xYOUR_WALLET\
&fromChainId=8453&fromTokenAddress=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\
&priceInUsd=32000&expireAt=1778000000"

Cancel that order after funding, if it is still unfilled:

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/actions/<actionId>/cancel?wallet=0xYOUR_WALLET"

Sign response.bytecode (legs where Number(chainId) === 8453) on Base, then poll:

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/v2/strategies/Ondo-AAPL-bsc?wallet=0xYOUR_WALLET"

Sell shares, receive USDC on Arbitrum (crosschain):

curl -H "x-api-key: $API_KEY" \
  "https://api.pods.finance/strategies/Ondo-AAPL-bsc/bytecode\
?action=request-withdraw&amountInShares=1000000000000000000&wallet=0xYOUR_WALLET\
&toChainId=42161&toTokenAddress=0xaf88d065e77c8cC2239327C5EDb3A432268e5831"

Sign response.bytecode (legs where Number(chainId) === 56) on BSC, then poll the position until the pending arrays clear.

Endpoint reference

Concern	Method & Path
Market open / symbol tradable?	`GET /ondo/stocks/market-status` (`?symbol=` optional)
List Stocks & ETFs	`GET /tokens?category=stock&chainId=56`
List strategies	`GET /strategies?protocol=Ondo&network=bsc`
Strategy + position	`GET /v2/strategies/:id?wallet=<addr>`
Position per wallet	`GET /v2/wallets/:addr/strategies/:id`
Quote + bytecode	`GET /strategies/:id/bytecode`
Cancel client-limit	`GET /actions/:id/cancel?wallet=<addr>`
Pending actions	`GET /strategies/:id/status?wallet=<addr>`
Wallet snapshot	`GET /v2/wallets/:addr?include=all`
Wallet activity	`GET /actions?walletAddress=<addr>`
Status updates	`wss://<host>/updates`

All HTTP endpoints require x-api-key.

Overview

Guides

Integrations

Agents

Ondo Global Markets

Introduction

Authentication

Integration flow

1. Market status

2. List Stocks & ETFs

3. Resolve strategy ID

4. Buy — `buy` or `request-lend`

5. Sell — `sell` or `request-withdraw`

Limit price, expiry, and cancel

Cancel a client-limit order

6. Positions & pending requests

Wallet snapshot (all positions)

Single strategy position

In-flight operations

Available balance for sell

7. Track order status

HTTP — pending actions for one strategy

Root response

Orderbook

GM market (Ethereum primary)

Actions

Same-chain suw

Empty pending example

WebSocket (recommended)

History

Refresh positions

8. Supported chains & USDC addresses

9. Errors

10. Integration notes

Minimal example

Endpoint reference

​Introduction

​Authentication

​Integration flow

​1. Market status

​2. List Stocks & ETFs

​3. Resolve strategy ID

​4. Buy — buy or request-lend

​5. Sell — sell or request-withdraw

​Limit price, expiry, and cancel

​Cancel a client-limit order

​6. Positions & pending requests

​Wallet snapshot (all positions)

​Single strategy position

​In-flight operations

​Available balance for sell

​7. Track order status

​HTTP — pending actions for one strategy

​Root response

​Orderbook

​GM market (Ethereum primary)

​Actions

​Same-chain suw

​Empty pending example

​WebSocket (recommended)

​History

​Refresh positions

​8. Supported chains & USDC addresses

​9. Errors

​10. Integration notes

​Minimal example

​Endpoint reference

Introduction

Authentication

Integration flow

1. Market status

2. List Stocks & ETFs

3. Resolve strategy ID

4. Buy — `buy` or `request-lend`

5. Sell — `sell` or `request-withdraw`

Limit price, expiry, and cancel

Cancel a client-limit order

6. Positions & pending requests

Wallet snapshot (all positions)

Single strategy position

In-flight operations

Available balance for sell

7. Track order status

HTTP — pending actions for one strategy

Root response

Orderbook

GM market (Ethereum primary)

Actions

Same-chain suw

Empty pending example

WebSocket (recommended)

History

Refresh positions

8. Supported chains & USDC addresses

9. Errors

10. Integration notes

Minimal example

Endpoint reference