Execution API

The Execution API lets any app route its users' Hyperliquid orders through Borsa's execution engine. You send an intent: what to buy and sell, how much, the worst price you accept and a deadline. Borsa works it on the user's own Hyperliquid account and reports every fill back to you.

Use it when sending one taker order per leg isn't good enough:

• Chase: rest a post-only order at the best bid or ask and follow the book, so fills are maker fills instead of crossing the spread.
• TWAP: spread a large order over minutes or days, each slice taker or chase.
• Multi-leg balance: a pair or basket (up to 4 legs) where no leg runs ahead of the others by more than a tolerance you set, and a leg left behind is pulled level with a taker order.
• Price protection: every leg has a hard worst price (slippage bound and/or limit price). Nothing fills beyond it.

Orders are placed on the user's own account through an agent the user approves. Borsa never holds funds and can't withdraw: Hyperliquid agents can only trade.

How It Works

1. Borsa gives you an API key.
2. Each user approves, inside your app, three things once (see Onboarding a User): the Borsa execution agent, the Borsa builder fee, and a signed delegation that lets your app send intents for them.
3. You POST /intents. Borsa validates it, records the arrival price of every leg and starts working it.
4. You follow progress with GET /intents/{id}, the event stream, or both.

Base URL: https://app.borsa.cc/api/exec/v1

Every request carries your key:

Authorization: Bearer bx_<yourid>_<secret>

Keep the key on your server. Requests are limited to 20 per second per key.

Onboarding a User

Call GET /users/{address} to see what a user still needs:

{
  "user": "0x6858…41ea",
  "ready": false,
  "agent": { "address": "0x4a9a…44c8", "name": "Borsa Cloud", "approved": false, "validUntil": null },
  "builder": { "address": "0x74c3…4bd0", "maxFeeRate": "0.025%", "approved": true, "feeBps": 25 },
  "delegation": { "active": false, "expiresAt": null }
}

ready is true once all three are in place. Add ?fresh=1 right after the user signs something (answers are cached for 30 seconds).

1. Approve the agent

The user signs Hyperliquid's approveAgent action with their main wallet, using agent.address and agent.name exactly as returned. Every user has their own agent address. With the Hyperliquid SDK (@nktkas/hyperliquid):

await exchange.approveAgent({ agentAddress: status.agent.address, agentName: status.agent.name });

Users who already run Borsa Cloud strategies have this agent approved and skip this step. Hyperliquid allows a few named agents per account; approving a new name when they are all taken replaces one of the user's existing agents, so tell the user which name they are approving.

2. Approve the builder fee

Orders carry Borsa's builder code. The user signs approveBuilderFee with builder.address and builder.maxFeeRate:

await exchange.approveBuilderFee({ builder: status.builder.address, maxFeeRate: status.builder.maxFeeRate });

3. Sign the delegation

The delegation is an EIP-712 message that lets your app, and only your app, send intents for the user. Get the exact payload, ask the user to sign it with their main wallet, and post the signature:

GET /delegations/typed-data?user=0x…&expiresAt=<ms>&nonce=<n>&chainId=<wallet chain id>

{
  "domain": { "name": "Borsa Execution", "version": "1", "chainId": 42161 },
  "types": {
    "Delegation": [
      { "name": "user", "type": "address" },
      { "name": "integrator", "type": "string" },
      { "name": "expiresAt", "type": "uint64" },
      { "name": "nonce", "type": "uint64" }
    ]
  },
  "primaryType": "Delegation",
  "message": { "user": "0x…", "integrator": "yourid", "expiresAt": "1799999999999", "nonce": "1" }
}

POST /delegations
{ "user": "0x…", "expiresAt": 1799999999999, "nonce": 1, "chainId": 42161, "signature": "0x…" }

• expiresAt is a Unix time in milliseconds, at most 366 days ahead.
• nonce must be higher than the user's previous delegation to you (a timestamp works). A new delegation replaces the old one.
• chainId is whatever chain the user's wallet is on; it only has to match what was signed.
• DELETE /delegations/{address} revokes it and cancels the user's working intents.

Sending an Intent

POST /intents

{
  "user": "0x6858c42ceb3596b256ca0f547c76e2ad178a41ea",
  "clientId": "order-7781",
  "algo": "chase",
  "legs": [
    { "coin": "BTC", "side": "buy", "notionalUsd": "5000" },
    { "coin": "ETH", "side": "sell", "notionalUsd": "5000" }
  ],
  "maxSlippageBps": 30,
  "durationSec": 300,
  "onDeadline": "market",
  "maxImbalancePct": 20
}

The response is the intent (status 201, see The Intent Object). Posting the same clientId again returns the existing intent with status 200, so retries are safe.

Legs

Each leg must be worth at least 10 USD (Hyperliquid's minimum order). One coin per leg, up to 4 legs.

Parameters

Algorithms

market: every leg is sent at once as an immediate-or-cancel order priced at its worst price, so it takes whatever liquidity is inside the bound. Anything the book can't fill inside the bound is retried every couple of seconds until durationSec.

chase: each leg rests a post-only order at the best bid (buy) or best ask (sell). When the touch moves, the order is cancelled and reposted at the new touch, at most every repostMs. It never posts beyond the worst price: if the touch moves past it, the leg waits. Fills are maker fills.

twap: the size is released in slices equal steps over durationSec. Each released step is worked as a chase or market order. A slice that isn't done when the next one is released carries over. With onDeadline: "market" (the default) whatever is left at the end is taken.

Keeping Legs Balanced

With two or more legs, each leg's working order is capped so that its progress (filled as a share of its size) stays within maxImbalancePct of the slowest leg. With the default 20%, a pair starts by resting 20% of each leg; once the slower leg catches up, the next 20% is released.

If one leg fills and the other doesn't, the leader stops and waits. After catchUpAfterSec the laggard crosses the spread for exactly the amount needed to bring it level (catchUp: "taker"). A smaller maxImbalancePct means tighter balance and more, smaller orders.

Market legs are sent together, so they don't need the cap.

The Intent Object

{
  "id": "0b3f…",
  "clientId": "order-7781",
  "user": "0x6858…41ea",
  "status": "working",
  "error": null,
  "algo": "chase",
  "params": { "maxSlippageBps": 30, "durationSec": 300, "onDeadline": "market", "maxImbalancePct": 20, "…": "…" },
  "builderFeeBps": 25,
  "createdAt": 1791969952467,
  "deadline": 1791970252467,
  "endedAt": null,
  "legs": [
    {
      "coin": "BTC", "side": "buy",
      "targetSize": "0.06", "filledSize": "0.012", "filledNotionalUsd": "997.21",
      "avgPx": 83101, "arrivalMid": 83105.5, "worstPx": 83354.8, "slippageBps": -0.54,
      "working": { "px": "83101", "size": "0.012" },
      "done": false
    }
  ]
}

slippageBps is the fill price against the leg's arrival mid: positive is worse, negative is better. builderFeeBps is in tenths of a basis point (25 = 0.025%).

Endpoints

Events

Every change is an event with an increasing id, kept for 7 days:

GET /events/stream replays everything after ?after= (or the Last-Event-ID header, which EventSource sends on reconnect) and then streams new events. Store the last id you processed and you never miss or double count one. A comment line is sent every 15 seconds to keep the connection open.

id: 412
event: intent.fill
data: {"id":412,"type":"intent.fill","intentId":"0b3f…","ts":1791969955000,"data":{"leg":0,"coin":"BTC","side":"buy","size":"0.012","px":83101,"liquidity":"maker","oid":4012…}}

Errors

Errors are JSON: { "error": "<code>", "detail": … }.

Fees

Orders pay Hyperliquid's normal trading fees plus Borsa's builder fee, the same as trading on Borsa: 0.025%, or 0.01% on HIP-3 markets (0.01% everywhere for accounts that approved Borsa's builder fee before October 14, 2026). Borsa's volume and brsHYPE staking fee reductions don't apply to API orders. Integrators earn an agreed share of the builder fees their users generate; GET /revenue shows the running total.

Example: Pair Trading

A pair trade is two legs with opposite sides. Long SOL against ETH, 2,000 USD each, worked passively for up to 10 minutes and finished with takers if needed:

curl -X POST https://app.borsa.cc/api/exec/v1/intents \
  -H "Authorization: Bearer $BORSA_KEY" -H "content-type: application/json" \
  -d '{
    "user": "0x6858c42ceb3596b256ca0f547c76e2ad178a41ea",
    "clientId": "pair-sol-eth-0193",
    "algo": "chase",
    "durationSec": 600,
    "onDeadline": "market",
    "maxSlippageBps": 40,
    "maxImbalancePct": 15,
    "legs": [
      { "coin": "SOL", "side": "buy",  "notionalUsd": "2000" },
      { "coin": "ETH", "side": "sell", "notionalUsd": "2000" }
    ]
  }'

Closing the pair is the same intent with the sides swapped and "reduceOnly": true on both legs. For a large pair, "algo": "twap" with "durationSec": 3600 spreads it over an hour while keeping the legs within 15% of each other the whole way.

Getting Access

Ask the Borsa team for an API key. Tell us the name to show users and where you'd like revenue share paid.