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

# Ticks, pips, and subcents

> How contract prices, cash, the rest grid, and settlement units work for API bots.

Every price on the wire is an integer **pip**. A pip is **0.01¢** ($0.0001). `$1 = 10\_000` pips. Old cent-era ticks (`1`–`99\`) are **rejected** — they are
never reinterpreted as cents.

<Card title="Place an order" icon="chart-line" href="/quickstart/place-order">
  Limit and market orders, `max_cost` in pips, idempotency.
</Card>

## Units

| Name | Value |
| - | - |
| pip | 0.01¢ = \$0.0001 |
| `$1` | `10_000` pips (`TICK_SPAN`) |
| tick domain | integer **1..9999** (0.00 and 100.00 are illegal) |
| whole cent | `tick % 100 == 0` (`4700` = 47.00¢) |
| v1 wing step | `10` (0.10¢) |

Cash, `max_cost`, balances, fees, deposits, and withdrawals are **pips**,
rendered as decimal strings. Quantities are whole contracts (shares).

Winning contracts pay **10\_000 pips** (\$1). Losing contracts pay 0.

### Conversion

| Display | Wire `tick` |
| - | - |
| 1.00¢ | `100` |
| 4.00¢ | `400` |
| 24.00¢ | `2400` |
| 35.00¢ | `3500` |
| 47.00¢ | `4700` |
| 96.00¢ | `9600` |
| 96.10¢ | `9610` |
| 99.90¢ | `9990` |

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
TICK_SPAN = 10_000  # $1

def cents_to_tick(cents: float) -> int:
    """47.00 → 4700. 96.10 → 9610."""
    return int(round(cents * 100))

def tick_to_cents(tick: int) -> float:
    return tick / 100.0
```

Buying YES at `4700` costs 4,700 pips (47.00¢) per contract and pays 10,000
pips if YES wins. Sending `tick: 47` is `bad_price_tick`.

## Rest grid (live: `narrow`)

The venue admits rests on a named **tick policy**. Production is **`narrow`**.

| Region | Ticks | Rule |
| - | - | - |
| Interior `[400, 9600]` | 4.00¢ … 96.00¢ | whole cents only (`tick % 100 == 0`) |
| Wings `< 400` or `> 9600` | below 4.00¢ / above 96.00¢ | 0.10¢ (`tick % 10 == 0`) |

That grid is **always live**. You can rest `380` (3.80¢) or `9610` (96.10¢)
without waiting for a mode change. Interior `4710` (47.10¢) is always rejected.

<Warning>
  **Do not send cent-era ticks.** `1`–`99` fail `bad_price_tick`. The cheapest
  on-grid wing tick is `10` (0.10¢), not `1`.
</Warning>

## `tick_size` on every book

REST `GET /v1/markets/{id}` / `GET /v1/markets/{id}/orderbook` and WebSocket
book snapshots include:

```json theme={"theme":{"light":"github-light","dark":"github-dark"}}
{
  "type": "tick_size",
  "market_id": 71,
  "policy": "narrow",
  "mode": "cent",
  "tick_step": 10,
  "wing_lo": 400,
  "wing_hi": 9600
}
```

| Field | Meaning |
| - | - |
| `policy` | Named grid. Live v1 is `narrow`. |
| `mode` | `"cent"` or `"subcent"` — advertised book state. **Admit does not wait for `"subcent"`**; wings are already legal on `narrow`. |
| `tick_step` | Wing step in pips. v1 is `10` (0.10¢). |
| `wing_lo` / `wing_hi` | Interior bounds in pips (4.00¢ / 96.00¢ on `narrow`). |

Place against `wing_lo`, `wing_hi`, and `tick_step`. Ignore unknown extra
fields.

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
def on_grid(tick: int, ts: dict) -> bool:
    if tick < 1 or tick >= 10_000:
        return False
    step = int(ts["tick_step"])
    lo, hi = int(ts["wing_lo"]), int(ts["wing_hi"])
    if ts.get("policy") == "broadband":
        return step != 0 and tick % step == 0
    if tick < lo or tick > hi:
        return step != 0 and tick % step == 0
    return tick % 100 == 0
```

Off-grid **new** orders reject with `400 bad_price_tick`. If a later coarsen
cancels a rest that is no longer on the live grid, the placement/cancel
outcome is `status: "canceled"` with `reason: "tick_size"` (execution
outcome, not an HTTP error).

## Reciprocal book

Bids only, both sides. A YES bid at `t` is a NO ask at `10000 − t`.

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
best_yes_bid = book["yes"][0][0]
best_yes_ask = 10_000 - book["no"][0][0]
```

See [Orderbook responses](/concepts/orderbook).

## How a round settles

Rounds are aligned to the wall clock, not to `open_ts + cadence`. The cadence
is per series — 60 seconds, 5 minutes, or 15 minutes — and the asset is BTC,
gold, or WTI crude depending on `category`. A 60-second round:

1. **Open** — the scheduler opens in the first few seconds of a Unix minute
   (`:00`). `strike` is the asset's oracle price at open (units of 1e-8 USD).
2. **Trade** — `status: "trading"` until the wall clock enters the **next**
   Unix minute.
3. **Freeze** — `status: "frozen"`. Resting orders are cancelled (`reason:
   "freeze"`). `settle_price` is a TWAP of the sequenced oracle over the last
   `twap_window_secs` seconds (default **10**).
4. **Settle** — `winner` is `"yes"` if that TWAP is **strictly above**
   `strike`, otherwise `"no"` (exact equality → `"no"`). YES holders of a
   winning contract receive 10,000 pips; losers receive 0.

`yes_payout` on the round row is still `0` or `100` — cents of a \$1 contract,
not a pip tick.

Find the live slot with `GET /v1/markets?status=trading`, then
`GET /v1/rounds/{market_id}`. `GET /v1/rounds?limit=1` is newest
`round_number` first and is **not** guaranteed to be `trading`. See
[Rounds and markets](/concepts/rounds-and-markets).

## Fees

Maker/taker fees use pip ticks:

```
Q(p) = p · (10000 − p)
fee  = ceil(rate · qty · Q / 10^10)
```

Peak `Q` is at `p = 5000` (50.00¢), matching the old whole-cent fee at 50¢.

## Place against the grid

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from omnibook import Client
from omnibook.ticks import TICK_SPAN, cents_to_tick, on_grid

with Client(api_key="…", api_secret="…") as client:
    markets = client.get_markets(status="trading")
    m = next(x for x in markets["markets"] if x["status"] == "trading")
    book = client.get_orderbook(m["market_id"])
    tick = cents_to_tick(35.00)  # 3500
    assert on_grid(tick, book["tick_size"])
    order = client.place_order(
        client_order_id="42",
        market_id=m["market_id"],
        side="buy",
        outcome="yes",
        type="limit",
        tick=tick,
        qty=10,
        tif="gtc",
        post_only=True,
    )
```

Market **buys** require `max_cost` in **pips** (decimal string). A budget of
\$5.00 is `"50000"`. `worst_tick` defaults to `9999` on buys and `1` on sells.

Full placement walkthrough: [Place your first order](/quickstart/place-order).
The [Python SDK](/sdk/python) exports `TICK_SPAN`, `cents_to_tick`, `on_grid`,
and `implied_ask`.


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