# Trading fees (https://docs.predictorsdk.com/guides/trading-fees)

Work out what a trade really costs on any venue, and compare venues that quote the same price.

`GET /v1/markets/{market_id}` returns a `trading_fees` object: what the
**venue** charges to trade that market, in one format across all nine venues.
It is the prediction market's own fee and has nothing to do with your
PredictorSDK plan.

## Why normalized price is not enough [#why-normalized-price-is-not-enough]

No venue charges a flat percentage: every fee changes with the price. Two
venues can quote the same ask for the same bet and still differ by more than
1% in what the trade costs, and which one is cheaper can flip during the day.

A real example from August 2026: an MLB total, Angels at Rangers, over 8.5.
Both venues quoted `0.41 / 0.42`:

| Market | Fee parameters | Fee on a $100 taker buy | Effective |
|---|---|---|---|
| `kalshi:KXMLBTOTAL-26AUG212015LAATEX-9` | `quadratic`, rate `0.035` | $2.03 | 203 bps |
| same market, after first pitch | `quadratic`, rate `0.07` | $4.06 | 406 bps |
| `polymarket:3753849` | `quadratic`, rate `0.05`, exponent `1` | $2.90 | 290 bps |

Kalshi was 0.87% cheaper before the game started and 1.16% more expensive
after. Both were known in advance: the second from `scheduled_change`.

## The model [#the-model]

Every venue's published fee is a **fee per share times the number of shares**.
Only the per-share part differs, so one description covers them all. The one
exception is Limitless, which publishes its taker fee as a table with no
formula: it reports `partial` with no taker leg rather than an invented rate
(and a Limitless market with fees turned off reports `published` with both
legs at zero).

```
fee = shares × f(price)          then apply `rounding`
```

| `model` | `f(price)` | Used by |
|---|---|---|
| `quadratic` | `rate × (price × (1 − price)) ^ exponent` | Kalshi, Polymarket, AlphaArcade, Pred, Polymarket US |
| `min_price` | `rate × min(price, 1 − price)` | Predict |
| `notional` | `rate × price` | Hyperliquid |
| `none` | `0` | fee-free markets, and most maker legs |

`rate` is a decimal fraction, never basis points: `0.07` means 7% of the price
term.

To compare venues, use the **effective rate on what you spend**,
`f(price) / price`. For `quadratic` with `exponent: 1` that is
`rate × (1 − price)`, so any single percentage is right at one price and wrong
at every other. At `rate: 0.07` it runs from 6.93% at a price of 0.01 down to
0.07% at 0.99.

`min_price` is shaped like a **tent, not a curve**: its effective rate stays at
`rate` for every price up to 0.5 and only falls above it. Don't treat it as
`quadratic`.

```ts
import type { PredictorSDK } from "@predictorsdk/client";

// The effective rate on notional, or null when the magnitude is unknown: a
// null leg (SX Bet, ProphetX), or a null rate or exponent (Hyperliquid, a
// Limitless taker). Never treat null as zero.
function effectiveRate(
  leg: PredictorSDK.MarketDetailFeeLeg | null | undefined,
  price: number,
): number | null {
  // A price of 0 or 1 has no notional to divide by.
  if (leg == null || !(price > 0 && price < 1)) return null;
  switch (leg.model) {
    case "none":
      return 0;
    case "quadratic":
      if (leg.rate == null || leg.exponent == null) return null;
      return (leg.rate * Math.pow(price * (1 - price), leg.exponent)) / price;
    case "min_price":
      if (leg.rate == null) return null;
      return (leg.rate * Math.min(price, 1 - price)) / price;
    case "notional":
      return leg.rate ?? null;
    default:
      return null;
  }
}
```

Both the `taker` and the `maker` legs are always returned, and you pick one.
PredictorSDK can't know which side you will be on, because that depends on an
order it hasn't seen.

## Read `availability` before you read the rate [#read-availability-before-you-read-the-rate]

`availability` says what is **known**; the legs say what is **charged**.
Keeping them apart lets you tell these cases apart:

| `availability` | Meaning | Where you'll see it |
|---|---|---|
| `published` | The full parameter set for this market is known. | Kalshi, Polymarket, Predict, AlphaArcade, Pred, Polymarket US, and any Limitless market whose fees are disabled (`metadata.fee: false`) |
| `partial` | Fees may be charged, but something upstream was unreadable. Nothing is guessed. | a Polymarket market with fees on and no readable schedule; a Kalshi market whose pending-change list could not be read; every fee-enabled Limitless market (the taker curve has no closed form, so the taker leg stays null while the explicitly-free maker leg is asserted); a Pred market whose record omits `fee_rate_bps` (absent fee configuration is unconfirmed, not zero) |
| `account_specific` | Rates exist but are set per trading account and need your own venue credentials. | SX Bet, Hyperliquid |
| `unpublished` | The venue publishes no fee model for this market at all. | reserved |
| `unavailable` | Our own bounded parameter fetch failed or timed out, or the venue exposes no per-market fee parameters at all. Identity and pricing are still served. | a degraded Kalshi lookup; every ProphetX market (the Market Maker API publishes no fee fields on the market record) |

A **fee-free market is not missing data**: it reports
`availability: "published"` with `model: "none"` and `rate: 0`, a stated zero.
Polymarket's geopolitics and world-events markets are fee-free, and so are some
Kalshi series.

For `account_specific` venues, read your own rates from the venue: SX Bet's
`GET /user/fees-v3` (signed in), or Hyperliquid's
`POST /info {"type":"userFees"}` (public for any address). A `model` with a
`null` rate, as Hyperliquid reports, means the shape of the fee is known and
its size isn't.

## Two fields that change the arithmetic [#two-fields-that-change-the-arithmetic]

**`charge_basis`** says when and on what the fee is taken:

- `fill`: when the order fills, on the shares traded at the fill price.
- `settlement_profit`: at settlement, on the profit, and only if the position
  **won**. SX Bet works this way. It trims your expected winnings rather than
  costing anything up front.
- `close_or_settlement`: when a position is closed or settles, never when it is
  opened. Hyperliquid's outcome markets work this way, so a buy that opens a
  position costs nothing.

**`scheduled_change`** is the next fee change the venue has announced, with the
time it takes effect, and is left out when there is none. Kalshi uses these:
its MLB games, for example, trade at half the fee rate until first pitch, and
the full rate applies from then on, so the fee doubles on a game already
trading.

Once the change takes effect it becomes the rate in `taker` and `maker`: the
same market reports `rate: 0.035` with a pending change before first pitch, and
`rate: 0.07` with none after. If `availability` is `partial`, a missing
`scheduled_change` means the list of pending changes couldn't be read, not that
nothing is coming.

```json
"scheduled_change": {
  "effective_at": "2026-08-22T00:15:00Z",
  "taker": { "model": "quadratic", "rate": 0.07, "exponent": 1,
             "rounding": { "direction": "up", "increment": 0.0001 } },
  "maker": { "model": "none", "rate": 0, "exponent": null, "rounding": null }
}
```

## Rounding, and where the number will still be slightly off [#rounding-and-where-the-number-will-still-be-slightly-off]

`rounding` is the venue's published rule,
`{ "direction": "up" | "nearest" | "down", "increment": <number> }`, or `null`
where the venue publishes none (Predict). Treat `null` as unknown, not as "no
rounding", which would understate small trades. Pred rounds `down`: fees are
worked out to six decimal places and rounded down, so a fee smaller than
0.000001 is zero.

Kalshi also charges a small rounding fee on each fill, refunded once it adds up
to more than $0.01. It depends on how your order splits across fills, so it
can't be known before the trade and isn't modelled here. Expect the fee Kalshi
charges to be slightly higher than the one you compute when an order fills in
many pieces.

## What is deliberately not here [#what-is-deliberately-not-here]

These all change what you pay, but they depend on your account or your route
rather than on the market, so they are not fields:

- **Rebates**, such as Polymarket's maker and taker rebate programs.
- **Account discounts**, such as Predict's 10% invite discount. `rate` is the
  published base rate; a referred account pays less.
- **Volume and staking tiers.** Hyperliquid's fee tier depends on your last 14
  days of volume and your staked HYPE.
- **A market creator's fee.** Each Hyperliquid outcome carries its creator's
  `deployerFeeScale` in `outcomeMeta`: `1.0` on outcomes from the `out` and
  `skew` creators, and `0` (no extra fee) on trade.xyz's own.
- **Fees added by a third party**, such as a Kalshi broker's fee or a
  Polymarket front end's builder fee.
- **Whether you are maker or taker.** Both legs are returned; which applies
  depends on your order.

## Cost of the lookup [#cost-of-the-lookup]

Polymarket, Predict, AlphaArcade, Pred and Polymarket US carry their fees on the
market record the lookup already reads, so `trading_fees` costs nothing extra. SX Bet,
Hyperliquid, ProphetX and Limitless need no read at all. Only Kalshi needs extra
reads, because its fees live on the market's series and on any scheduled
change; those reads are limited and cached. `source` says which case you are
in: `market_record`, `series_record` or `venue_schedule`.

`observed_at` is when PredictorSDK read the fee. It is `null` for
`venue_schedule` (nothing is read at request time) and for `unavailable`.
`pricing.observed_at` means the same for the quotes. `pricing.as_of` is the
venue's own timestamp, and `pricing.as_of_kind` says whether it tracks the
quote or only the market record. Even a quote's own timestamp can be hours old
on a quiet market, so judge freshness venue by venue.