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

# List fixtures for the current account

> Every fixture the account has access to, in reverse chronological order
(newest first — by the match's `recorded_at`). Archived games are
excluded; fixtures that have no analysed sides yet are excluded.

The response is paginated. Use the `query` parameter for a single
case-insensitive substring search across the fixture name, either
team's name, and the competition name.




## OpenAPI

````yaml /api-reference/openapi.yaml get /api/v1/fixtures
openapi: 3.0.3
info:
  title: Framesports API
  version: 1.0.0
  description: >
    The Framesports API exposes read access to the same domain model used by the

    product: **accounts**, **fixtures**, **games**, and **events**.


    This reference documents the v1 surface. It is intentionally small — the API
    is

    used primarily by a small number of integration partners (e.g.
    broadcast-graphics

    tooling). If you need a capability that is not listed here, contact

    `support@framesports.ai` before building around private endpoints.


    ### Base URL


    ```

    https://app.framesports.ai

    ```


    ### Authentication


    All endpoints (except `POST /api/v1/auth` and `POST /api/v1/users`) require
    a

    bearer token in the `Authorization` header:


    ```

    Authorization: Bearer <token>

    ```


    To get a token, sign in to Framesports and open

    [API tokens](https://2.framesports.ai/settings/my/api_tokens).

    Choose **Create token**, give it a name, pick the club it is for and how
    long

    it lasts. The token is shown once, so copy it straight away. The same page

    shows the club's account ID and lists your tokens, and **Delete token**
    stops

    one on its next request.

    A token acts as the person who made it; every request has their access.


    ### Account scoping


    Most endpoints are scoped to a single account (the multi-tenant unit — a
    club or

    governing body). The account is selected in priority order:


    1. The `Account-Id` header on the request (prefix ID, e.g.
    `acct_Ex4mpLeAcc0unt1d567890`).
       The user must have access to that account directly, or through a governance
       relationship to it.
    2. Otherwise, the club the token was made for.

    3. Otherwise, the account stored in the user's session (for
    browser-originated
       calls).
    4. Otherwise, the user's newest / fallback account.


    > **Note on the header name.** The server currently reads `Account-Id`, not

    > `X-Account-Id`. If you send `X-Account-Id`, it is silently ignored and the

    > request falls back to rule 2 or later, which may not be the account you
    intended.


    Responses when the header is present but invalid:


    | Situation | Status |

    | --- | --- |

    | Account does not exist | `404 Not Found` |

    | Account exists but the user cannot access it | `403 Forbidden` |


    ### IDs


    Object IDs in the API are always **prefix IDs** — an opaque string with a

    type-specific prefix:


    | Type | Prefix | Example |

    | --- | --- | --- |

    | Account | `acct_` | `acct_Ex4mpLeAcc0unt1d567890` |

    | Fixture | `fxt_` | `fxt_Ex4mpLeF1xtur31d34567890` |

    | Game | `game_` | `game_Ex4mpLeG4m31d4567890abc` |

    | Event | `evnt_` | `evnt_Ex4mpLe3v3nt1d4567890ab` |

    | Team | `team_` | `team_Ex4mpLeTe4m1d4567890abc` |

    | Player | `pl_` | `pl_Ex4mpLePL4y3r1d4567890abc` |

    | Player game involvement | `pgi_` | `pgi_Ex4mpLePG1nv0Lv3m3nt4aa` |


    Never pass raw integer IDs — the API only accepts prefix IDs for public
    lookups.


    ### Pagination


    List endpoints use [Pagy](https://ddnexus.github.io/pagy/) with
    JSON:API-style

    links. Pass `page` and `per_page` as query parameters (or use the URLs in
    the

    `links` object of the response):


    ```json

    {
      "links": {
        "first": "/api/v1/games/.../events?page[page]=1",
        "last":  "/api/v1/games/.../events?page[page]=9",
        "prev":  null,
        "next":  "/api/v1/games/.../events?page[page]=2"
      },
      "data": [ /* ... */ ]
    }

    ```


    ### Errors


    Errors are returned with an appropriate HTTP status and (usually) a JSON
    body of

    the form `{"error": "..."}`. Unauthenticated responses (`401`) currently
    return

    an empty body with `content-type: text/html` — treat any `401` as "token
    missing

    or invalid" regardless of body.


    ### Versioning & stability


    The `/api/v1/` prefix denotes a stable version of the API. Fields may be
    **added**

    without notice; fields will not be **removed** or change meaning without a
    new

    major version. Any field whose object includes `"deprecated": true` is
    scheduled

    for removal — migrate off it.
  contact:
    name: Framesports support
    email: support@framesports.ai
servers:
  - url: https://app.framesports.ai
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Authentication
    description: Exchange credentials for an API token, or invalidate the current session.
  - name: Accounts
    description: The accounts the authenticated user can access.
  - name: Me
    description: The authenticated user.
  - name: Fixtures
    description: |
      A fixture is a single rugby match with two sides. Each side carries the
      team that played, the roster that took the field, and the full set of
      team-level stats. This is the endpoint to use for broadcast graphics,
      season roll-ups, or anything else that wants "the match" as a single
      object.
  - name: Games
    description: |
      **Deprecated — prefer `Fixtures`.** A game represents one side of a
      fixture (the billing account's own side). The `/api/v1/games` endpoints
      are kept for backwards compatibility; new integrations should consume
      `/api/v1/fixtures` instead, which returns both sides and all stats in
      one payload.
  - name: Events
    description: |
      Tagged plays within a fixture (tackles, carries, tries, etc.). Prefer
      `GET /api/v1/fixtures/{fixture_id}/events`, which spans both sides of
      the match and resolves each event's team + player into prefix IDs. The
      `/api/v1/games/{game_id}/events` endpoint is kept for backwards
      compatibility — it returns only one side and leaves you to map
      `"Home"` / `"Opp"` + jersey numbers yourself.
paths:
  /api/v1/fixtures:
    get:
      tags:
        - Fixtures
      summary: List fixtures for the current account
      description: |
        Every fixture the account has access to, in reverse chronological order
        (newest first — by the match's `recorded_at`). Archived games are
        excluded; fixtures that have no analysed sides yet are excluded.

        The response is paginated. Use the `query` parameter for a single
        case-insensitive substring search across the fixture name, either
        team's name, and the competition name.
      operationId: listFixtures
      parameters:
        - $ref: '#/components/parameters/AccountIdHeader'
        - in: query
          name: query
          description: |
            Case-insensitive substring match against the fixture name, either
            side's team name, or the competition name.
          schema:
            type: string
        - in: query
          name: page
          schema:
            type: integer
            minimum: 1
            default: 1
        - in: query
          name: per_page
          schema:
            type: integer
            minimum: 1
            maximum: 100
            default: 20
      responses:
        '200':
          description: Fixtures page.
          content:
            application/json:
              schema:
                type: object
                required:
                  - data
                  - links
                  - account
                properties:
                  data:
                    type: array
                    items:
                      $ref: '#/components/schemas/FixtureSummary'
                  links:
                    $ref: '#/components/schemas/PaginationLinks'
                  account:
                    type: object
                    properties:
                      id:
                        type: string
                        example: acct_Ex4mpLeAcc0unt1d567890
                      name:
                        type: string
                        example: Queensland Rugby Union
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
components:
  parameters:
    AccountIdHeader:
      in: header
      name: Account-Id
      required: false
      description: |
        Prefix ID of the account to scope this request to. Settings → API tokens
        shows it next to each token. If omitted, the server uses the club the
        token was made for (then the session account, then the newest account).
        Must be `Account-Id`: `X-Account-Id` is not read.
      schema:
        type: string
        example: acct_Ex4mpLeAcc0unt1d567890
  schemas:
    FixtureSummary:
      type: object
      description: Lightweight fixture record for list views.
      properties:
        id:
          type: string
          example: fxt_Ex4mpLeF1xtur31d34567890
        name:
          type: string
          nullable: true
          description: >-
            Derived from the fixture's games. May differ between sides for
            mirrored fixtures; this is the canonical one.
          example: Sunnybank v Wests | 2nd Grade | Round 3
        recorded_at:
          type: string
          format: date-time
          nullable: true
          description: When the match was recorded (kick-off), if known.
        competition:
          $ref: '#/components/schemas/Competition'
          nullable: true
        sides:
          type: array
          description: >-
            Always exactly two sides. Each summary side includes only the team
            and whether it belongs to the requesting account.
          items:
            $ref: '#/components/schemas/FixtureSummarySide'
    PaginationLinks:
      type: object
      properties:
        first:
          type: string
          nullable: true
        last:
          type: string
          nullable: true
        prev:
          type: string
          nullable: true
        next:
          type: string
          nullable: true
    Competition:
      type: object
      properties:
        id:
          type: integer
          example: 42
        name:
          type: string
          example: Queensland Premier Rugby 2026
    FixtureSummarySide:
      type: object
      properties:
        team:
          $ref: '#/components/schemas/Team'
        jersey_description:
          type: string
          nullable: true
          description: >-
            The kit this team wore in this specific fixture. Stored per-match
            because teams can swap colours.
          example: Green and yellow
        data_source:
          type: string
          enum:
            - analyzed
            - inferred
          description: >
            * `analyzed` — stats computed from this team's own tagged events.

            * `inferred` — stats derived from the other side's events (no mirror
            game).
    Team:
      type: object
      properties:
        id:
          type: string
          example: team_Ex4mpLeTe4m1d4567890abc
        name:
          type: string
          example: Wests Senior 2nd Team Men's
        abbreviated_name:
          type: string
          example: WST
        gender:
          type: string
          enum:
            - Men's
            - Women's
            - Other
        age:
          type: string
          enum:
            - Senior
            - Under 23
            - Under 21
            - Under 20
            - Under 19
            - Under 18
            - Under 17
            - Under 16
            - Under 15
            - Under 14
            - Under 13
            - Under 12
            - Under 11
            - Other
        level:
          type: string
          enum:
            - 1st Team
            - 2nd Team
            - 3rd Team
            - 4th Team
            - 5th Team
            - 6th Team
            - 7th Team
            - Other
        club:
          type: object
          nullable: true
          properties:
            name:
              type: string
              example: Wests Rugby
  responses:
    Unauthorized:
      description: Token missing or invalid.
    Forbidden:
      description: The account exists but the user cannot access it.
    NotFound:
      description: The account or record does not exist.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: opaque
      description: |
        Create a token on **Settings → API tokens** in Framesports. It is shown
        once, when you create it.

````

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