> ## Documentation Index
> Fetch the complete documentation index at: https://docs.updown.fast/llms.txt
> Use this file to discover all available pages before exploring further.

# Boost orders

> Place, track and sell Boost orders with a trade key: one order that pays more the further the price closes your way.

A Boost order is one order on the window that's open now. It pays more the further the price closes your way. It's the same order the website and the app place: the same server prices it, and the same limits and settlement apply. Placing and selling need an API key with the **Trade** permission; reading needs **Read**. See [Authentication](https://docs.updown.fast/api/authentication.md).

> [!WARNING]
>
> Boost orders are **real money**. The stake is paid from your account's cash the moment the order is placed. Orders placed through the API never use trade credit.

## What a Boost is

A Boost has two parts:

* **The bet**: the regular Up / Down contract, bought on the order book at the current ask. It buys as many contracts as your stake in dollars, so a right call pays your whole stake back. It pays the normal taker fee, like any order on the book.
* **The ride**: one **option leg** bought with the rest of the stake. It's a call spread on Up and a put spread on Down, struck at the live price when the order is placed. It pays a fixed amount for every \$1 the asset closes past that strike, up to a ceiling set so the whole Boost pays at most **100× your stake**.

For example, a \$10 Boost on Up when Up's ask is 65¢:

* The bet buys 10 contracts on the order book at 65¢, plus the taker fee of about 1.6¢ each. That's $6.66 in all, and any close at or above the price to beat pays $10.
* The other $3.34 buys the ride, which adds to the payout for every $1 the asset closes above its strike.

The option leg has no order book. It's quoted on request (RFQ) when you place the order, priced for your order at that moment from the live price and the move expected in the time left.

### Two records

Once placed, a Boost is two records on your account:

| | What it is | Where to see it |
| - | - | - |
| The bet | An ordinary position in that market, settled and sold like any other. | [`GET /portfolio/positions`](https://docs.updown.fast/api-reference/get-positions), and the Boost order's `bet` field |
| The ride | The Boost order itself. | [`GET /portfolio/boosts`](https://docs.updown.fast/api-reference/list-boosts) |

On a Boost order, `stake`, `max_payout`, `value`, `sell_proceeds` and `payout` are **the ride's**. The whole Boost cost `stake` + `bet.cost`, and `multiplier` is `max_payout` ÷ `stake`.

### Partial fills and no sellers

* **Partial fill.** If the order book can't sell you the full number of contracts at the price you were shown, the bet takes what it can. The rest of the stake goes into the ride, and `bet.contracts` says how many filled.
* **No sellers.** If nothing is for sale at that price, nothing is bought and the order is refused with `400 ORDER_REJECTED`. Try again in a moment.

## Where and when

* **Which markets.** Boost is offered on the markets your account has it on. Anywhere else, an order answers `403 BOOST_UNAVAILABLE`.
* **The current window only.** `market_ticker` must name the window that's open now; find it with [`GET /markets?status=open`](https://docs.updown.fast/api-reference/list-markets). Any other window answers `400 MARKET_NOT_OPEN`.
* **Not in the last minute.** That answers `400 MARKET_NOT_OPEN`. Otherwise Boost is open whenever the market is: there are no paused hours.
* **Live keys only.** There is no practice Boost: a test key's order answers `403 BOOST_UNAVAILABLE`, and its list is always empty.
* **Check `mode`.** `live` is real money. `shadow` means the market isn't open to real money for your account yet: the order is recorded, but no money moved and nothing was bought on the order book.

## Place a Boost

```bash theme={null}
curl -X POST https://api.updown.fast/trade-api/v1/portfolio/boosts \
  -H "Authorization: Bearer $UPDOWN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "market_ticker": "btc-15m-261102-1600-1615",
    "outcome": "up",
    "stake": "10",
    "expected_price": "0.65",
    "client_order_id": "boost-000123"
  }'
```

```json 201 Created theme={null}
{
  "boost": {
    "boost_id": "6f1c2a8e-3b4d-4e5f-9a1b-2c3d4e5f6a7b",
    "client_order_id": "boost-000123",
    "market_ticker": "btc-15m-261102-1600-1615",
    "outcome": "up",
    "kind": "boost",
    "mode": "live",
    "status": "open",
    "stake": "3.34",
    "multiplier": "296.41",
    "max_payout": "990.00",
    "price_to_beat": "110350.25",
    "value": "3.31",
    "sell_proceeds": "3.12",
    "created_ts_ms": 1793635262114,
    "close_ts_ms": 1793636100000,
    "bet": {
      "order_id": "btc-15m/o13067395",
      "contracts": "10.00",
      "cost": "6.66"
    }
  }
}
```

Here the whole Boost cost $10.00 ($3.34 + $6.66) and pays up to $1,000 ($990 from the ride + $10 from the bet).

| Field | |
| - | - |
| `market_ticker` | The window that's open now. |
| `outcome` | `up` or `down`. |
| `stake` | Dollars as a string, up to two decimals. **$1 to $100**, and no more than your key's max order. This is the whole Boost: bet and ride together. |
| `expected_price` | Optional. The contract price you priced on. The order is refused (`400 ORDER_REJECTED`) if the part of your stake that rides comes out more than 10% smaller than at this price, taker fee included. |
| `expected_max_payout` | Optional. The order is refused (`400 ORDER_REJECTED`) if its max payout comes out more than 10% below this, because the price moved. |
| `client_order_id` | **Required.** Your id for the order; see below. |

The response is the order after it's placed, usually `open`. It reads `pending` while the stake is still being taken.

## Retrying safely with `client_order_id`

The rules are the same as for [orders](https://docs.updown.fast/api/orders.md#retrying-safely-with-client_order_id):

* **Same id, same order** → you get back the order already placed. Never a second one.
* **Same id, different order** → `409 IDEMPOTENCY_CONFLICT`.

When a request times out or answers `503 EXCHANGE_UNAVAILABLE`, resend it with the **same** `client_order_id`, or look it up with [`GET /portfolio/boosts?client_order_id=…`](https://docs.updown.fast/api-reference/list-boosts). Never retry with a new id: if the first request went through, a new id places a second order.

A `failed` order with no `bet` gives its id back: nothing moved, so to try again, send the same order with the same `client_order_id`. A `failed` order **with** a `bet` keeps its id: the bet was bought and is a position on your account, and resending the same id returns that order rather than buying again.

Ids are 1 to 64 characters (letters, digits, `.` `_` `:` `-`) and unique per account. Boost orders and book orders keep separate ids, so the same id can be used once on each.

## Order status

| `status` | Meaning |
| - | - |
| `pending` | The stake is being taken. |
| `open` | Live until the window closes. It can be sold early. |
| `selling` | Your sale is being paid. |
| `sold` | Sold back early. `payout` is what the sale paid. |
| `settling` | The window closed and the payout is being sent. |
| `settled` | Paid out, or lost. `payout` is what it paid (`0.00` on a loss). |
| `void` | Refunded: the window's result couldn't be read. |
| `failed` | The ride's stake was never taken. If there's a `bet`, it was bought and stays a position. |

## Track your orders

| Endpoint | Returns |
| - | - |
| [`GET /portfolio/boosts`](https://docs.updown.fast/api-reference/list-boosts) | Your Boost orders, newest first, including ones placed on the website or in the app (those have no `client_order_id`). Filter by `market_ticker`, `client_order_id` or `status`; `limit` 1 to 100, default 50. |
| [`GET /portfolio/boosts/{boost_id}`](https://docs.updown.fast/api-reference/get-boost) | One order. |

While an order is open, `value` is what the ride is worth at the current price and `sell_proceeds` is what selling it right now pays. Each is left out when it can't be worked out. After the close, `close_price` is the settlement price (or the price it was sold at) and `payout` is what the ride paid. The bet settles on its own, like any position.

There's no websocket channel for Boost orders yet, so poll these endpoints.

`credit_used` and `paid` show only on orders placed on the website or in the app with trade credit. There, `paid` is what reached the wallet: the payout less the credit.

Orders placed on the website before Boost replaced the leverage slider may read `kind: "multiplier"`. Every new order is `kind: "boost"`.

## Sell early

```bash theme={null}
curl -X POST https://api.updown.fast/trade-api/v1/portfolio/boosts/6f1c2a8e-3b4d-4e5f-9a1b-2c3d4e5f6a7b/sell \
  -H "Authorization: Bearer $UPDOWN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "expected_proceeds": "3.12" }'
```

The ride is sold back for its current `sell_proceeds`, paid to your cash, and the response shows it `sold`.

* **This sells the ride only.** The bet is an ordinary position: sell it on the order book like any other (see [Order entry](https://docs.updown.fast/api/orders.md)), or hold it to the close.
* `sell_proceeds` is **below** `value`, so buying and selling straight back costs money.
* `expected_proceeds` is optional. With it, the sale is refused (`400 ORDER_REJECTED`) if it would pay more than 10% less.
* Only an `open` order can be sold, and not in the window's last minute.
* A key limited to some series can only sell Boost orders on those, including ones placed on the website or in the app.
* A sale has no `client_order_id`. If it answers `503 EXCHANGE_UNAVAILABLE`, get the order before trying again: `selling` or `sold` means it went through.

## At the close

Open orders settle automatically on the window's result: `settling`, then `settled`, with the ride's payout sent to your cash. The bet settles like any position in that market. If the result still can't be read 6 hours after the close, the ride's stake is refunded and the order reads `void`.

## Limits

The tightest of these wins:

1. **Your key's limits.** The key's max order applies to the whole stake: trade keys start at **\$20 per order**, so raise the key's max order to stake more. The key's daily limit counts its Boosts of the last 24 hours, bet and ride, alongside its book fills and resting buys; [`GET /account`](https://docs.updown.fast/api-reference/get-account) shows them together as `daily_used_usd`. A key limited to some series can only place Boost orders on those.
2. **The stake**, the same as on the website: **$1 to $100** per order. There's no limit on how many orders you place on a window or in a day, beyond the cash they need and your key's limits.
3. **The order budget.** Each new Boost order costs one unit of your key's order budget (10 a second, bursts of 20), like a book order. Sales don't. See [Rate limits](https://docs.updown.fast/api/rate-limits.md).

Going over a limit answers `400 LIMIT_EXCEEDED`, with a message that says which.

Before your first order, the account must have accepted the current Terms of Service and **allowed trading** on its wallet (a one-time step in the app). Without them, an order answers `403 FORBIDDEN` and says which step is missing.

## Errors

| HTTP | `code` | Meaning |
| - | - | - |
| 400 | `BAD_REQUEST` | A field is missing or invalid; `message` says which. |
| 400 | `INSUFFICIENT_BALANCE` | Not enough cash for the stake. |
| 400 | `LIMIT_EXCEEDED` | Over a key limit, or a stake outside $1 to $100; `message` says which. |
| 400 | `MARKET_NOT_OPEN` | Not the window that's open now, or its last minute. |
| 400 | `ORDER_REJECTED` | Refused for another reason, such as no one selling the contract at that price, the price moving past your `expected_*` field, or no fresh price; `message` says why. Nothing was placed or sold. |
| 403 | `BOOST_UNAVAILABLE` | Boost isn't offered to this account on this market, or the key is a test key. |
| 403 | `FORBIDDEN` | The key lacks the permission, or the account can't trade yet (Terms, allow trading). |
| 404 | `ORDER_NOT_FOUND` | No Boost order with that id on your account. |
| 409 | `IDEMPOTENCY_CONFLICT` | That `client_order_id` was used for a different order. |
| 409 | `ACCOUNT_BUSY` | Another request on your account is still running. Retry in a moment with the same `client_order_id`. |
| 429 | `RATE_LIMITED` | Too many new orders. Wait `Retry-After` seconds. |
| 503 | `TRADING_PAUSED` | Trading is paused; `message` says why. |
| 503 | `EXCHANGE_UNAVAILABLE` | We couldn't confirm the stake or the sale, or the bet was bought but the ride wasn't added. Look the order up by `client_order_id` before trying again; don't send it with a new id. |

> [card] [Boost](https://docs.updown.fast/interval/multiplier.md)
>
> How a Boost pays, when it's open, and cashing out early.

> [card] [Order entry](https://docs.updown.fast/api/orders.md)
>
> Limit orders on the order book, batches, and cancels.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.