Put the stock market in your app.

From a ticker to a checked trade.

Ask for a USDG-to-NVDA trade. Stocklayer resolves the stock token, checks the wallet, builds the route, and simulates the full sequence before returning anything to sign.

Your first checked trade plan.

Available now: the hosted sandbox, HTTP API, published TypeScript SDK, and all eight local MCP tools. Test keys use fixture prices, balances, quotes, and simulation results. Live USDG-to-NVDA quotes and unsigned plans have passed verification through Uniswap. Live routes depend on liquidity, provider access, and sufficient token and gas balances on Robinhood Chain. Never submit sandbox transactions to a real wallet.

Use Node.js 20.3 or later. This example spends 500 simulated USDG on NVDA with a test key. It needs no funded wallet and moves no money.

1. Create a test key.Open the dashboard, create a test-environment API key, and enable the trade:plan scope.
2. Save and run the example.Save the code below as quickstart.mjs. Install the SDK, replace the key placeholder with your test key, and run the file from your terminal.
3. Inspect the result.With no blocking project policy, the funded sandbox wallet returns an allowed plan with an approval followed by a swap.

npm install @stocklayer/sdkexport STOCKLAYER_PROJECT_KEY="stocklayer_test_..."node quickstart.mjs

1import { StocklayerClient } from "@stocklayer/sdk";23const stocklayer = new StocklayerClient({4  baseUrl: "https://stocklayer.dev/api/v0",5  apiKey: process.env.STOCKLAYER_PROJECT_KEY,6});78const plan = await stocklayer.trades.plan({9  wallet: "0x0000000000000000000000000000000000000001",10  intent: {11    type: "exact_input",12    tokenIn: "USDG",13    tokenOut: "NVDA",14    amountIn: "500",15  },16  slippageTolerance: 0.5,17});1819console.log(JSON.stringify({20  status: plan.status,21  verdict: plan.verdict.outcome,22  simulation: plan.simulation.status,23  steps: plan.steps.map(step => step.kind),24  signing: plan.signing.mode,25}, null, 2));

{  "status": "ready",  "verdict": "allow",  "simulation": "passed",  "steps": ["approve", "swap"],  "signing": "wallet_controlled"}

curl https://stocklayer.dev/api/v0/trades/plan \  -H "Authorization: Bearer $STOCKLAYER_PROJECT_KEY" \  -H "Content-Type: application/json" \  -H "Idempotency-Key: stocklayer-quickstart-0001" \  -d '{    "wallet": "0x0000000000000000000000000000000000000001",    "intent": {      "type": "exact_input",      "tokenIn": "USDG",      "tokenOut": "NVDA",      "amountIn": "500"    },    "slippageTolerance": 0.5  }'

Authenticate server-side.

Create a test or live project key in the dashboard, pass it as a bearer token, and keep it in server environment variables. Keys are isolated by environment and never belong in a browser bundle. The API, SDK, and MCP server do not require token ownership.

Test keys run against a deterministic sandbox.

A stocklayer_test_ key never reaches Robinhood, the chain, 0x, or Uniswap. Every call is answered from a fixed catalog with repeatable balances, so your integration tests need no provider credential. Pick an outcome by wallet address, or force one with the x-stocklayer-scenario header.

• fundedFunded; approval required before the swap
  0x0000000000000000000000000000000000000001
• approvedFunded; approval already granted
  0x0000000000000000000000000000000000000002
• insufficient_balanceHolds 1 USDG; plans fail closed
  0x0000000000000000000000000000000000000003
• zero_balanceEmpty wallet
  0x0000000000000000000000000000000000000004
• simulation_failedPlan is blocked with no signable transactions
  0x0000000000000000000000000000000000000005
• provider_degradedQuote provider returns a retryable error
  0x0000000000000000000000000000000000000006

Any other wallet behaves like zero_balance. The symbol HALT reports a trading halt. Plan and quote identifiers repeat when you send the same x-request-id. Sandbox responses carry x-stocklayer-sandbox: on.

Every plan tells you whether to allow, review, or block it.

Stocklayer first simulates the full sequence, then applies the active immutable policy for that project. Policies can allow or block stocks and payment tokens, and set warning or blocking thresholds for trade size and requested slippage. Every result includes structured checks a person or coding agent can explain.

One API. Explicit contracts.

All routes are versioned under /api/v0. Quantities use exact decimal strings, addresses are checksummed, and every response includes a request ID.

A response your app can act on.

Successful HTTP responses return data and meta. Failures return error and meta, with a stable code, message, retryability, and details. The SDK unwraps data and throws a typed StocklayerApiError for failures.

The OpenAPI schema contains the full request and response contract, including executable examples. API discovery, health, and OpenAPI are public; market endpoints require a project key.

Know the route before the wallet signs.

Stocklayer normalizes quotes from configured routing providers. The Uniswap connection has passed a live USDG-to-NVDA plan check; 0x aggregation is not enabled. The selected provider, route, amounts, and slippage come back on the quote and plan so your app can show them and your policy can rule on them.

Keep the plan. Retrieve it by ID.

Stocklayer stores each plan with its original policy verdict and simulation evidence and returns it by ID from the same project environment until it expires. Your wallet signs and submits the transactions. Stocklayer never submits for you, so your app owns the receipt and the record of what it sent.

Give your agent the same checked trade flow.

@stocklayer/mcp exposes the API as eight MCP tools, so Claude, Cursor, and any other MCP client can look up an asset, price it, quote it, preflight a trade, and hand back an unsigned plan. The project key stays in the local MCP process. Your wallet still signs.

1. Create a test key.In the dashboard, select the test environment and enable market:read, portfolio:read, trade:plan, and transaction:simulate to use all eight tools.
2. Connect your client.Install Node.js 22.13 or newer. Add the configuration below to your client’s MCP settings, replace stocklayer_test_... with your key, and reconnect the server. This is a local stdio server, not a remote MCP URL.
3. Run a sandbox plan.Ask: “Use Stocklayer to prepare an exact-input trade of 500 USDG for NVDA with wallet 0x0000000000000000000000000000000000000001. Show the verdict, checks, and unsigned transactions.” With no blocking project policy, expect ready, allow, and two unsigned transactions.

Check the request in your dashboard logs. If tools do not appear, check Node.js and reconnect the client. A 401 means the key is missing, invalid, or revoked; a 403 can mean a required scope is missing. Keep keys private and never paste wallet signing keys into the server.

{  "mcpServers": {    "stocklayer": {      "command": "npx",      "args": ["-y", "@stocklayer/mcp"],      "env": {        "STOCKLAYER_PROJECT_KEY": "stocklayer_test_..."      }    }  }}

Usage and diagnostics are built into every request.

API access is free during public launch. A successful new quote, trade plan, or simulation uses one checked-action unit. Reads, stored-plan lookups, idempotent replays, and failed requests use zero units. A blocked plan is a completed checked action and uses one unit. The dashboard shows your project allowance.

Every authenticated call counts toward the organization ceiling of 10,000 requests per UTC month. Minute limits apply to reads and checked actions. Follow the response limit headers and Retry-After when a request is throttled.

Authenticated responses identify the resolved environment and plan, plus minute and monthly allowance headers. The dashboard separates test and live usage, searches recent requests by ID, route, status, key prefix, error, symbol, or wallet, and exports daily usage as CSV.

Errors are designed for software.

Every failure includes a stable code, plain-language message, retryability signal, details, and request ID. Branch on the error code, never the prose.