# Game-line rules (https://docs.predictorsdk.com/guides/game-line-rules)

How each venue settles a tied game, overtime and a line that lands exactly, summarised on every moneyline, spread and total.

Two venues can list the same moneyline and still pay differently. The clearest
case is an NFL game that ends level: Kalshi pays each side half, ProphetX voids
the contract and returns the stakes. The matched row looks identical; the
payout is not.

Every moneyline, spread and total on
[the sports matching endpoint](https://docs.predictorsdk.com/api-reference/getSportsMatchingMarkets) carries a
one-word verdict on that, `settlement_equivalence`, and a small rule matrix
behind it that you ask for with `include_rules=true`, so the difference is
visible before you trade. Matching itself is unchanged: venues are still paired
exactly as before, and a venue that settles a tie differently stays in the row.
The matrix is the evidence you use to decide whether a pairing is a hedge.

## The verdict is always there; the rows are opt-in [#the-verdict-is-always-there-the-rows-are-opt-in]

| Request | A moneyline, spread or total carries |
| --- | --- |
| default | `settlement_equivalence` |
| `include_rules=true` | `settlement_equivalence` and `rule_comparisons` |

The rows are the evidence: each one names every source market, describes the
rule in words and links the clause. That makes them about 60% of the bytes of a
busy football event, and a page of events with every submarket was about 11 MB
with them, large enough to run into the request deadline. So a response leaves
them out unless you ask. The usual pattern is to read the verdicts on a page and,
for a game whose verdict is `different` or `unverified`, look it up with the
rows:

```
GET /v1/matching-markets/sports/lookup?event_id=nfl-pit-no-2026-10-25&include_rules=true
```

`include_rules` reads the same on the list and the lookup. It changes what each
event lists and never which events come back, so a `cursor` from one request
continues with or without it. It takes one value, an empty value means `false`,
and anything that is not a boolean is a `400`. A player prop is not affected: it
carries its nine rows whatever `include_rules` says. The SDK parameter is
`includeRules` in TypeScript, `include_rules` in Python and `IncludeRules` in Go.

## The three rules [#the-three-rules]

With `include_rules=true`, each game line has three rows in `rule_comparisons`,
one value per source market (`source_markets[]`). Its summary,
`settlement_equivalence`, is there either way.

| Rule | What it says | Values |
| --- | --- | --- |
| `tie` | What the venue does when the game or period ends level | `half_payout` (each side is paid half), `void` (stakes returned), `loses` (the named result loses), `separate_outcome` (the venue lists a tie contract of its own), `not_possible`, `unknown` |
| `overtime` | Whether overtime, extra innings or a shootout counts toward the contract | `included`, `excluded`, `not_applicable`, `unknown` |
| `push` | What happens when the result lands exactly on a whole-number line | `void`, `loses`, `not_applicable`, `unknown` |

`not_possible` means the contract cannot end level: a league that plays on
until one side wins (the NBA, WNBA, MLB and NHL) cannot end a full game tied,
and a spread or total has no tie result of its own because its line decides it.
Only the NFL can end a game level, so that is where `tie` differs in practice.
For `push`, `not_applicable` means there is nothing to land on: a moneyline has
no line, and a half-point line, which is every line matched today, cannot be
landed on exactly. For `overtime`, it means overtime cannot change the result:
an NHL game tied after regulation is decided by exactly one goal (sudden-death
overtime, or a shootout that adds one goal to the winner's score), so a puck
line of more than one goal, such as -1.5, settles the same whether a venue
counts overtime or not.

Each value comes with a `description` in plain words and, for every known value,
an `evidence_url`: the venue's published rules (a Kalshi contract-terms PDF, SX
Bet's help center, a ProphetX CFTC filing) or the record that holds the market's
own rules text. Where a venue writes no rule but has settled games it decided,
the value comes from those settlements and the evidence is the venue's own record
of one of them: Predict paid the extra-innings winner of every MLB game that went
past nine innings, AlphaArcade paid the full-game winner of every game that went
past regulation and paid each side half when an NFL game ended tied, SX Bet
voided the moneyline of an NFL game that ended tied, and Pred paid every NFL
spread, total and moneyline, and every NBA spread, that overtime decided on the
final score.
An `unknown` value has a description that says why and no evidence, because there
is no clause to point at.

## Reading `settlement_equivalence` [#reading-settlement_equivalence]

| Value | Meaning |
| --- | --- |
| `equivalent` | Every rule is known for every venue and agrees |
| `different` | At least one rule is known to differ, even if another rule is unknown |
| `unverified` | No difference was found, but a rule is `unknown` for at least one venue |

`unknown` never means "no restriction", and an unknown value never makes a row
`equivalent`. A venue whose rules say nothing about overtime, for example, leaves
the row `unverified` however many other venues agree. A known difference always
wins over an unknown, so `different` is never hidden by a venue that is silent.

## An excerpt [#an-excerpt]

An NFL moneyline where two venues void a tie and one pays half, as
`include_rules=true` returns it (abridged to the `tie` row and three venues):

```json
{
  "settlement_equivalence": "different",
  "rule_comparisons": [
    {
      "rule": "tie",
      "label": "Tied game or period",
      "comparison": "different",
      "source_values": [
        {
          "provider": "kalshi",
          "market_id": "...",
          "value": "half_payout",
          "description": "The market's rules, or its game's rules, resolve a tied game 50-50.",
          "evidence_url": "https://api.elections.kalshi.com/trade-api/v2/markets/KXNFLGAME-..."
        },
        {
          "provider": "prophetx",
          "market_id": "...",
          "value": "void",
          "description": "ProphetX: \"If, after the completion of overtime, the result remains tied, all orders on the outright event winner contract shall be void and collateral shall be returned.\"",
          "evidence_url": "https://framerusercontent.com/assets/3xBUPoodNIUMWAauxaaccjNRSo.pdf"
        },
        {
          "provider": "sxbet",
          "market_id": "...",
          "value": "void",
          "description": "SX Bet's help center does not say what a tied NFL game pays, but SX Bet voided the moneyline of the 2026-10-11 Giants at Commanders tie (27-27 after overtime, reported outcome 0).",
          "evidence_url": "https://api.sx.bet/markets/find?marketHashes=0x..."
        }
      ]
    }
  ]
}
```

Filter rows with `comparison == "different"` for known differences and
`comparison == "unverified"` for gaps. A consumer that hedges across venues
usually wants `equivalent`, or a `different` whose rows it has read and accepted.

## What it does not do [#what-it-does-not-do]

- It never changes which venues are paired, the submarket's `key`, or any
  identifier. It is published beside the match. (The one overtime rule that
  does decide a pairing is a second half's or fourth quarter's own, which is in
  its `key`; the matrix reports the same rule beside it.)
- It carries no prices and no payout estimate. A `half_payout` is a rule, not a
  number.
- Agreement is not a complete contract review. Evidence quotes the clauses that
  were read; a venue can have further terms.
- The player-prop matrix is separate: props always carry nine rows, with or
  without `include_rules`, and the policies on
  [player-prop matching](https://docs.predictorsdk.com/guides/player-prop-matching). A total's
  `rules.settlement` still says whether the line was keyed with overtime (so
  does a second half's or fourth quarter's spread or total that counts it), and
  the `overtime` row of its matrix never contradicts it.

## Where the rules come from [#where-the-rules-come-from]

Kalshi, SX Bet and ProphetX publish rules by product family, so their values are
read from those documents. Hyperliquid's NFL game winners all use one published
template, which pays 0.5 to each side on a tie, and each market (a game winner,
spread or total) states whether overtime counts in its own `countedPlay`, which
is read like a market's text.
Polymarket, Predict, Pred, Limitless, AlphaArcade and Polymarket US
publish their rules in each market's own text, so their values are read from the
market's text when it states them (for example "Overtime is included if played"
or "If the game ends in a tie, this market will resolve 50-50"). A market whose
text is silent is `unknown` for that rule. A full-game line also reads the text
of its game beside the market's own: Polymarket's event, and for an NBA spread or
total Predict's game description, which says once for every market of the game
that the final score includes overtime (Predict's spreads and totals say nothing
about it themselves). A period market states its own rule and reads nothing
else. The `description` on each value says which it is.