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

# List a state's session laws

> List the session laws of one state: every act its legislature enacted, filtered
by session, approval date or effective date. This is how you ask "what became law
in Texas this session", "what was signed in April" or "what takes effect on
September 1, 2025", and how you turn the answer into `sessionLawId`s for the get
and body endpoints. A session law is the act as enacted, before it is folded into
a code; v1 serves STATE acts.

**Cost**: 1 credit per page of up to 200 rows (default
50), however many rows the page holds. An empty page is an answer and is
charged when it means nothing matches your filters. A request that fails validation (422)
is never charged; a failure on our side (500, 503) is refunded.

**Empty pages.** A page with no rows carries `coverage`, what we hold of the session you
named (or of the state, when you named none), so you can tell "nothing matches" from "we
have not collected this". `coverage.status` is `complete` (we hold every law the publisher
lists for it: the empty page is a true negative, and it is charged), `partial` (the
collection stopped short, so the law you want may exist) or `not_held` (we hold nothing of
it). On `partial` and `not_held` the page is NOT charged and `creditsConsumed` is 0: we
do not bill an empty answer that may be our gap. The one exception is a request that
names only the state, where some sessions we hold are complete and some partial: the page
is charged, since for the complete ones it is a true negative, and `coverage.partialSessions`
names the sessions to doubt (send one as `session` to ask about it alone). If coverage
cannot be read the page is charged as before and `coverage` is omitted.

**Filters.** `jurisdiction` is required and scopes everything; the rest narrow it
and combine with AND. A value that is malformed is a 422, and so is a range whose end is before its
start (`approvedTo` before `approvedFrom`, `effectiveTo` before `effectiveFrom`). A value that is well
formed and matches nothing (an unknown `session`, a date range with no laws) is a
200 with `results: []`. Dates are `YYYY-MM-DD`.

- Everything from one session: `session` (`2025R`, `2025S1`).
- Approved in a window: `approvedFrom` / `approvedTo`.
- Taking effect in a window: `effectiveFrom` / `effectiveTo`. For one day send the
  same date to both. This matches laws whose first-to-last effective dates overlap
  your window, so read `effectiveFirst` and `effectiveLast` on each row and
  `effectiveDates` on the law. A law with no held effective date (not every state
  prints them) never matches.
- Narrow by `series`, `instrumentType`, `hasText` or `textStatus`.
- What became law and what did not: `isLaw` (`false` for the vetoed and pocket-vetoed
  measures; a measure whose outcome does not settle it has a null `isLaw` and matches
  neither value) and `enactmentOutcome`, repeated for several outcomes
  (`enactmentOutcome=vetoed&enactmentOutcome=pocket_veto`).
- A sync job: `updatedSince` returns the laws whose record changed on or after a date
  (midnight UTC, by `updatedAt`), so a job that stores its last run pulls only what is new
  or corrected.
- Find by words: `q`, a case-insensitive substring of the `title` or the bill number as
  the publisher prints it (3 to 100 characters). It is a substring match inside one
  state, not a search engine.
- A derived approval date (`approvedDateDerived: true`) is not matched by `approvedFrom`
  and `approvedTo`, which read the registry's own approval date.

**Paging.** Rows come in `session.code` order, then `sessionLawId`, both as TEXT in the
database's collation, not in chapter order: `..._C10` sorts before `..._C2`, and the id's
series and numbering-year segments sort before the chapter. Sort client-side by `number`
if you need chapter order. The order is the same on every page and for every filter,
so a cursor never skips or repeats a row. Send
`nextCursor` back as `cursor`, with the same filters, while `hasMore` is true (a
cursor sent with different filters is a 422, `cursor_query_mismatch`: restart
without it). The cursor is a keyset (it names the last row you saw), so laws added between your
calls never repeat or skip a row you have passed. `count` is the size of this
page, never a total.

**Text.** Rows include laws whose text we do not hold (`textStatus: not_held`) or
hold and withhold (`withheld`, with `withheldReason`): the row is still a real law.
Pass `hasText=true` for just the laws `/{sessionLawId}/body` will serve. A row is
the summary only: the full dates, sources and code sections are on
`GET /us/session-laws/{sessionLawId}`. Each row carries `charCount` and
`estimatedBodyPages`, so you can price reading a law before you open it.
`citableAs` is the law cited the way a lawyer writes it (`Minn. Laws 2025, ch. 1`), and
`licenseNote` says what its licence class permits.

**Cost of reading a law.** Reading a whole law is `estimatedBodyPages` times the price
of one body page (6 credits). Both are on the record: `charCount` is its length
in characters and `estimatedBodyPages` is that divided by the page size (about
30,000 characters), rounded up, and null unless the text is served. Most acts
take a page or two. The longest we hold, Ohio's 2025 budget act (HB 96, 9,571,132
characters), takes about 320 pages, 1,920 credits to read in
full, so check `estimatedBodyPages` before you page through an omnibus act. Each body
response then carries `pagePrice` (what that page cost) and `estimatedRemainingCredits`
(the pages still to come times the price) so you can stop whenever you have enough.

**Example**

```bash
curl "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=tx&effectiveFrom=2025-09-01&effectiveTo=2025-09-01&limit=25" \
  -H "Authorization: Bearer $VAQUILL_API_KEY"

# only what changed since your last sync, and only measures that did not become law
curl "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=mn&updatedSince=2026-10-01" \
  -H "Authorization: Bearer $VAQUILL_API_KEY"
curl "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=mn&isLaw=false&enactmentOutcome=vetoed&enactmentOutcome=pocket_veto" \
  -H "Authorization: Bearer $VAQUILL_API_KEY"

# find by words in the title or the printed bill number
curl "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=mn&q=court%20fees" -H "Authorization: Bearer $VAQUILL_API_KEY"
```

```javascript
const url = new URL("https://api.vaquill.ai/api/v1/us/session-laws/list");
url.search = new URLSearchParams({ jurisdiction: "mn", session: "2025R" });
const res = await fetch(url, {
  headers: { Authorization: `Bearer ${process.env.VAQUILL_API_KEY}` },
});
const { results, nextCursor, hasMore } = await res.json();
```

**Related endpoints**

- `GET /us/statutes/resolve` answers a citation that names a state session law
  rather than a code section with a `sessionLaw` block (`matched`, or `ambiguous`
  with every candidate), pointing here. It never changes `resolved` or `section`.
- `GET /us/statutes/coverage` lists, per jurisdiction under `sessionLaws`, which
  sessions we hold session laws for and whether each is `complete` or `partial`.
  Read it first: a law missing from a `partial` session is not evidence that it
  does not exist.
- Federal session laws (the Statutes at Large, `SAL_` ids) are not served here. Read
  them with `GET /us/statutes/section/{actId}`.

**Nulls.** Every field of a response is always present: one with no value is `null`
(or `[]` for a list). The examples on this page leave the nulls out for brevity. The
exceptions are blocks that exist only when they apply and are OMITTED otherwise, never
null: `publisher`, `provenance` and `session.coverageStatus` on a law, and `coverage` on a
list page that has rows.

**Rate limits.** Calls count against your key's per-minute budget like every Data
API route; a 429 carries `Retry-After`.



## OpenAPI

````yaml https://api.vaquill.ai/external/openapi.json get /api/v1/us/session-laws/list
openapi: 3.1.0
info:
  title: Vaquill Developer API
  description: >-
    Public API for legal statutes and legislation.


    **Authentication**: Pass your API key as `Authorization: Bearer vq_key_...`
    (preferred) or in the `X-API-Key` header. The `api_key` query parameter also
    works where a header cannot be set, but a URL ends up in logs and browser
    history. Sending two different keys in one request is rejected with a 401.


    **Credits**: Each call costs API credits. See `GET
    /api/v1/api-credits/pricing` for the full pricing matrix.


    ## Jurisdictions


    | Jurisdiction | Coverage | `countryCode` |

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

    | **United States** | USC and the Statutes at Large, the CFR and its annual
    editions, all 52 state and territory statutory codes (50 states plus DC and
    Puerto Rico), state administrative regulations, court rules, federal and
    state constitutions, federal agency guidance and adjudications, the Federal
    Register, the Sentencing Guidelines and US tax treaties. | `US` |


    See the full [Coverage page](https://www.vaquill.ai/docs/api-guide/coverage)
    for the jurisdiction-by-jurisdiction breakdown, or call
    `/us/statutes/coverage` for live counts. Coverage is per (jurisdiction,
    corpusType) pair, so treat that endpoint as the authoritative list rather
    than this summary.


    ## Endpoints


    - **US Statutes**: Search and retrieve any of the corpora above with full
    text, resolve a citation to its exact section, browse the statutory
    hierarchy, read a section as it stood on a past date, and follow its change
    history, cross-references and defined terms

    - **Board Watches**: Subscribe to a corpus source and get a webhook or email
    when it refreshes with real changes (free, API key required)

    - **Pricing**: Credit costs per endpoint (no auth required)


    ## Rate limits


    Limits are enforced per API key and scale with your plan. A `429` response
    includes a `Retry-After` header.


    | Plan | Per minute | Per hour | Per day |

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

    | Vaquill API Pro | 60 | 1,000 | 2,000 |

    | Vaquill API Business | 150 | 2,500 | 10,000 |


    For full documentation, visit the [API
    Reference](https://www.vaquill.ai/docs/api-reference/).
  version: 1.0.0
  contact:
    name: Vaquill API Support
    url: https://www.vaquill.ai
    email: support@vaquill.ai
  license:
    name: Proprietary
    url: https://www.vaquill.ai/terms
  termsOfService: https://www.vaquill.ai/terms
servers:
  - url: https://api.vaquill.ai
    description: Production
security:
  - ApiKeyAuth: []
  - ApiKeyHeader: []
  - ApiKeyQuery: []
tags:
  - name: US Statutes
    description: >-
      Search and retrieve US primary law. Covers the United States Code and the
      Statutes at Large, the Code of Federal Regulations and its annual
      editions, state statutory codes and administrative regulations, federal
      and state constitutions, court rules, Federal Register rules and
      Presidential documents, federal and state agency guidance, agency
      adjudications, state Attorney General opinions, the Sentencing Guidelines
      and US tax treaties. Scope a search with the `corpusType` filter, and call
      `/us/statutes/coverage` for the live jurisdiction-by-corpusType list.


      - **Search**: Search across all USC, CFR, state, and regulatory sections

      - **Section**: Get metadata, citation, hierarchy, and source links for a
      specific section

      - **Body**: Get the full text of a section

      - **Enactments**: Which state session laws a publisher's own tables list
      against a section (supported jurisdictions only, never a complete history)
  - name: US Session Laws
    description: >-
      State session laws: the acts of each legislature as they were enacted,
      chapter by chapter, before they are folded into a code. A session law is
      what the governor signs. It carries the act's own text, including the
      language it strikes and inserts, its approval and effective dates, and,
      where the publisher prints one, the code sections it changes. That makes
      it the source for "which act changed this section, and when did it take
      effect".


      Every act has a permanent `sessionLawId` (for example
      `SSL_MN_2025R_G_Y2025_C1`, Minnesota Laws 2025, regular session, chapter
      1) whether or not we hold its text, and a citation or bill number such as
      `S.F.No. 1552` is accepted where an id goes. v1 serves STATE acts only.
      Federal session laws (the Statutes at Large, `SAL_` ids) are served by
      `/us/statutes/section`, and `/us/statutes/resolve` points a session-law
      citation here.


      **Start here**: check `/us/statutes/coverage` (free) for what we hold per
      state: each jurisdiction's `sessionLaws` block lists its sessions, which
      are complete or only partly collected, and the `series` and
      `instrumentTypes` that exist. Then **List** a session or a date range to
      get ids, **Get** one act for its record, then **Body** for its text. A law
      missing from a partly collected session is a free 404
      (`session_not_fully_collected`), not proof it does not exist.


      - **List**: everything enacted in a state's session, approved in a window,
      or taking effect on a date

      - **Get**: one act by id or by citation; dates (`effectiveDates` is always
      a list), sources and the code sections it affects

      - **Body**: the act's text as printed, paged by cursor, with amendatory
      markup preserved where the publisher printed it

      - **Batch**: up to 50 ids or citations in one call, the same record as
      Get, billed per law served, with every miss listed and its reason

      - **Changes**: a sync feed of the registry over an integer cursor
      (`sinceId`): what began to be served, was corrected, withdrawn or merged


      The reverse link, from a code section to the acts a publisher's own tables
      list against it, is `GET /us/statutes/section/{actId}/enactments`.
  - name: Board Watches
    description: >-
      Law-change alerts. Subscribe to a **board** (a tracked corpus source,
      identified by `corpusType` plus an optional `state`) and get a webhook or
      email whenever it refreshes with real changes, naming the exact sections
      that changed. Fetch old-vs-new text for any amended section via the change
      diff.


      Boards refresh on their own existing cadence; watching one does not change
      how often it refreshes. Every endpoint here is **free**: authenticated by
      API key and rate-limited, but not credit-metered.


      See the [Law Change Alerts
      guide](https://www.vaquill.ai/docs/api-guide/alerts) for the full
      walkthrough.
  - name: Pricing
    description: >-
      Credit pricing and conversion rates. No authentication required. 1 credit
      = $0.01 USD.
  - name: Credits
    description: >-
      Your own credit balance: what is spendable right now, where it came from,
      and what is about to expire.


      Free and never charged, so it is safe to poll for low-balance alerting or
      to pre-flight a batch job.
externalDocs:
  description: Full API Reference
  url: https://www.vaquill.ai/docs/api-reference/
paths:
  /api/v1/us/session-laws/list:
    get:
      tags:
        - US Session Laws
      summary: List a state's session laws
      description: >-
        List the session laws of one state: every act its legislature enacted,
        filtered

        by session, approval date or effective date. This is how you ask "what
        became law

        in Texas this session", "what was signed in April" or "what takes effect
        on

        September 1, 2025", and how you turn the answer into `sessionLawId`s for
        the get

        and body endpoints. A session law is the act as enacted, before it is
        folded into

        a code; v1 serves STATE acts.


        **Cost**: 1 credit per page of up to 200 rows (default

        50), however many rows the page holds. An empty page is an answer and is

        charged when it means nothing matches your filters. A request that fails
        validation (422)

        is never charged; a failure on our side (500, 503) is refunded.


        **Empty pages.** A page with no rows carries `coverage`, what we hold of
        the session you

        named (or of the state, when you named none), so you can tell "nothing
        matches" from "we

        have not collected this". `coverage.status` is `complete` (we hold every
        law the publisher

        lists for it: the empty page is a true negative, and it is charged),
        `partial` (the

        collection stopped short, so the law you want may exist) or `not_held`
        (we hold nothing of

        it). On `partial` and `not_held` the page is NOT charged and
        `creditsConsumed` is 0: we

        do not bill an empty answer that may be our gap. The one exception is a
        request that

        names only the state, where some sessions we hold are complete and some
        partial: the page

        is charged, since for the complete ones it is a true negative, and
        `coverage.partialSessions`

        names the sessions to doubt (send one as `session` to ask about it
        alone). If coverage

        cannot be read the page is charged as before and `coverage` is omitted.


        **Filters.** `jurisdiction` is required and scopes everything; the rest
        narrow it

        and combine with AND. A value that is malformed is a 422, and so is a
        range whose end is before its

        start (`approvedTo` before `approvedFrom`, `effectiveTo` before
        `effectiveFrom`). A value that is well

        formed and matches nothing (an unknown `session`, a date range with no
        laws) is a

        200 with `results: []`. Dates are `YYYY-MM-DD`.


        - Everything from one session: `session` (`2025R`, `2025S1`).

        - Approved in a window: `approvedFrom` / `approvedTo`.

        - Taking effect in a window: `effectiveFrom` / `effectiveTo`. For one
        day send the
          same date to both. This matches laws whose first-to-last effective dates overlap
          your window, so read `effectiveFirst` and `effectiveLast` on each row and
          `effectiveDates` on the law. A law with no held effective date (not every state
          prints them) never matches.
        - Narrow by `series`, `instrumentType`, `hasText` or `textStatus`.

        - What became law and what did not: `isLaw` (`false` for the vetoed and
        pocket-vetoed
          measures; a measure whose outcome does not settle it has a null `isLaw` and matches
          neither value) and `enactmentOutcome`, repeated for several outcomes
          (`enactmentOutcome=vetoed&enactmentOutcome=pocket_veto`).
        - A sync job: `updatedSince` returns the laws whose record changed on or
        after a date
          (midnight UTC, by `updatedAt`), so a job that stores its last run pulls only what is new
          or corrected.
        - Find by words: `q`, a case-insensitive substring of the `title` or the
        bill number as
          the publisher prints it (3 to 100 characters). It is a substring match inside one
          state, not a search engine.
        - A derived approval date (`approvedDateDerived: true`) is not matched
        by `approvedFrom`
          and `approvedTo`, which read the registry's own approval date.

        **Paging.** Rows come in `session.code` order, then `sessionLawId`, both
        as TEXT in the

        database's collation, not in chapter order: `..._C10` sorts before
        `..._C2`, and the id's

        series and numbering-year segments sort before the chapter. Sort
        client-side by `number`

        if you need chapter order. The order is the same on every page and for
        every filter,

        so a cursor never skips or repeats a row. Send

        `nextCursor` back as `cursor`, with the same filters, while `hasMore` is
        true (a

        cursor sent with different filters is a 422, `cursor_query_mismatch`:
        restart

        without it). The cursor is a keyset (it names the last row you saw), so
        laws added between your

        calls never repeat or skip a row you have passed. `count` is the size of
        this

        page, never a total.


        **Text.** Rows include laws whose text we do not hold (`textStatus:
        not_held`) or

        hold and withhold (`withheld`, with `withheldReason`): the row is still
        a real law.

        Pass `hasText=true` for just the laws `/{sessionLawId}/body` will serve.
        A row is

        the summary only: the full dates, sources and code sections are on

        `GET /us/session-laws/{sessionLawId}`. Each row carries `charCount` and

        `estimatedBodyPages`, so you can price reading a law before you open it.

        `citableAs` is the law cited the way a lawyer writes it (`Minn. Laws
        2025, ch. 1`), and

        `licenseNote` says what its licence class permits.


        **Cost of reading a law.** Reading a whole law is `estimatedBodyPages`
        times the price

        of one body page (6 credits). Both are on the record: `charCount` is its
        length

        in characters and `estimatedBodyPages` is that divided by the page size
        (about

        30,000 characters), rounded up, and null unless the text is served. Most
        acts

        take a page or two. The longest we hold, Ohio's 2025 budget act (HB 96,
        9,571,132

        characters), takes about 320 pages, 1,920 credits to read in

        full, so check `estimatedBodyPages` before you page through an omnibus
        act. Each body

        response then carries `pagePrice` (what that page cost) and
        `estimatedRemainingCredits`

        (the pages still to come times the price) so you can stop whenever you
        have enough.


        **Example**


        ```bash

        curl
        "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=tx&effectiveFrom=2025-09-01&effectiveTo=2025-09-01&limit=25"
        \
          -H "Authorization: Bearer $VAQUILL_API_KEY"

        # only what changed since your last sync, and only measures that did not
        become law

        curl
        "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=mn&updatedSince=2026-10-01"
        \
          -H "Authorization: Bearer $VAQUILL_API_KEY"
        curl
        "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=mn&isLaw=false&enactmentOutcome=vetoed&enactmentOutcome=pocket_veto"
        \
          -H "Authorization: Bearer $VAQUILL_API_KEY"

        # find by words in the title or the printed bill number

        curl
        "https://api.vaquill.ai/api/v1/us/session-laws/list?jurisdiction=mn&q=court%20fees"
        -H "Authorization: Bearer $VAQUILL_API_KEY"

        ```


        ```javascript

        const url = new
        URL("https://api.vaquill.ai/api/v1/us/session-laws/list");

        url.search = new URLSearchParams({ jurisdiction: "mn", session: "2025R"
        });

        const res = await fetch(url, {
          headers: { Authorization: `Bearer ${process.env.VAQUILL_API_KEY}` },
        });

        const { results, nextCursor, hasMore } = await res.json();

        ```


        **Related endpoints**


        - `GET /us/statutes/resolve` answers a citation that names a state
        session law
          rather than a code section with a `sessionLaw` block (`matched`, or `ambiguous`
          with every candidate), pointing here. It never changes `resolved` or `section`.
        - `GET /us/statutes/coverage` lists, per jurisdiction under
        `sessionLaws`, which
          sessions we hold session laws for and whether each is `complete` or `partial`.
          Read it first: a law missing from a `partial` session is not evidence that it
          does not exist.
        - Federal session laws (the Statutes at Large, `SAL_` ids) are not
        served here. Read
          them with `GET /us/statutes/section/{actId}`.

        **Nulls.** Every field of a response is always present: one with no
        value is `null`

        (or `[]` for a list). The examples on this page leave the nulls out for
        brevity. The

        exceptions are blocks that exist only when they apply and are OMITTED
        otherwise, never

        null: `publisher`, `provenance` and `session.coverageStatus` on a law,
        and `coverage` on a

        list page that has rows.


        **Rate limits.** Calls count against your key's per-minute budget like
        every Data

        API route; a 429 carries `Retry-After`.
      operationId: list_session_laws_api_v1_us_session_laws_list_get
      parameters:
        - name: jurisdiction
          in: query
          required: true
          schema:
            type: string
            description: >-
              Two-letter code of the state whose session laws to list: the 50
              states, `dc` and `pr`. Case-insensitive (`MN` works). Required:
              the list is scoped to one jurisdiction at a time. `federal` and
              any unknown code is a 422; federal session laws are on
              `/us/statutes/section`. A jurisdiction we hold no session laws for
              yet (Indiana and Tennessee at launch) returns an empty page, which
              is charged: see `sessionLaws` on `/us/statutes/coverage` for what
              is held.
            examples:
              - mn
            enum:
              - al
              - ak
              - as
              - az
              - ar
              - ca
              - co
              - ct
              - de
              - dc
              - fl
              - ga
              - gu
              - hi
              - id
              - il
              - in
              - ia
              - ks
              - ky
              - la
              - me
              - md
              - ma
              - mi
              - mn
              - ms
              - mo
              - mt
              - ne
              - nv
              - nh
              - nj
              - nm
              - ny
              - nc
              - nd
              - mp
              - oh
              - ok
              - or
              - pa
              - pr
              - ri
              - sc
              - sd
              - tn
              - tx
              - ut
              - vt
              - vi
              - va
              - wa
              - wv
              - wi
              - wy
            title: Jurisdiction
          description: >-
            Two-letter code of the state whose session laws to list: the 50
            states, `dc` and `pr`. Case-insensitive (`MN` works). Required: the
            list is scoped to one jurisdiction at a time. `federal` and any
            unknown code is a 422; federal session laws are on
            `/us/statutes/section`. A jurisdiction we hold no session laws for
            yet (Indiana and Tennessee at launch) returns an empty page, which
            is charged: see `sessionLaws` on `/us/statutes/coverage` for what is
            held.
        - name: session
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                maxLength: 32
                minLength: 1
                pattern: ^[A-Za-z0-9._-]+$
              - type: 'null'
            description: >-
              Only laws enacted in this session. Use the code exactly as
              `session.code` reports it: `2025R` is the 2025 regular session,
              `2025S1` the first special session of 2025. Case-sensitive, so
              `2025r` matches nothing. A code that matches no session returns an
              empty page (charged), not an error; characters other than letters,
              digits, `.`, `_` and `-` are a 422. Omit to list every session.
            examples:
              - 2025R
            title: Session
          description: >-
            Only laws enacted in this session. Use the code exactly as
            `session.code` reports it: `2025R` is the 2025 regular session,
            `2025S1` the first special session of 2025. Case-sensitive, so
            `2025r` matches nothing. A code that matches no session returns an
            empty page (charged), not an error; characters other than letters,
            digits, `.`, `_` and `-` are a 422. Omit to list every session.
        - name: series
          in: query
          required: false
          schema:
            anyOf:
              - items:
                  type: string
                  enum:
                    - general
                    - public
                    - public_act
                    - special_act
                    - private_and_special
                    - act
                    - acts
                    - law
                    - local
                    - municipal
                    - appropriation
                    - resolve
                    - resolves
                    - resolution
                    - resolution_chapter
                    - joint_resolution
                    - concurrent_resolution
                    - memorial
                    - initiated_bill
                    - constitutional_amendment
                type: array
              - type: 'null'
            description: >-
              Only laws in one of these numbering series. Repeat the parameter
              for several (`series=resolve&series=resolves`); they combine with
              OR. `general` is the ordinary chapter sequence of most states;
              others number acts, resolutions or local laws apart. One of
              `general`, `public`, `public_act`, `special_act`,
              `private_and_special`, `act`, `acts`, `law`, `local`, `municipal`,
              `appropriation`, `resolve`, `resolves`, `resolution`,
              `resolution_chapter`, `joint_resolution`, `concurrent_resolution`,
              `memorial`, `initiated_bill`, `constitutional_amendment`, as a
              result's `series` reports it. Not every jurisdiction uses every
              series: `sessionLaws` on `/us/statutes/coverage` lists each one's.
              Any other value is a 422, never charged; a valid series nothing
              matches returns an empty page (charged). Omit for every series.
            examples:
              - - general
            title: Series
          description: >-
            Only laws in one of these numbering series. Repeat the parameter for
            several (`series=resolve&series=resolves`); they combine with OR.
            `general` is the ordinary chapter sequence of most states; others
            number acts, resolutions or local laws apart. One of `general`,
            `public`, `public_act`, `special_act`, `private_and_special`, `act`,
            `acts`, `law`, `local`, `municipal`, `appropriation`, `resolve`,
            `resolves`, `resolution`, `resolution_chapter`, `joint_resolution`,
            `concurrent_resolution`, `memorial`, `initiated_bill`,
            `constitutional_amendment`, as a result's `series` reports it. Not
            every jurisdiction uses every series: `sessionLaws` on
            `/us/statutes/coverage` lists each one's. Any other value is a 422,
            never charged; a valid series nothing matches returns an empty page
            (charged). Omit for every series.
        - name: instrumentType
          in: query
          required: false
          schema:
            anyOf:
              - items:
                  type: string
                  enum:
                    - act
                    - joint_resolution
                    - concurrent_resolution
                    - resolution
                    - resolve
                    - memorial
                    - other
                type: array
              - type: 'null'
            description: >-
              Only these kinds of measure. Repeat the parameter for several
              (`instrumentType=joint_resolution&instrumentType=concurrent_resolution`);
              they combine with OR. One of `act`, `joint_resolution`,
              `concurrent_resolution`, `resolution`, `resolve`, `memorial`,
              `other` (`act` is an ordinary law), as `instrumentType` reports
              it. Any other value is a 422, never charged; a valid kind nothing
              matches returns an empty page (charged). Omit for every kind.
            examples:
              - - joint_resolution
                - concurrent_resolution
            title: Instrumenttype
          description: >-
            Only these kinds of measure. Repeat the parameter for several
            (`instrumentType=joint_resolution&instrumentType=concurrent_resolution`);
            they combine with OR. One of `act`, `joint_resolution`,
            `concurrent_resolution`, `resolution`, `resolve`, `memorial`,
            `other` (`act` is an ordinary law), as `instrumentType` reports it.
            Any other value is a 422, never charged; a valid kind nothing
            matches returns an empty page (charged). Omit for every kind.
        - name: approvedFrom
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                pattern: ^\d{4}-\d{2}-\d{2}$
              - type: 'null'
            description: >-
              Only laws approved (signed) on or after this date. Format
              `YYYY-MM-DD`, inclusive; it must be a real calendar date
              (`2025-02-30` is a 422). A law with no printed approval date never
              matches, and neither does one whose `approvedDate` we derived
              (`approvedDateDerived: true`): this filter reads the registry's
              own approval date, so South Dakota's derived dates are not found
              by it. Pair with `approvedTo` for a range; an end before the start
              is a 422 (never charged).
            examples:
              - '2025-04-01'
            format: date
            title: Approvedfrom
          description: >-
            Only laws approved (signed) on or after this date. Format
            `YYYY-MM-DD`, inclusive; it must be a real calendar date
            (`2025-02-30` is a 422). A law with no printed approval date never
            matches, and neither does one whose `approvedDate` we derived
            (`approvedDateDerived: true`): this filter reads the registry's own
            approval date, so South Dakota's derived dates are not found by it.
            Pair with `approvedTo` for a range; an end before the start is a 422
            (never charged).
        - name: approvedTo
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                pattern: ^\d{4}-\d{2}-\d{2}$
              - type: 'null'
            description: >-
              Only laws approved (signed) on or before this date. Format
              `YYYY-MM-DD`, inclusive; it must be a real calendar date
              (`2025-02-30` is a 422). Like `approvedFrom`, it does not match a
              derived `approvedDate`.
            examples:
              - '2025-05-31'
            format: date
            title: Approvedto
          description: >-
            Only laws approved (signed) on or before this date. Format
            `YYYY-MM-DD`, inclusive; it must be a real calendar date
            (`2025-02-30` is a 422). Like `approvedFrom`, it does not match a
            derived `approvedDate`.
        - name: effectiveFrom
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                pattern: ^\d{4}-\d{2}-\d{2}$
              - type: 'null'
            description: >-
              Only laws with an effective date on or after this date. Format
              `YYYY-MM-DD`, inclusive; it must be a real calendar date
              (`2025-02-30` is a 422). A law matches when the span from its
              first to its last effective date (`effectiveFirst` to
              `effectiveLast`) overlaps your window, so one whose dates straddle
              your day is returned even though none falls exactly on it: read
              `effectiveDates` on the law for the dates themselves. Only laws
              with a held effective date can match, and not every state's
              publisher prints them (Texas, Washington and Iowa do; Minnesota
              does not yet): a law with no effective date is never returned by
              this filter, though it may well be in force. To get everything
              taking effect on one day, send the same date to both
              `effectiveFrom` and `effectiveTo`; for example `jurisdiction=tx`,
              `effectiveFrom=2025-09-01`, `effectiveTo=2025-09-01` lists the
              Texas acts effective September 1, 2025.
            examples:
              - '2025-09-01'
            format: date
            title: Effectivefrom
          description: >-
            Only laws with an effective date on or after this date. Format
            `YYYY-MM-DD`, inclusive; it must be a real calendar date
            (`2025-02-30` is a 422). A law matches when the span from its first
            to its last effective date (`effectiveFirst` to `effectiveLast`)
            overlaps your window, so one whose dates straddle your day is
            returned even though none falls exactly on it: read `effectiveDates`
            on the law for the dates themselves. Only laws with a held effective
            date can match, and not every state's publisher prints them (Texas,
            Washington and Iowa do; Minnesota does not yet): a law with no
            effective date is never returned by this filter, though it may well
            be in force. To get everything taking effect on one day, send the
            same date to both `effectiveFrom` and `effectiveTo`; for example
            `jurisdiction=tx`, `effectiveFrom=2025-09-01`,
            `effectiveTo=2025-09-01` lists the Texas acts effective September 1,
            2025.
        - name: effectiveTo
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                pattern: ^\d{4}-\d{2}-\d{2}$
              - type: 'null'
            description: >-
              Only laws with an effective date on or before this date. Format
              `YYYY-MM-DD`, inclusive; it must be a real calendar date
              (`2025-02-30` is a 422). Overlap rule as for `effectiveFrom`. An
              end before `effectiveFrom` is a 422 (never charged).
            examples:
              - '2025-09-30'
            format: date
            title: Effectiveto
          description: >-
            Only laws with an effective date on or before this date. Format
            `YYYY-MM-DD`, inclusive; it must be a real calendar date
            (`2025-02-30` is a 422). Overlap rule as for `effectiveFrom`. An end
            before `effectiveFrom` is a 422 (never charged).
        - name: hasText
          in: query
          required: false
          schema:
            anyOf:
              - type: boolean
              - type: 'null'
            description: >-
              `true`: only laws whose text is served (`textStatus: held`), the
              ones `/{sessionLawId}/body` will return. `false`: only laws whose
              text is not served (`withheld`, `not_held` or `pending`). Omit for
              both. Combined with `textStatus` by AND, so
              `hasText=true&textStatus=withheld` is always empty. Anything but a
              boolean is a 422.
            examples:
              - true
            title: Hastext
          description: >-
            `true`: only laws whose text is served (`textStatus: held`), the
            ones `/{sessionLawId}/body` will return. `false`: only laws whose
            text is not served (`withheld`, `not_held` or `pending`). Omit for
            both. Combined with `textStatus` by AND, so
            `hasText=true&textStatus=withheld` is always empty. Anything but a
            boolean is a 422.
        - name: textStatus
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                enum:
                  - held
                  - withheld
                  - not_held
                  - pending
              - type: 'null'
            description: >-
              Only laws with this text status. One of `held`, `withheld`,
              `not_held`, `pending`: `held` is served, `withheld` is held but
              kept back for a measured defect, `not_held` is known to exist
              without text, `pending` is collected and not yet verified. Any
              other value is a 422. Omit for every status.
            examples:
              - held
            title: Textstatus
          description: >-
            Only laws with this text status. One of `held`, `withheld`,
            `not_held`, `pending`: `held` is served, `withheld` is held but kept
            back for a measured defect, `not_held` is known to exist without
            text, `pending` is collected and not yet verified. Any other value
            is a 422. Omit for every status.
        - name: isLaw
          in: query
          required: false
          schema:
            anyOf:
              - type: boolean
              - type: 'null'
            description: >-
              `true`: only measures that are law. `false`: only numbered
              measures that are NOT law (a vetoed bill, a pocket veto), the ones
              `isLaw: false` marks. Omit for both. A measure whose outcome does
              not settle it (`not_presented`, `unknown`) has a null `isLaw`, so
              it matches neither `true` nor `false`: use `enactmentOutcome` for
              those. Anything but a boolean is a 422.
            examples:
              - false
            title: Islaw
          description: >-
            `true`: only measures that are law. `false`: only numbered measures
            that are NOT law (a vetoed bill, a pocket veto), the ones `isLaw:
            false` marks. Omit for both. A measure whose outcome does not settle
            it (`not_presented`, `unknown`) has a null `isLaw`, so it matches
            neither `true` nor `false`: use `enactmentOutcome` for those.
            Anything but a boolean is a 422.
        - name: enactmentOutcome
          in: query
          required: false
          schema:
            anyOf:
              - type: array
                items:
                  type: string
                  enum:
                    - signed
                    - became_law_without_signature
                    - veto_overridden
                    - line_item_veto
                    - vetoed
                    - pocket_veto
                    - not_presented
                    - approved_by_voters
                    - unknown
              - type: 'null'
            description: >-
              Only laws with one of these outcomes. Repeat the parameter for
              several (`enactmentOutcome=vetoed&enactmentOutcome=pocket_veto`);
              they combine with OR. One of `signed`,
              `became_law_without_signature`, `veto_overridden`,
              `line_item_veto`, `vetoed`, `pocket_veto`, `not_presented`,
              `approved_by_voters`, `unknown`, as `enactmentOutcome` reports it.
              Any other value is a 422, never charged; a valid outcome nothing
              matches returns an empty page (charged). The order you send them
              in does not matter, and a cursor stays valid for the same set.
            examples:
              - - vetoed
                - pocket_veto
            title: Enactmentoutcome
          description: >-
            Only laws with one of these outcomes. Repeat the parameter for
            several (`enactmentOutcome=vetoed&enactmentOutcome=pocket_veto`);
            they combine with OR. One of `signed`,
            `became_law_without_signature`, `veto_overridden`, `line_item_veto`,
            `vetoed`, `pocket_veto`, `not_presented`, `approved_by_voters`,
            `unknown`, as `enactmentOutcome` reports it. Any other value is a
            422, never charged; a valid outcome nothing matches returns an empty
            page (charged). The order you send them in does not matter, and a
            cursor stays valid for the same set.
        - name: updatedSince
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                pattern: ^\d{4}-\d{2}-\d{2}$
              - type: 'null'
            description: >-
              Only laws whose record changed on or after this date, midnight
              UTC, by `updatedAt`: the filter for a sync job that pulls only
              what is new or corrected since its last run. Format `YYYY-MM-DD`,
              inclusive; it must be a real calendar date (`2025-02-30` is a
              422). A day with no change returns an empty page (charged), not an
              error.
            examples:
              - '2026-10-01'
            format: date
            title: Updatedsince
          description: >-
            Only laws whose record changed on or after this date, midnight UTC,
            by `updatedAt`: the filter for a sync job that pulls only what is
            new or corrected since its last run. Format `YYYY-MM-DD`, inclusive;
            it must be a real calendar date (`2025-02-30` is a 422). A day with
            no change returns an empty page (charged), not an error.
        - name: q
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                minLength: 3
                maxLength: 100
              - type: 'null'
            description: >-
              Only laws whose `title` or printed `billNumber` contains this
              text, case-insensitively (`grain buyers` finds `An act relating to
              agriculture; modifying financial reporting requirements for grain
              buyers ...`). A plain substring, not a search engine: no stemming,
              no ranking, and `%` and `_` mean themselves. The bill number is
              matched as the publisher prints it (`S.F.No. 1552`, not `SF
              1552`): to find a law by citation, use `GET
              /us/session-laws/{sessionLawId}`. 3 to 100 characters after
              trimming and without control characters, else a 422 (never
              charged); text that matches nothing returns an empty page
              (charged). Combines with the other filters by AND within the
              required `jurisdiction`.
            examples:
              - grain buyers
            title: Q
          description: >-
            Only laws whose `title` or printed `billNumber` contains this text,
            case-insensitively (`grain buyers` finds `An act relating to
            agriculture; modifying financial reporting requirements for grain
            buyers ...`). A plain substring, not a search engine: no stemming,
            no ranking, and `%` and `_` mean themselves. The bill number is
            matched as the publisher prints it (`S.F.No. 1552`, not `SF 1552`):
            to find a law by citation, use `GET
            /us/session-laws/{sessionLawId}`. 3 to 100 characters after trimming
            and without control characters, else a 422 (never charged); text
            that matches nothing returns an empty page (charged). Combines with
            the other filters by AND within the required `jurisdiction`.
        - name: cursor
          in: query
          required: false
          schema:
            anyOf:
              - type: string
                maxLength: 600
              - type: 'null'
            description: >-
              Where to resume: the previous page's `nextCursor`, unchanged. Send
              it with the same filters that produced it (`limit` may change). It
              is opaque, signed and tied to those filters, and is only ever
              issued by this API: a value we did not issue is a 422 with
              `reason: invalid_cursor`, one from an older cursor format is
              `cursor_expired`, and one sent with different filters is
              `cursor_query_mismatch` (restart without `cursor`). Never an empty
              page. Omit for the first page.
            examples:
              - >-
                eyJ2IjoyLCJqIjoibW4iLCJzIjoiMjAyNVIiLCJpIjoiU1NMX01OXzIwMjVSX0dfWTIwMjVfQzEwIiwicSI6IjYxMjk2NDEzOTE2OTJmOTYifQ.86d0NXnVAJD7j_3d9zoWPQ
            title: Cursor
          description: >-
            Where to resume: the previous page's `nextCursor`, unchanged. Send
            it with the same filters that produced it (`limit` may change). It
            is opaque, signed and tied to those filters, and is only ever issued
            by this API: a value we did not issue is a 422 with `reason:
            invalid_cursor`, one from an older cursor format is
            `cursor_expired`, and one sent with different filters is
            `cursor_query_mismatch` (restart without `cursor`). Never an empty
            page. Omit for the first page.
        - name: limit
          in: query
          required: false
          schema:
            type: integer
            maximum: 200
            minimum: 1
            description: >-
              Rows per page, 1 to 200; default 50. A page costs the same however
              many rows it holds, so a larger `limit` is cheaper per law.
              Outside the range is a 422.
            examples:
              - 25
            default: 50
            title: Limit
          description: >-
            Rows per page, 1 to 200; default 50. A page costs the same however
            many rows it holds, so a larger `limit` is cheaper per law. Outside
            the range is a 422.
      responses:
        '200':
          description: >-
            A page of the state's session laws. `hasMore` and `nextCursor` say
            whether another follows; an empty `results` is a charged answer,
            unless `coverage` says the session or state is not fully collected.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SessionLawListResponse'
              examples:
                search:
                  summary: >-
                    jurisdiction=mn&q=court fees: laws whose title or bill
                    number contains the text
                  value:
                    results:
                      - sessionLawId: SSL_MN_2025R_G_Y2025_C10
                        jurisdiction: mn
                        citation: CHAPTER 10--H.F.No. 2184
                        citableAs: Minn. Laws 2025, ch. 10
                        citationShort: MN ch. 10 (2025)
                        session:
                          code: 2025R
                          label: 2025 Regular Session
                          type: regular
                          year: 2025
                        series: general
                        instrumentType: act
                        number: '10'
                        billNumber: H.F.No. 2184
                        numberingYear: 2025
                        title: >-
                          An act relating to court fees; exempting the Office of
                          Ombudsperson for American Indian Families from court
                          fee requirements; amending Minnesota Statutes 2024,
                          section 357.021, subdivision 1a.
                        approvedDate: '2025-04-30'
                        approvedDateDerived: false
                        enactmentOutcome: signed
                        isLaw: true
                        textStatus: held
                        charCount: 4561
                        estimatedBodyPages: 1
                        textSha256: >-
                          6c4008d050a5b85a7eaf03cd6f26ccca5160f015bbeb7bf9dceece9bd8bcd8d9
                        versionNo: 1
                        amendatoryMarkup: preserved
                        markupConvention: publisher_literal
                        documentKind: session_law_print
                        identityConfidence: single_source
                        licenseNote: >-
                          Government public: published by a government body with
                          no restrictive terms, so the text may be reused,
                          including commercially.
                        updatedAt: '2026-10-05T09:06:39.998043+00:00'
                    count: 1
                    hasMore: false
                    processingTimeMs: 204.1
                    creditsConsumed: 1
                session:
                  summary: jurisdiction=mn&session=2025R&limit=2
                  value:
                    results:
                      - sessionLawId: SSL_MN_2025R_G_Y2025_C1
                        jurisdiction: mn
                        citation: CHAPTER 1--S.F.No. 1552
                        citableAs: Minn. Laws 2025, ch. 1
                        citationShort: MN ch. 1 (2025)
                        session:
                          code: 2025R
                          label: 2025 Regular Session
                          type: regular
                          year: 2025
                        series: general
                        instrumentType: act
                        number: '1'
                        billNumber: S.F.No. 1552
                        numberingYear: 2025
                        title: >-
                          An act relating to agriculture; modifying financial
                          reporting requirements for grain buyers; amending
                          Minnesota Statutes 2024, section 223.17, subdivision
                          6.
                        approvedDate: '2025-03-17'
                        approvedDateDerived: false
                        enactmentOutcome: signed
                        isLaw: true
                        textStatus: held
                        charCount: 5470
                        estimatedBodyPages: 1
                        textSha256: >-
                          55c7a8d08647e41f87e23fc2016881a6583911a1d5cfa8687403442e9096451b
                        versionNo: 1
                        amendatoryMarkup: preserved
                        markupConvention: publisher_literal
                        documentKind: session_law_print
                        identityConfidence: single_source
                        licenseNote: >-
                          Government public: published by a government body with
                          no restrictive terms, so the text may be reused,
                          including commercially.
                        updatedAt: '2026-10-05T09:06:39.998043+00:00'
                      - sessionLawId: SSL_MN_2025R_G_Y2025_C10
                        jurisdiction: mn
                        citation: CHAPTER 10--H.F.No. 2184
                        citableAs: Minn. Laws 2025, ch. 10
                        citationShort: MN ch. 10 (2025)
                        session:
                          code: 2025R
                          label: 2025 Regular Session
                          type: regular
                          year: 2025
                        series: general
                        instrumentType: act
                        number: '10'
                        billNumber: H.F.No. 2184
                        numberingYear: 2025
                        title: >-
                          An act relating to court fees; exempting the Office of
                          Ombudsperson for American Indian Families from court
                          fee requirements; amending Minnesota Statutes 2024,
                          section 357.021, subdivision 1a.
                        approvedDate: '2025-04-30'
                        approvedDateDerived: false
                        enactmentOutcome: signed
                        isLaw: true
                        textStatus: held
                        charCount: 4561
                        estimatedBodyPages: 1
                        textSha256: >-
                          6c4008d050a5b85a7eaf03cd6f26ccca5160f015bbeb7bf9dceece9bd8bcd8d9
                        versionNo: 1
                        amendatoryMarkup: preserved
                        markupConvention: publisher_literal
                        documentKind: session_law_print
                        identityConfidence: single_source
                        licenseNote: >-
                          Government public: published by a government body with
                          no restrictive terms, so the text may be reused,
                          including commercially.
                        updatedAt: '2026-10-05T09:06:39.998043+00:00'
                    count: 2
                    nextCursor: >-
                      eyJ2IjoyLCJqIjoibW4iLCJzIjoiMjAyNVIiLCJpIjoiU1NMX01OXzIwMjVSX0dfWTIwMjVfQzEwIiwicSI6IjYxMjk2NDEzOTE2OTJmOTYifQ.86d0NXnVAJD7j_3d9zoWPQ
                    hasMore: true
                    processingTimeMs: 186.4
                    creditsConsumed: 1
                effectiveDate:
                  summary: >-
                    jurisdiction=tx&effectiveFrom=2025-09-01&effectiveTo=2025-09-01&limit=2
                  value:
                    results:
                      - sessionLawId: SSL_TX_2025R_G_Y2025_C1
                        jurisdiction: tx
                        citation: 89th Regular Session, ch. 1
                        citableAs: 2025 Tex. Gen. Laws ch. 1
                        citationShort: TX ch. 1 (2025)
                        session:
                          code: 2025R
                          label: 89th Regular Session
                          type: regular
                          year: 2025
                        series: general
                        instrumentType: act
                        number: '1'
                        billNumber: S.B. No. 14
                        numberingYear: 2025
                        title: >-
                          Relating to reforming the procedure by which state
                          agencies adopt rules and impose regulatory
                          requirements and the deference given to the
                          interpretation of laws and rules by state agencies in
                          certain judicial proceedings.
                        approvedDate: '2025-04-23'
                        approvedDateDerived: false
                        effectiveFirst: '2025-09-01'
                        effectiveLast: '2025-09-01'
                        enactmentOutcome: signed
                        isLaw: true
                        textStatus: held
                        charCount: 18449
                        estimatedBodyPages: 1
                        textSha256: >-
                          27df48f5be5c3d8b6a13832b064710b7584cd26b1dd1de0033f085dd3249f257
                        versionNo: 1
                        amendatoryMarkup: preserved
                        markupConvention: mixed
                        documentKind: enrolled_bill
                        identityConfidence: single_source
                        licenseNote: >-
                          Government public: published by a government body with
                          no restrictive terms, so the text may be reused,
                          including commercially.
                        updatedAt: '2026-10-05T09:04:11.120118+00:00'
                      - sessionLawId: SSL_TX_2025R_G_Y2025_C10
                        jurisdiction: tx
                        citation: 89th Regular Session, ch. 10
                        citableAs: 2025 Tex. Gen. Laws ch. 10
                        citationShort: TX ch. 10 (2025)
                        session:
                          code: 2025R
                          label: 89th Regular Session
                          type: regular
                          year: 2025
                        series: general
                        instrumentType: act
                        number: '10'
                        billNumber: S.B. No. 711
                        numberingYear: 2025
                        title: >-
                          Relating to property owners' associations, including
                          condominium unit owners' associations.
                        approvedDate: '2025-05-13'
                        approvedDateDerived: false
                        effectiveFirst: '2025-09-01'
                        effectiveLast: '2025-09-01'
                        enactmentOutcome: signed
                        isLaw: true
                        textStatus: held
                        charCount: 10764
                        estimatedBodyPages: 1
                        textSha256: >-
                          8d82fb97105d63cd50ec09865c1591cbaa8d3996f813951bba4f9a52bdb8e92b
                        versionNo: 1
                        amendatoryMarkup: preserved
                        markupConvention: mixed
                        documentKind: enrolled_bill
                        identityConfidence: single_source
                        licenseNote: >-
                          Government public: published by a government body with
                          no restrictive terms, so the text may be reused,
                          including commercially.
                        updatedAt: '2026-10-05T09:04:11.120118+00:00'
                    count: 2
                    nextCursor: >-
                      eyJ2IjoyLCJqIjoidHgiLCJzIjoiMjAyNVIiLCJpIjoiU1NMX1RYXzIwMjVSX0dfWTIwMjVfQzEwIiwicSI6IjMzYmM2NWQ5MWU2ZjAyZjUifQ.V2XakPeIVCCaxSqKPBCbFg
                    hasMore: true
                    processingTimeMs: 231.9
                    creditsConsumed: 1
                emptyPartialSession:
                  summary: >-
                    jurisdiction=ok&session=2025R&q=zoning: an empty page in a
                    session we hold only part of. Not charged: the law may exist
                  value:
                    results: []
                    count: 0
                    hasMore: false
                    coverage:
                      scope: session
                      jurisdiction: ok
                      status: partial
                      session:
                        code: 2025R
                        label: Oklahoma Session Laws - 2025
                        type: regular
                        year: 2025
                      sessionsHeld: 1
                      partialSessions:
                        - 2025R
                      message: >-
                        No law in session 2025R matches your filters, but we
                        hold only part of this session, so the law you want may
                        exist. This page was not charged.
                    processingTimeMs: 47.2
                    creditsConsumed: 0
                emptyCompleteSession:
                  summary: >-
                    jurisdiction=mn&session=2025R&q=zzz: an empty page in a
                    session we hold in full. Charged: nothing matches
                  value:
                    results: []
                    count: 0
                    hasMore: false
                    coverage:
                      scope: session
                      jurisdiction: mn
                      status: complete
                      session:
                        code: 2025R
                        label: 2025 Regular Session
                        type: regular
                        year: 2025
                      sessionsHeld: 2
                      partialSessions: []
                      message: >-
                        No law in session 2025R matches your filters. We hold
                        every law the publisher lists for it, so this is not a
                        gap in our collection.
                    processingTimeMs: 51.8
                    creditsConsumed: 1
                emptyNotHeld:
                  summary: >-
                    jurisdiction=in: a state we hold no session laws for. Not
                    charged
                  value:
                    results: []
                    count: 0
                    hasMore: false
                    coverage:
                      scope: jurisdiction
                      jurisdiction: in
                      status: not_held
                      sessionsHeld: 0
                      partialSessions: []
                      reason: >-
                        Indiana publishes its session laws only through a
                        service that needs an access token we do not hold yet.
                      message: >-
                        Indiana publishes its session laws only through a
                        service that needs an access token we do not hold yet.
                        This page was not charged.
                    processingTimeMs: 38.6
                    creditsConsumed: 0
        '401':
          description: Missing, invalid or revoked API key. Not charged.
          content:
            application/json:
              example:
                detail: Invalid or expired API key
              schema:
                $ref: '#/components/schemas/ApiDetailError'
        '402':
          description: >-
            Insufficient credits for this call. Nothing was done and nothing was
            charged. Read your balance, free, at `GET /credits/balance`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiDetailError'
              example:
                detail: Insufficient credits
        '403':
          description: The API key lacks the `research:read` scope. Not charged.
          content:
            application/json:
              example:
                detail: Insufficient permissions for this operation
              schema:
                $ref: '#/components/schemas/ApiDetailError'
        '422':
          description: >-
            A parameter failed validation: `jurisdiction` missing or not a
            state, a malformed filter or date (`enactmentOutcome` outside its
            vocabulary, `q` shorter than 3 characters), `limit` out of range, or
            a `cursor` we did not issue. Never charged. `errors[].loc` names the
            parameter exactly as you send it.
          content:
            application/json:
              examples:
                missingJurisdiction:
                  summary: '`jurisdiction` omitted'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - jurisdiction
                        msg: Field required
                        type: missing
                federalJurisdiction:
                  summary: >-
                    `jurisdiction=federal`: federal acts are on
                    /us/statutes/section
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - jurisdiction
                        msg: >-
                          Value error, Unknown `jurisdiction` value 'federal'.
                          Expected one of: al, ak, as, az, ar, ca, co, ct, de,
                          dc, fl, ga, gu, hi, id, il, in, ia, ks, ky, la, me,
                          md, ma, mi, mn, ms, mo, mt, ne, nv, nh, nj, nm, ny,
                          nc, nd, mp, oh, ok, or, pa, pr, ri, sc, sd, tn, tx,
                          ut, vt, vi, va, wa, wv, wi, wy.
                        type: value_error
                impossibleDate:
                  summary: '`effectiveFrom=2025-02-30`'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - effectiveFrom
                        msg: >-
                          Value error, `effectiveFrom` must be a real calendar
                          date in YYYY-MM-DD form.
                        type: value_error
                limitTooLarge:
                  summary: '`limit=500`'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - limit
                        msg: Input should be less than or equal to 200
                        type: less_than_equal
                badEnactmentOutcome:
                  summary: '`enactmentOutcome=bogus`'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - enactmentOutcome
                          - 0
                        msg: >-
                          Input should be 'signed',
                          'became_law_without_signature', 'veto_overridden',
                          'line_item_veto', 'vetoed', 'pocket_veto',
                          'not_presented', 'approved_by_voters' or 'unknown'
                        type: literal_error
                qTooShort:
                  summary: '`q=ab`: at least 3 characters'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - q
                        msg: String should have at least 3 characters
                        type: string_too_short
                impossibleUpdatedSince:
                  summary: '`updatedSince=2026-02-30`'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - updatedSince
                        msg: >-
                          Value error, `updatedSince` must be a real calendar
                          date in YYYY-MM-DD form.
                        type: value_error
                badTextStatus:
                  summary: '`textStatus=bogus`'
                  value:
                    detail: Invalid request parameters
                    errors:
                      - loc:
                          - query
                          - textStatus
                        msg: >-
                          Input should be 'held', 'withheld', 'not_held' or
                          'pending'
                        type: literal_error
                reversedDateRange:
                  summary: >-
                    `effectiveFrom=2025-09-30&effectiveTo=2025-09-01` (an end
                    before the start)
                  value:
                    detail: >-
                      `effectiveFrom` (2025-09-30) must not be after
                      `effectiveTo` (2025-09-01). Swap them, or send the same
                      date to both for a single day.
                badCursor:
                  summary: A `cursor` this API did not issue
                  value:
                    detail: '`cursor` is not one this API issued.'
                    reason: invalid_cursor
                cursorQueryMismatch:
                  summary: A `cursor` sent with different filters than produced it
                  value:
                    detail: >-
                      `cursor` was issued for a different query. Send it only
                      with the filters that produced it, or restart without
                      `cursor`.
                    reason: cursor_query_mismatch
                cursorExpired:
                  summary: A `cursor` from before the cursor format changed
                  value:
                    detail: >-
                      `cursor` is from an earlier version of this API and has
                      expired. Restart without `cursor`.
                    reason: cursor_expired
              schema:
                $ref: '#/components/schemas/ApiDetailError'
        '429':
          description: >-
            Rate limit exceeded for your key. Not charged. Wait `Retry-After`
            seconds.
          headers:
            Retry-After:
              description: Seconds to wait before retrying.
              schema:
                type: integer
                examples:
                  - 12
            X-RateLimit-Limit:
              description: Requests per minute your key is allowed.
              schema:
                type: integer
                examples:
                  - 60
            X-RateLimit-Remaining:
              description: Requests left in the current minute. 0 on a 429.
              schema:
                type: integer
                examples:
                  - 0
            X-RateLimit-Reset:
              description: Unix time at which the minute window resets.
              schema:
                type: integer
                examples:
                  - 1791194460
          content:
            application/json:
              example:
                detail: Rate limit exceeded. Try again in 12 seconds.
              schema:
                $ref: '#/components/schemas/ApiDetailError'
        '500':
          description: An unexpected failure on our side. The charge is refunded.
          content:
            application/json:
              example:
                detail: Internal server error
              schema:
                $ref: '#/components/schemas/ApiDetailError'
        '503':
          description: >-
            The session-laws database is temporarily unavailable. The charge is
            refunded; retry.
          content:
            application/json:
              example:
                detail: >-
                  The US session-laws database is temporarily unavailable.
                  Please retry.
              schema:
                $ref: '#/components/schemas/ApiDetailError'
components:
  schemas:
    SessionLawListResponse:
      properties:
        processingTimeMs:
          type: number
          title: Processingtimems
          description: >-
            Server-side time for this request in milliseconds, excluding network
            transit. Not billed on.
          default: 0
          examples:
            - 747.5
        creditsConsumed:
          type: integer
          title: Creditsconsumed
          description: >-
            Credits actually charged for this call, never the list price. It
            includes the `/us/statutes/resolve` fee when a citation was sent
            where an id goes. 0 when the call was not charged or was refunded (a
            body that answers `available: false`).
          default: 0
          examples:
            - 2
        results:
          items:
            $ref: '#/components/schemas/SessionLawSummary'
          type: array
          title: Results
          description: >-
            The page of laws, by `session.code` and then `sessionLawId`, both as
            text in the database's collation, not chapter order (so `..._C10`
            comes before `..._C2`; sort by `number` client-side if you need
            chapter order). The record without its dates list, sources or text:
            fetch those with `GET /us/session-laws/{sessionLawId}`.
        count:
          type: integer
          title: Count
          description: >-
            Rows on this page. Never a total: the list is paged by cursor and
            has no corpus-wide count.
          default: 0
          examples:
            - 25
        nextCursor:
          anyOf:
            - type: string
            - type: 'null'
          title: Nextcursor
          description: >-
            Opaque cursor for the next page: send it as `cursor`, with the same
            filters. Null on the last page.
          examples:
            - >-
              eyJ2IjoxLCJqIjoibW4iLCJzIjoiMjAyNVIiLCJpIjoiU1NMX01OXzIwMjVSX0dfWTIwMjVfQzEzIn0
        hasMore:
          type: boolean
          title: Hasmore
          description: >-
            True when another page follows. Each page is charged, an empty one
            included, except an empty page that `coverage` reports as a gap in
            our collection.
          default: false
          examples:
            - true
        coverage:
          anyOf:
            - $ref: '#/components/schemas/SessionLawListCoverage'
            - type: 'null'
          description: >-
            Present only on an EMPTY page: what we hold of the session (or
            state) you asked about, so you can tell `nothing matches your
            filters` from `we have not collected this`. `status: complete` means
            the first: the page is charged. `partial` (the collection stopped
            short) and `not_held` (we hold nothing of it) mean the second: the
            page is NOT charged and `creditsConsumed` is 0. Omitted when the
            coverage cannot be read, in which case the empty page is charged as
            before.
      type: object
      title: SessionLawListResponse
      description: Response for `GET /us/session-laws/list`.
    ApiDetailError:
      properties:
        detail:
          type: string
          title: Detail
          description: >-
            Human-readable reason, safe to surface to an end user. Branch on the
            HTTP status rather than on this string: the wording is not part of
            the contract and may be reworded, but 401 (bad key), 402 (out of
            credits), 403 (missing scope), 404 (no such resource) and 429 (rate
            limited) are stable.
          examples:
            - Insufficient API credits.
        errors:
          anyOf:
            - items:
                $ref: '#/components/schemas/ApiFieldError'
              type: array
            - type: 'null'
          title: Errors
          description: 'Present on 422 only: every field that failed validation.'
      type: object
      required:
        - detail
      title: ApiDetailError
      description: >-
        Error envelope the API actually returns.


        Every error (400/401/402/403/404/405/422/429/5xx) carries a `detail`

        string, e.g. `{"detail": "Insufficient API credits."}`, on every mount
        of

        the API. A 422 adds `errors`, one entry per rejected field. Some 404s
        add

        endpoint-specific diagnosis beside `detail` (the statutes section routes

        add `actId`, `reason` and `didYouMean`); treat unknown keys as optional.
    SessionLawSummary:
      properties:
        sessionLawId:
          type: string
          title: Sessionlawid
          description: >-
            Permanent identifier of the law, the key to use everywhere. Shape
            `SSL_{state}_{session
            code}_{series}[_Y{numberingYear}]_{C<chapter>|B<billKey>}`. It never
            changes: a correction to our reading of a law keeps the old id
            working. Pass it to `GET /us/session-laws/{sessionLawId}`.
          examples:
            - SSL_MN_2025R_G_Y2025_C1
        lawId:
          anyOf:
            - type: string
            - type: 'null'
          title: Lawid
          description: >-
            The law's identifier in the open us1 scheme. Null until its identity
            is confirmed by a second source and the us1 state shape is minted,
            so it is null on every state law today. Use `sessionLawId`, which is
            always present.
          examples:
            - null
        jurisdiction:
          type: string
          title: Jurisdiction
          description: >-
            Lowercase two-letter code of the state, `dc` or `pr`. Federal acts
            are not served by this family: they are on `/us/statutes/section`.
          examples:
            - mn
        citation:
          type: string
          title: Citation
          description: >-
            The act's citation as its publisher prints it, falling back to
            `{session label}, ch. {number}` when none is printed. It is NOT
            unique: many states print a bare `CHAPTER 1` every session. Key on
            `sessionLawId`.
          examples:
            - CHAPTER 1--S.F.No. 1552
            - ACT No. 2
            - Chapter 1, Laws of 2025
        citableAs:
          anyOf:
            - type: string
            - type: 'null'
          title: Citableas
          description: >-
            The law cited the way a lawyer writes it, from the state's own form:
            `Minn. Laws 2025, ch. 1`, `2025 Fla. Laws ch. 3`, `Ill. Pub. Act
            104-0001`, `S.L. 2025-12` (North Carolina), `Stats. 2025, ch. 12`
            (California), `Ohio S.B. 1 (2025)` for a state that numbers no
            chapters. A law in a special or extraordinary session carries it
            (`Minn. Laws 2025, 1st Spec. Sess., ch. 1`). Every value is read
            back through the grammar that `GET /us/session-laws/{sessionLawId}`
            accepts a citation in, and must name this law; one that would not is
            null, never guessed. Null where the state's form is not known, for a
            series with no standard form (resolutions, memorials), or for a law
            with neither a chapter nor a bill key. Where a regular and a special
            session each have a chapter 1, the bare form is the regular
            session's law and resolves with that law flagged as the default; the
            special session's carries its session. Distinct from `citation`,
            which is the publisher's printed form.
          examples:
            - Minn. Laws 2025, ch. 1
            - 2025 Tex. Gen. Laws ch. 1
            - null
        citationShort:
          anyOf:
            - type: string
            - type: 'null'
          title: Citationshort
          description: >-
            A compact label for tables and badges: `MN ch. 1 (2025)`, `IL P.A.
            104-0001`, `OH S.B. 1 (2025)`. Not a form to send back: use
            `citableAs` or the `sessionLawId`. Null exactly when `citableAs` is
            null.
          examples:
            - MN ch. 1 (2025)
            - TX ch. 1 (2025)
            - null
        session:
          $ref: '#/components/schemas/SessionLawSession'
          description: The legislative session the law was enacted in.
        series:
          type: string
          title: Series
          description: >-
            The numbering series the law belongs to within its session. Most
            states have one, `general`. Others number acts, resolutions or local
            laws separately (`public`, `act`, `acts`, `law`, `public_act`,
            `resolve`, `resolution_chapter`, `local`, ...). An open list that
            grows as jurisdictions load. Filter with `series` on the list.
          examples:
            - general
        instrumentType:
          type: string
          title: Instrumenttype
          description: >-
            What kind of measure this is: `act`, `joint_resolution`,
            `concurrent_resolution`, `resolution`, `resolve`, `memorial` or
            `other`. An open list. A resolution that was numbered and published
            among the session laws is included, with `isLaw` saying whether it
            binds as law.
          examples:
            - act
        number:
          anyOf:
            - type: string
            - type: 'null'
          title: Number
          description: >-
            The chapter or act number exactly as printed, as a string. It is not
            always an integer: `1`, `2025-12` (Florida), `104-0001` (Illinois),
            `1A`. Null where the state does not number its acts (see `billKey`).
          examples:
            - '1'
            - 2025-12
        billKey:
          anyOf:
            - type: string
            - type: 'null'
          title: Billkey
          description: >-
            Normalised bill identifier (chamber and type letters plus the
            number) that stands in for a chapter number in states that do not
            number their acts (Missouri, Ohio, Nebraska). `House Bill 2` is
            `HB2`. Null whenever `number` is set. Part of the `sessionLawId` as
            `B<billKey>`.
          examples:
            - HB2
            - null
        billNumber:
          anyOf:
            - type: string
            - type: 'null'
          title: Billnumber
          description: >-
            The bill the act originated as, as the publisher prints it. Matches
            as a citation on `GET /us/session-laws/{sessionLawId}`.
          examples:
            - S.F.No. 1552
            - House Bill 2
        numberingYear:
          anyOf:
            - type: integer
            - type: 'null'
          title: Numberingyear
          description: >-
            The year of the numbering sequence the chapter number belongs to,
            where the state numbers by year (Minnesota, Florida, Texas). It
            appears in the `sessionLawId` as `_Y2025`. A chapter number is only
            unique within a session and numbering year: Minnesota's regular and
            first special sessions of 2025 each have a Chapter 1. Null where one
            sequence runs across the session (Louisiana).
          examples:
            - 2025
            - null
        title:
          anyOf:
            - type: string
            - type: 'null'
          title: Title
          description: >-
            The act's long title as printed, usually beginning `An act relating
            to`. It names the code sections the act amends in prose.
          examples:
            - >-
              An act relating to agriculture; modifying financial reporting
              requirements for grain buyers; amending Minnesota Statutes 2024,
              section 223.17, subdivision 6.
        shortTitle:
          anyOf:
            - type: string
            - type: 'null'
          title: Shorttitle
          description: >-
            The act's short title when the publisher gives one (Ohio, New York,
            the District of Columbia and a few others do), otherwise null.
          examples:
            - Enact Advance Ohio Higher Education Act
            - null
        approvedDate:
          anyOf:
            - type: string
              format: date
            - type: 'null'
          title: Approveddate
          description: >-
            Date the governor (or the equivalent authority) approved the act,
            ISO 8601. Never an effective date: an act is usually in force on a
            different day, which is `effectiveDates`. Null when the publisher
            prints no approval date. Where the registry holds none but the
            publisher's own dated label on `otherDates` names the governor's
            signature, it is filled from that label and `approvedDateDerived` is
            true. The `approvedFrom` and `approvedTo` filters do NOT match a
            derived date: they read the registry's own approval date.
          examples:
            - '2025-03-17'
        approvedDateDerived:
          type: boolean
          title: Approveddatederived
          description: >-
            True only when `approvedDate` was not held as an approval date and
            we filled it from a dated label printed on the act (today South
            Dakota's `Signed by the Governor`, listed under `otherDates`), on an
            act whose `enactmentOutcome` is `signed` or `line_item_veto`. False
            when `approvedDate` is null or is the registry's own. We never read
            a `presented` or `passed` date as an approval, nor a signing label
            on an act that became law without signature.
          default: false
          examples:
            - false
            - true
        effectiveFirst:
          anyOf:
            - type: string
              format: date
            - type: 'null'
          title: Effectivefirst
          description: >-
            Earliest of the act's effective dates we hold. Null when we hold
            none: a date the publisher does not print, or prints as a relative
            rule (`the day following final enactment`), is not guessed. The full
            list is `effectiveDates` on `GET /us/session-laws/{sessionLawId}`.
          examples:
            - '2025-09-01'
            - null
        effectiveLast:
          anyOf:
            - type: string
              format: date
            - type: 'null'
          title: Effectivelast
          description: >-
            Latest of the act's effective dates we hold. Equal to
            `effectiveFirst` for an act with one date; null when we hold none.
          examples:
            - '2026-01-01'
            - null
        enactmentOutcome:
          type: string
          title: Enactmentoutcome
          description: >-
            How the measure became, or failed to become, law. `signed`;
            `became_law_without_signature`; `veto_overridden`; `line_item_veto`
            (signed with some items vetoed); `vetoed` and `pocket_veto` (not
            law); `not_presented` (no governor action recorded, usual for
            resolutions); `approved_by_voters`; `unknown` (the publisher does
            not say).
          examples:
            - signed
        isLaw:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Islaw
          description: >-
            True for an act that is law. False for a numbered measure that is
            not: a vetoed bill, a pocket veto. Null when `enactmentOutcome` does
            not settle it (`not_presented`, `unknown`).
          examples:
            - true
        textStatus:
          type: string
          enum:
            - held
            - withheld
            - not_held
            - pending
          title: Textstatus
          description: >-
            Whether we serve this law's text. `held`: the text is served by
            `/us/session-laws/{sessionLawId}/body`. `withheld`: we hold the text
            but a measured defect keeps it from being served, and
            `withheldReason` says what. `not_held`: we know the act exists and
            do not hold its text. `pending`: collected and not yet verified.
          examples:
            - held
        withheldReason:
          anyOf:
            - type: string
            - type: 'null'
          title: Withheldreason
          description: >-
            Present only when `textStatus` is `withheld`: a plain sentence
            saying what is wrong with the text we hold and what would release
            it. Free text, not an enum: show it, do not branch on it. The record
            itself (dates, sources, title) is still served and still correct.
          examples:
            - >-
              LA: struck (deleted) law is merged into the text as if current
              while the record declares the markup preserved or absent (audit
              2026-10-03). Awaiting a re-run with strike and underline recovery.
            - null
        charCount:
          anyOf:
            - type: integer
            - type: 'null'
          title: Charcount
          description: >-
            Length of the law's full text in characters, the same as
            `totalChars` on the body. Null when there is no text. It is reported
            for a withheld law too (a fact about the text we hold), though that
            text is not served.
          examples:
            - 5470
            - 310454
        estimatedBodyPages:
          anyOf:
            - type: integer
            - type: 'null'
          title: Estimatedbodypages
          description: >-
            How many body pages the text takes: `charCount` divided by the page
            size (30,000 characters), rounded up. Pages are cut back to a
            paragraph break, so a long act can run a few percent over. Null
            unless `textStatus` is `held`: there is nothing to read. Reading a
            whole law costs `estimatedBodyPages` times the price of one body
            page (6 credits per page on `GET
            /us/session-laws/{sessionLawId}/body`). Ohio's 2025 budget act (HB
            96) is 9,571,132 characters, about 320 pages or 1,920 credits to
            read in full; most acts are a page or two.
          examples:
            - 1
            - 11
        textSha256:
          anyOf:
            - type: string
            - type: 'null'
          title: Textsha256
          description: >-
            SHA-256 (hex) of the full text of this law. It changes only when the
            text does, so it is the cheap way to tell whether a copy you hold is
            current. Body pages carry the same value.
          examples:
            - 55c7a8d08647e41f87e23fc2016881a6583911a1d5cfa8687403442e9096451b
        versionNo:
          anyOf:
            - type: integer
            - type: 'null'
          title: Versionno
          description: >-
            Revision counter of our record of this law: 1 for the first
            collection, higher after a re-collection changed the text or the
            metadata. Not a legislative version.
          examples:
            - 1
        amendatoryMarkup:
          anyOf:
            - type: string
            - type: 'null'
          title: Amendatorymarkup
          description: >-
            Whether the language an amending act strikes and inserts survives in
            the text. `preserved`: it is in `text`, in the convention
            `markupConvention` names. `lost`: the publisher printed it and our
            text does not keep it, so deleted words can read as law: check the
            source before quoting. `absent`: the act carries no such markup that
            we found. `not_applicable`: there is no text to carry it.
          examples:
            - preserved
        markupConvention:
          anyOf:
            - type: string
            - type: 'null'
          title: Markupconvention
          description: >-
            How preserved markup is written, set only when `amendatoryMarkup` is
            `preserved`. `wdiff`: deleted language is `[-like this-]` and
            inserted language `{+like this+}`. `publisher_literal`: the
            publisher's own words are left as printed (Minnesota prints `new
            text begin` / `new text end` and `deleted text begin` / `deleted
            text end` markers). `mixed`: both in one text.
          examples:
            - publisher_literal
            - wdiff
        documentKind:
          anyOf:
            - type: string
            - type: 'null'
          title: Documentkind
          description: >-
            What kind of document the text was taken from: `session_law_print`
            (the publisher's printed chapter), `enrolled_bill`, `slip_law`,
            `volume_extract` (carved out of a bound volume) or `other`. An open
            list. Null when there is no text.
          examples:
            - session_law_print
            - enrolled_bill
        identityConfidence:
          type: string
          title: Identityconfidence
          description: >-
            How firmly the law's identity (session and number) is established.
            `single_source`: read from one publisher source, which is every
            state law at launch. `confirmed`: agreed by a second independent
            source, the level at which a `lawId` can be minted. `inferred`:
            derived by us rather than printed. `disputed`: sources disagree. The
            `sessionLawId` is the same at every level.
          examples:
            - single_source
        licenseNote:
          anyOf:
            - type: string
            - type: 'null'
          title: Licensenote
          description: >-
            What the law's licence class is and what it means for reuse, in a
            plain sentence: `Government public: published by a government body
            with no restrictive terms, so the text may be reused, including
            commercially.` Every law served with text is of a class that permits
            reuse; a note saying otherwise describes a record whose text is held
            back. Free text to show, not an enum to branch on: branch on
            `textStatus`.
          examples:
            - >-
              Government public: published by a government body with no
              restrictive terms, so the text may be reused, including
              commercially.
        updatedAt:
          anyOf:
            - type: string
            - type: 'null'
          title: Updatedat
          description: >-
            When this law's record last changed in our registry, ISO 8601 UTC
            with a `+00:00` offset, the same form as the statutes routes. Use it
            with `updatedSince` on the list to sync only what changed.
          examples:
            - '2026-10-05T09:06:39.998043+00:00'
      type: object
      required:
        - sessionLawId
        - jurisdiction
        - citation
        - session
        - series
        - instrumentType
        - enactmentOutcome
        - textStatus
        - identityConfidence
      title: SessionLawSummary
      description: One session law, as it appears in lists and citation results.
    SessionLawListCoverage:
      properties:
        scope:
          type: string
          enum:
            - session
            - jurisdiction
          title: Scope
          description: >-
            `session` when the request named a `session`, `jurisdiction` when it
            named only the state.
          examples:
            - session
            - jurisdiction
        jurisdiction:
          type: string
          title: Jurisdiction
          description: Lowercase two-letter code of the state, `dc` or `pr`.
          examples:
            - ok
        status:
          type: string
          enum:
            - complete
            - partial
            - not_held
          title: Status
          description: >-
            `complete`: we hold every law the publisher lists for what you asked
            about, so an empty page means nothing matches your filters, and it
            is charged. `partial`: the collection stopped short, so the empty
            page may be a gap in our collection and not an absence of law; it is
            not charged when everything you asked about is partial. On a
            state-wide request (`scope: jurisdiction`) with some sessions
            complete and some partial the status is `partial`, `partialSessions`
            names the ones to doubt, and the page is charged, because for the
            complete sessions it is a true negative. `not_held`: we hold no
            session laws for this session or state at all (a state whose
            publisher we cannot yet collect from, for example); not charged.
          examples:
            - complete
            - partial
            - not_held
        session:
          anyOf:
            - $ref: '#/components/schemas/SessionLawSession'
            - type: 'null'
          description: >-
            The session you named, when `scope` is `session` and we hold any of
            it. Its counts are in the jurisdiction's `sessionLaws` block on `GET
            /us/statutes/coverage`.
        sessionsHeld:
          type: integer
          minimum: 0
          title: Sessionsheld
          description: >-
            How many sessions of this state we hold session laws for. 0 when
            `not_held`.
          default: 0
          examples:
            - 1
            - 0
        partialSessions:
          items:
            type: string
          type: array
          title: Partialsessions
          description: >-
            Session codes of this state whose collection is `partial`: the ones
            an empty page may be missing laws from. Empty when none.
          examples:
            - - 2025R
            - []
        reason:
          anyOf:
            - type: string
            - type: 'null'
          title: Reason
          description: >-
            Present on `not_held`: why we hold nothing, in one plain sentence. A
            gap in our collection, not a statement that the state enacted no
            laws.
          examples:
            - >-
              Indiana publishes its session laws only through a service that
              needs an access token we do not hold yet.
        message:
          type: string
          title: Message
          description: >-
            One sentence saying what this empty page means and whether it was
            charged. Free text to show, not an enum to branch on: branch on
            `status`.
          examples:
            - >-
              No law in this session matches your filters. We hold every law the
              publisher lists for 2025R, so this is not a gap in our collection.
      type: object
      required:
        - scope
        - jurisdiction
        - status
        - message
      title: SessionLawListCoverage
      description: What we hold of the session or state an EMPTY page was asked about.
    ApiFieldError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Loc
          description: >-
            Where the bad value is: `body`, `query` or `path`, then the
            parameter name exactly as you send it (camelCase), then list
            indexes. A bare `["body"]` means the body as a whole was not a JSON
            object.
          examples:
            - - body
              - corpusType
        msg:
          type: string
          title: Msg
          description: What is wrong with the value, in plain English.
          examples:
            - Input should be 'USC', 'CFR' or 'STATE'
        type:
          type: string
          title: Type
          description: >-
            Machine-readable error kind, e.g. `missing`, `literal_error`,
            `json_invalid`.
          examples:
            - literal_error
      type: object
      required:
        - loc
        - msg
        - type
      title: ApiFieldError
      description: One rejected field in a 422 response.
    SessionLawSession:
      properties:
        code:
          type: string
          title: Code
          description: >-
            Session code, `{year}{type}{ordinal}`. `type` is `R` regular, `S`
            special, `X` extraordinary, `F` fiscal, `V` veto, `U` unknown. A
            regular session has no ordinal (`2025R`); a numbered special session
            carries it (`2025S1`, the first special session of 2025); a lettered
            one carries its letter (`2025SC`, Florida's Special Session C).
            `year` is the year the publisher numbers the session by, which for a
            period spanning two years is the first (District of Columbia Council
            Period 25 is `2023R`). Pass it as `session` to `GET
            /us/session-laws/list`.
          examples:
            - 2025R
            - 2025S1
        label:
          anyOf:
            - type: string
            - type: 'null'
          title: Label
          description: The session's canonical label, as the publisher names it.
          examples:
            - 2025 Regular Session
            - 2025 1st Special Session
        type:
          anyOf:
            - type: string
            - type: 'null'
          title: Type
          description: >-
            `regular`, `special`, `extraordinary`, `fiscal`, `veto` or
            `unknown`.
          examples:
            - regular
        year:
          anyOf:
            - type: integer
            - type: 'null'
          title: Year
          description: The year the session convened, the same year `code` starts with.
          examples:
            - 2025
      type: object
      required:
        - code
      title: SessionLawSession
      description: The legislative session a law was enacted in.
  securitySchemes:
    ApiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: vq_key_*
      description: >-
        API key issued from the developer dashboard. Pass as `Authorization:
        Bearer vq_key_...` (preferred).
    ApiKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
      description: >-
        The same API key as a bare header value: `X-API-Key: vq_key_...`.
        Equivalent to the Bearer form.
    ApiKeyQuery:
      type: apiKey
      in: query
      name: api_key
      description: >-
        The same API key as a query parameter: `?api_key=vq_key_...`. Use only
        where you cannot set a header. A URL can end up in proxy and server
        logs, browser history and shared links, so prefer either header form,
        and rotate a key that has leaked.

````

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