Build on Epsilon

Epsilon is a trading platform on Robinhood Chain with advanced order types (limit, stop loss, DCA, trailing stop) for memecoins and RWAs. The developer platform gives you a keyed REST API — quotes, smart order routing, order placement, and market data — plus MCP servers so AI agents in Cursor, Claude, and any MCP client can trade programmatically.

Quickstart

1 — Get an API key. Keys are issued per Epsilon account. During early access, keys are concierge-issued — ask in the community or DM @TradeEpsilon. (Self-serve issuance with your Privy login lands with the developer dashboard.) Keys look like eps_… and are shown once at creation.

2 — First call: quote a swap. Amounts are raw token units (scaled by the token's decimals):

curl "https://api.epsilon.exchange/v1/route?tokenIn=0x…&tokenOut=0x…&amountIn=1500000000000000000&slippagePpm=10000&orderType=limit" \
  -H "X-API-Key: eps_YOUR_KEY"

The response contains the best route, expected and minimum output, price impact in ppm, and the feeLegs that a signed order must embed. Fees are priced per order kind × token class, so orderType must match what you'll submit (limit, stop_loss, take_profit, dca, trailing; add triggered=1 for a price-gated DCA) — omit it and you get the direct-swap cell, which an order submit will reject.

3 — Explore the surface. Everything lives under /v1 and is documented in the interactive API reference:

Authentication

Every keyed endpoint accepts the key in either header form:

X-API-Key: eps_YOUR_KEY
# or
Authorization: Bearer eps_YOUR_KEY

Keys are secrets: server-side only, never in browser code or repos. A leaked key can be disabled instantly and reissued — rotation is free.

Rate limits

Limits are per key (not per IP) over a sliding minute, in three buckets, driven by the key's tier:

Every response carries X-RateLimit-Limit and X-RateLimit-Remaining; a 429 includes Retry-After. Order submission additionally has per-maker-wallet limits. Enterprise limits are per contract — contact us.

Rev-share (permissionless)

Routing other people's orders through Epsilon? Add &referrer=0xYOUR_ADDRESS to GET /v1/route and the served feeLegs.referrer becomes your payout address. The maker signs those fee legs into the order, and the referral leg of every fill is paid to your address on-chain by the router — no application, no minimums, earning from your first fill. The fee ppm is policy-set server-side: you choose where the referral leg goes, never how big it is, so your users pay exactly what they'd pay anyway. Both SDKs pass it through (fetchOrderRoute({ …, referrer }) / order_route(…, referrer=…)), and the MCP server takes an EPSILON_REFERRER env var. The builder tier (application in the dashboard) is only about the 5× rate limits in the table above — earnings need no tier.

Not to be confused with the in-app user referral program (invites, ranks, points): that pays for bringing users and requires an Epsilon account; rev-share pays for routing orders and needs only an address. On a routed fill the referral leg goes to the flow-router named in the fee legs, and the maker always pays their own policy rate — a third-party frontend can never change what the user pays.

Amounts & prices

• Tokens are addresses. Resolve symbols with GET /v1/tokens?search=USDG — returns address, decimals, and 30-day volume (the disambiguator when symbols collide).
• Amounts are raw token units — decimal strings already scaled by the token's decimals. 1.5 WETH (18 decimals) is "1500000000000000000".
• Slippage is ppm (parts per million) in /v1 params: basis points × 100. 1% = 100 bps = 10000 ppm.
• Trigger prices are the price of 1 tokenIn expressed in tokenOut, scaled to tokenOut's decimals. 0 means execute at market (DCA legs).
• Chain: Robinhood Chain, id 4663. Live contract addresses at /v1/config.

Signed orders

Epsilon is non-custodial: an order is an EIP-712 message signed by the maker's wallet (domain EpsilonRouter v7, chain 4663), executed on-chain by keepers when the trigger condition is met. Funds stay in the maker's wallet until fill. The API key on POST /v1/orders is attribution and rate limiting — authorization is the signature itself.

Integration paths, most to least batteries-included:

• Local MCP package (@epsilon-exchange/mcp) — signs and submits for you; the private key never leaves your machine. Recommended for AI agents. See the MCP guide.
• SDKs — @epsilon-exchange/sdk (TypeScript) and epsilon-exchange (Python): a thin /v1 client plus local EIP-712 order signing. One signing implementation, cross-verified against the on-chain verifier in three languages.
• CLI — npx @epsilon-exchange/cli: the SDK as shell commands (quote, order, cancel, orders, portfolio, approve, tokens). Symbols resolve to addresses, amounts are human units, orders confirm on a terminal (--yes for cron), --json everywhere. Same env vars as the MCP server (EPSILON_API_KEY, EPSILON_WALLET_KEY, EPSILON_REFERRER, EPSILON_MAX_ORDER_USD).
• Raw HTTP — build and sign the order struct yourself, then POST /v1/orders. The full schema, maker-traits bit layout, and fee-leg rules are in the API reference. Fee fields must exactly match the feeLegs served by GET /v1/route for the same wallet and the same orderType — fees are per order-kind × token-class cell.

Cancelling a pending order is also signed: EIP-712 OrderCancel(bytes32 orderHash) by the maker, sent with DELETE /v1/orders/{hash}.

Webhooks

Stop polling GET /v1/orders — register an HTTPS endpoint on the dashboard and Epsilon POSTs you the order-lifecycle events of your linked wallets: order.filled, order.cancelled, order.expired, order.failed, stop.triggered, dca.completed, dca.stalled. Up to 3 endpoints per account; each can subscribe to all triggers or a subset.

POST https://your-app.com/webhooks/epsilon
Content-Type: application/json
X-Epsilon-Event: order.filled
X-Epsilon-Delivery: 6f1c…        <- unique event id: dedupe on this
X-Epsilon-Signature: t=1756350000,v1=hex(HMAC-SHA256(secret, t + "." + body))

{ "id": "6f1c…", "trigger": "order.filled", "createdAt": "…",
  "data": { "orderType": "limit", "pair": "WETH/USDG", "amountIn": "…",
            "amountOut": "…", "txHash": "0x…", "orderHash": "0x…" } }

Verify every delivery: recompute HMAC-SHA256(secret, t + "." + rawBody) and compare to v1 (constant-time), reject t older than ~5 minutes. Delivery is at-least-once with exponential retries for about a day — respond 2xx fast and process async; dedupe on X-Epsilon-Delivery. Endpoints that keep failing are auto-disabled (re-enable by re-creating). Test any endpoint with the dashboard's Test button before going live.

Errors

Errors are JSON with a stable machine-readable code:

{ "error": "human-readable message", "code": "MACHINE_CODE" }

The complete, always-current catalog with retry guidance is served live at GET /v1/errors (no key required).

Changelog

Developer-facing changes. Product releases are on the epsilon.exchange changelog (RSS).