DOCS

Account & Execution API

Query your account positions and place futures orders over a simple API on your own Rithmic broker account.

Overview

The Account & Execution API lets you query your account state and place and manage futures orders over a dead-simple HTTP API, routed to your own Rithmic broker account (prop firms and retail alike). You bring your Rithmic credentials; tickstream is the thin, fast account & execution layer on top.

• Query every position on your linked accounts — quantity, average open price, open/closed PnL, balances.
• Pull your trade history — every fill, as data, ready for your own analysis. Works for any linked account, independent of the algos.
• Order placement — market entry with a stop and target that rest at the broker as one native OCO pair, move or cancel that bracket, flatten; see placing orders.
• Futures only. Your account, your risk.

requiresAccount & Execution API or above

A standalone package, separate from the data ones, and also included in the Terminal plan, the legacy all-in-one plan, the Desk bundle and every-sleeve algo access. Prices on the pricing page.

Your positions

One call returns every Rithmic account linked to your API key, each with its latest position snapshot: net quantity per symbol, average open fill price, open and closed PnL, and account-level balances. A session is maintained automatically for every account you link — no algo activation required — and snapshots refresh about once a minute.

curl https://api.tick-stream.xyz/v1/exec/positions \
  -H "Authorization: Bearer sk_live_…"

{
  "accounts": [
    {
      "accountId": "acct_9f2c…",
      "updatedAt": 1751712000000,
      "account": {
        "name": "PAPER-12345",
        "metrics": { "accountBalance": 52140.50, "openPnl": 185.00, "closedPnl": -40.00 }
      },
      "positions": [
        {
          "symbol": "NQU6", "exchange": "CME",
          "qty": 2, "avgOpenPrice": 20010.25,
          "openPnl": 185.00, "closedPnl": -40.00
        }
      ]
    }
  ]
}

positions contains open positions (net quantity ≠ 0). updatedAt is the snapshot time in ms; if your session is disconnected the snapshot is the last known state.

Your trade history

Every fill on your linked accounts, as raw data — analyze your own trading however you like: win rates, per-symbol PnL, time-of-day breakdowns, slippage vs. our tick history. This works for any account you link in the dashboard, whether or not an algo trades it. History accumulates from the moment your account is linked (plus whatever your broker's order plant returns on connect) and survives restarts.

curl "https://api.tick-stream.xyz/v1/exec/fills?start=1751000000&symbol=NQU6" \
  -H "Authorization: Bearer sk_live_…"

Query: ?account=, ?symbol=, ?start=/?end= (epoch seconds), ?limit= (default 5000, most recent kept). Fills are returned oldest-first.

{
  "metrics": { "count": 142, "buyQty": 96, "sellQty": 96 },
  "fills": [
    {
      "accountId": "acct_9f2c…", "id": "20260705-1834",
      "ts": 1751713433, "tradeDate": "20260705",
      "symbol": "NQU6", "side": "buy",
      "qty": 2, "price": 20008.75,
      "orderNum": "233442211", "orderType": "MKT"
    }
  ]
}

Your orders

Every order you place through the Account & Execution API is tracked against the API key that placed it. List them — each one accepted or rejected — and watch them live in your dashboard.

curl "https://api.tick-stream.xyz/v1/exec/orders?status=rejected&symbol=MNQ&start=1789500000" \
  -H "Authorization: Bearer sk_live_…"

The journal records every order, bracket change and flatten that reaches your broker session — whether it came through this API, the terminal's trade panel, or a terminal script — together with what the broker answered. Fills are the record of what actually traded; the journal is the record of what was asked for.

Query: ?status=accepted|rejected|all (default all), ?account=, ?symbol= (a root like MNQ matches its contracts), ?start=/?end= (epoch seconds), ?limit= (default 1000, newest first). The journal keeps your newest 5,000 entries.

{
  "orders": [
    {
      "id": "j1789557328114-3f2a", "kind": "order", "source": "terminal",
      "account": "APEX-459021-05", "symbol": "MNQZ6", "side": "buy", "qty": 1,
      "orderType": "market", "stop": 29320.25, "target": 29410.25,
      "status": "accepted", "error": null, "submittedAt": 1789557328114
    }
  ]
}

Placing orders

Three write endpoints, all POST with a JSON body and your API key. They route to your own Rithmic account — the same path our GEX terminal's trade panel and our live algo sleeves use. A bare root (MNQ) resolves to the front contract; an explicit contract (MNQU6) is passed through. Prices must sit on the tick grid of the contract.

Several Rithmic accounts linked? Name the one to trade with "account": "<accountId>" (ids are in positions); with one account linked it is optional.

Entry with a resting bracket

curl -X POST https://api.tick-stream.xyz/v1/exec/order \
  -H "Authorization: Bearer sk_live_…" -H "Content-Type: application/json" \
  -d '{"symbol": "MNQ", "side": "buy", "qty": 1, "stop": 23380.00, "target": 23440.00}'

import requests
H = {"Authorization": "Bearer sk_live_…"}
r = requests.post("https://api.tick-stream.xyz/v1/exec/order", headers=H, json={
    "symbol": "MNQ", "side": "buy", "qty": 1,
    "stop": 23380.00, "target": 23440.00,
}).json()

{ "ok": true, "orderId": "233442211" }

ok and orderId cover the entry only. To confirm the bracket, look for the protect entry that follows it in /v1/exec/orders, or call /v1/exec/protect with the same levels.

Move the stop or target

Re-send both levels whenever one changes. The response tells you how many orders rest now, how many were replaced, and the position size they cover — qty: 0 means you are flat, so a filled stop or target shows up here on the next call.

curl -X POST https://api.tick-stream.xyz/v1/exec/protect \
  -H "Authorization: Bearer sk_live_…" -H "Content-Type: application/json" \
  -d '{"symbol": "MNQ", "stop": 23395.00, "target": 23440.00}'

while True:
    time.sleep(60)
    px = requests.get("https://api.tick-stream.xyz/v1/quote", params={"symbol": "MNQ"}, headers=H).json()["price"]
    stop = max(stop, round(round((px - 15) / 0.25) * 0.25, 2))   # only ever tighter, on the tick grid
    r = requests.post("https://api.tick-stream.xyz/v1/exec/protect", headers=H,
                      json={"symbol": "MNQ", "stop": stop, "target": target}).json()
    if r["qty"] == 0: break   # one side filled, the exchange cancelled the other

{
  "ok": true, "placed": 2, "cancelled": 2, "qty": 1,
  "stop": 23395.00, "target": 23440.00, "side": "S"
}

Flatten

curl -X POST https://api.tick-stream.xyz/v1/exec/close \
  -H "Authorization: Bearer sk_live_…" -H "Content-Type: application/json" \
  -d '{"symbol": "MNQ"}'

Errors

Every write answers HTTP 409 with {"ok": false, "error": "…"} when the broker refuses (a failed protect also reports protectedQty and unprotected), and one of these codes before anything reaches the broker:

Endpoints & status

Accounts are linked in the dashboard; the read endpoints work from that moment, no algo activation required. Limit orders and cancelling a single order by id are not exposed — the bracket is the one resting order type, and protect with no prices cancels it. Background on Rithmic's own interfaces and why this layer exists: the Rithmic API problem.

Your Rithmic credentials are used only to route your own orders and are never shared. See the broader safety model in our rollout notes — demo-first, per-user isolation, kill-switch.