Tradovate API Bracket (OSO/OCO) Orders Fail

Your automation fires a Tradovate API bracket order, the entry fills on ES or NQ, and then… nothing. No stop-loss, no take-profit. You're now one bad tick away from an uncapped position, and your log says the order “sent fine.” That's the trap. In 2026 the classic failure isn't a red error screen, it's a 200 OK HTTP status hiding a failureReason and failureText in the body, or an orderStrategy call that comes back as a bare 404. The variants you'll hit most: a 404 (undocumented) from startOrderStrategy, an Invalid JSON parse error, a Wrong OCO combination reject, and the nastiest one, a silent half-fill where only the entry survives. Here's what each error actually means, how to fix the endpoint and field problems behind them, and how PickMyTrade keeps an unprotected fill from ever reaching your account.

What “Wrong OCO Combination” and the 404 Errors Mean

Tradovate gives you several ways to submit protected orders, and each one fails in its own way. A bracket is an entry order plus two child legs, a protective stop and a profit target, where filling or cancelling one child cancels the other. On the REST API you build that with order/placeOSO (One-Sends-Other): a parent order carries bracket1 and bracket2 objects that only wake up after the parent fills. order/placeOCO (One-Cancels-Other) links two orders so a fill on one cancels the other, handy for bolting a stop and target onto a position you already hold.

The confusing part: these endpoints happily return 200 OK while still rejecting the order. Tradovate reports business-logic failures inside the response body, not in the HTTP status. So a payload that reaches the server cleanly can still come back with {"failureReason": "InvalidPrice", "failureText": "Wrong OCO combination"}, meaning the price levels or order-type pairing you chose aren't a legal OCO. A stop and a limit sitting on the wrong side of the market will do it. Treat any body containing failureReason as a rejection, full stop, no matter what the status line says.

The orderStrategy/startOrderStrategy endpoint is a different animal. It runs a server-side bracket strategy, the API equivalent of an ATM strategy, and it's far pickier about its payload. Send the wrong orderStrategyTypeId, or call it over plain REST when it wants a WebSocket frame, and you get an unhelpful 404 (undocumented). It looks like a missing route, but it's really a rejected request.

Top Causes of Tradovate API Bracket Orders Failing

1. You only checked the HTTP status, not the body

This is the number-one trap. Your client sees 200 OK, logs “order sent,” and walks away, but the entry was rejected, or only the parent order made it through. Parse every OSO/OCO response for failureReason and failureText before you call the bracket live.

2. Wrong orderStrategyTypeId on startOrderStrategy

A lot of people try orderStrategyTypeId: 1 and get a 404 (undocumented) for their trouble. There's only one valid value, and it's 2. Anything else is rejected before the strategy is ever built.

3. Calling startOrderStrategy over REST instead of WebSocket

Even with the right type id, this endpoint is unreliable over plain HTTP REST. It's built to run over a WebSocket, and it works reliably when you drive it that way. A REST call that keeps 404-ing will often succeed, unchanged, the moment you send it as a WebSocket frame.

4. Malformed JSON or a raw dict instead of a JSON body

A common placeOCO failure is Invalid JSON: expected '{', offset: 0x00000075. That happens when the request ships a form-encoded dictionary instead of a serialized JSON string, in Python, passing data=payload instead of json=payload (or forgetting json.dumps()). The server never sees valid JSON, so it throws out the whole bracket.

5. Missing accountSpec, wrong accountId, or an illegal price combination

Bracket endpoints want both the numeric accountId (pulled from account/list) and the string accountSpec (your account name). Drop either one and you're looking at Access is denied. Separately, placeOCO and placeOSO check that the two legs form a legal combination, a stop and limit priced on the wrong side of the market come back as Wrong OCO combination. Market-entry brackets add one more wrinkle: because the API needs concrete price levels for the child legs, you generally can't attach tick-relative TP/SL to a plain Market entry through placeOSO. You either compute the price levels yourself, or let the strategy engine handle the offsets.

How to Fix Tradovate API Bracket Orders: Step-by-Step

Fixing the “200 OK but no legs” trap

• After every placeOSO / placeOCO / startOrderStrategy call, parse the JSON body.
• Check for a failureReason key. If it's there, treat the order as rejected and read failureText for the cause.
• Only mark the bracket live once you've got confirmed order IDs for the parent and both child legs, poll order/list or subscribe to order events over WebSocket.
• Log the full body, not the status code, so half-fills show up in your audit trail.

Fixing startOrderStrategy 404s

• Set orderStrategyTypeId to 2, the only value it accepts.
• Send both accountId and accountSpec, plus symbol, action, and the params object (with your entryVersion and brackets).
• Submit the request as a WebSocket frame rather than a REST POST. This endpoint is designed to run over the WebSocket, and the frame format it expects is well documented.
• Retry the identical payload over the socket before you assume your JSON is broken, the 404 is usually transport, not schema.

Fixing Invalid JSON and Wrong OCO combination

• Serialize the payload as JSON. In Python requests, use requests.post(url, headers=..., json=payload), never data=payload with a dict.
• Confirm the Content-Type: application/json header is set.
• For placeOCO, check the geometry of the two legs: the stop and the limit have to sit on opposite, valid sides of the current price for the position's direction. If you see Wrong OCO combination, swap the leg that's on the wrong side.
• For a Market entry, either wait for the fill and attach a placeOCO stop/target to the resulting position, or switch to startOrderStrategy, which accepts relative offsets.

The reliable fallback: separate entry + OCO

When a native bracket just won't cooperate, decouple the entry from the exits. Place the entry order on its own with order/placeOrder, confirm the fill, then submit a placeOCO that pairs the protective stop with the profit target against the now-open position. It's one extra round trip, but it sidesteps the strategy endpoint entirely and gives you explicit control over each leg.

Troubleshooting Table

Prevent This with PickMyTrade

Hand-rolling OSO/OCO payloads means you own every one of the failure modes above. PickMyTrade sits between your TradingView alerts and Tradovate and handles the bracket plumbing for you:

• Bracket & OCO Handling, attaches stop-loss and take-profit legs correctly, so an entry never lands unprotected.
• Response Validation, inspects the full order response, not just the HTTP status, and surfaces real rejections instead of a false “success.”
• Entitlement & Risk Filters, respects your account's data-agreement state and prop-firm limits before an order is routed.
• Rate-Limit-Safe Routing, spaces out order flow so bracket legs don't bounce off request caps.
• Multi-Account Sync, mirrors the same protected bracket across every connected account.