---
title: "List a state's session laws"
method: GET
path: "/api/v1/us/session-laws/list"
tags: ["US Session Laws"]
---

# List a state's session laws

`GET /api/v1/us/session-laws/list`

## Request

- Base URL: `https://api.vaquill.ai`
- URL: `https://api.vaquill.ai/api/v1/us/session-laws/list`
- Auth: one of:
  - HTTP bearer
  - API key in header `X-API-Key`
- TypeScript: <https://skmtc.dev/vaquill/apis/vaquill-developer-api/docs/api/v1/us/session-laws/list/get.ts> (a function with typed inputs; its response is checked against the schema)

List the session laws of one state: every act its legislature enacted, filtered by session,
approval date or effective date. Use it to ask "what became law in Texas this session" or "what
takes effect on September 1, 2025", and to collect the `sessionLawId`s the get and body endpoints
take. 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 (see Empty pages). A request that fails validation (422) is not charged; a failure on
our side (500, 503) is refunded.

**Common questions.** `jurisdiction` is required and scopes everything; the other filters combine
with AND, and each parameter documents its own rules.

| Question | Filter | Example |
| --- | --- | --- |
| Everything from one session | `session` | `session=2025R` |
| Approved in a window | `approvedFrom`, `approvedTo` | `approvedFrom=2025-04-01&approvedTo=2025-04-30` |
| Taking effect in a window or on one day | `effectiveFrom`, `effectiveTo` (laws whose first-to-last effective dates overlap the window; one day: the same date in both) | `effectiveFrom=2025-09-01&effectiveTo=2025-09-01` |
| Vetoed measures, or what did not become law | `isLaw`, `enactmentOutcome` (repeatable) | `isLaw=false&enactmentOutcome=vetoed` |
| Laws whose text can be read | `hasText`, `textStatus` | `hasText=true` |
| What changed since my last sync | `updatedSince` | `updatedSince=2026-10-01` |
| Find by words in the title or printed bill number | `q` | `q=court fees` |
| Narrow by numbering series or kind of measure | `series`, `instrumentType` | `series=general` |

A malformed value, or a range whose end precedes its start, is a 422. A well-formed value that
matches nothing (an unknown `session`, a date range with no laws) is a 200 with `results: []`.
Dates are `YYYY-MM-DD`. Read `effectiveFirst` and `effectiveLast` on each row and `effectiveDates`
on the law for the dates themselves. A date filter the data cannot satisfy for the state or session
(no law carries that kind of date) answers an empty page with `coverage.status: filter_unavailable`
naming `unavailableFilters`, not charged.

**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` | Meaning | Charged |
| --- | --- | --- |
| `complete` | We hold every law the publisher lists: a true negative. | Yes |
| `partial` | The collection stopped short, so the law you want may exist. | No (`creditsConsumed` 0) |
| `not_held` | We hold nothing of it. | No (`creditsConsumed` 0) |

A request that names only the state, where some held sessions are complete and some partial, is
charged (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 and `coverage` is omitted.

**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, and `order=desc` reverses it
exactly. 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, not 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. 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` (the law cited as a lawyer writes it, `Minn. Laws 2025, ch. 1`) and `licenseNote` (what
its licence class permits).

**Cost of reading a law.** Reading a whole law costs `estimatedBodyPages` times the price
of one body page (6 credits). `estimatedBodyPages` is on the record next to `charCount`
and is the most pages the text can take: a page holds up to 30,000 characters and is cut
back to a paragraph break, so a long act usually takes fewer. It is null when the text cannot be
read (it can be when served, or when withheld for a reason we label and `/body` reads with
`includeUnverified`). Most acts take a page or two. Each body response carries `pagePrice` and
`estimatedRemainingCredits`, 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&isLaw=false&enactmentOutcome=vetoed" \
  -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`, the sessions held and
  whether each is `complete` or `partial`. A law missing from a `partial` session may still exist.
- Federal session laws (the Statutes at Large, `SAL_` ids) are read with
  `GET /us/statutes/section/{actId}`, not here.

**Nulls.** Every response field is present: one with no value is `null` (`[]` for a list). The
examples here leave the nulls out. `publisher`, `provenance` and `session.coverageStatus` on a law,
and `coverage` on a list page with rows, are absent when they do not apply.

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

## Query parameters

- `jurisdiction` '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', required: Two-letter code of the jurisdiction whose session laws to list: the 56 jurisdictions (the 50 states, `dc` and the territories `pr`, `gu`, `vi`, `as`, `mp`). 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 returns an empty page with a `coverage` block saying so, which is not charged: see `sessionLaws` on `/us/statutes/coverage` for what is held.
- `session` string, nullable: 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. The case you send is matched to the stored code (`2025r` is `2025R`), and the cursor and `coverage` use the stored spelling. A code that matches no session returns an empty page, not an error: refunded with a `coverage` block when we hold no such session, charged when the session is held and nothing in it matches; characters other than letters, digits, `.`, `_` and `-` are a 422. Omit to list every session.
- `series` string[], nullable: Only laws in one of these numbering series; repeat the parameter for several (`series=resolve&series=resolves`), combined with OR. `general` is the ordinary chapter sequence of most states. 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`, `private`, `constitutional_resolution`, `competing_measure_resolution`, `resolution_act`. 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).
- `instrumentType` string[], nullable: 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.
- `approvedFrom` string, date, nullable: 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). Matches the `approvedDate` a row shows, including one we derived (`approvedDateDerived: true`); a law with no approval date never matches, nor does one whose date we serve as null. Pair with `approvedTo` for a range; an end before the start is a 422 (never charged).
- `approvedTo` string, date, nullable: 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 matches a derived `approvedDate` too.
- `effectiveFrom` string, date, nullable: 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 publisher prints one: a law without it is not returned, though it may be in force. For one day, send the same date to both `effectiveFrom` and `effectiveTo`.
- `effectiveTo` string, date, nullable: 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).
- `hasText` boolean, nullable: `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.
- `textStatus` 'held' | 'withheld' | 'not_held' | 'pending', nullable: 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.
- `isLaw` boolean, nullable: `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.
- `enactmentOutcome` string[], nullable: Only laws with one of these outcomes; repeat the parameter for several (`enactmentOutcome=vetoed&enactmentOutcome=pocket_veto`), combined with OR. One of `signed`, `became_law_without_signature`, `veto_overridden`, `line_item_veto`, `vetoed`, `pocket_veto`, `not_presented`, `approved_by_voters`, `unknown`. Any other value is a 422, never charged; a valid outcome nothing matches returns an empty page (charged). Their order does not matter.
- `updatedSince` string, date, nullable: 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.
- `q` string, nullable: 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 or ranking, and `%` and `_` mean themselves. Whitespace runs count as one space and curly quotes and typographic dashes as their plain forms, on both sides. 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).
- `order` 'asc' | 'desc': The order of the list: `asc` (default) is by session code, then by law id; `desc` is exactly the reverse, so the newest session comes first and, inside a session, the highest law id first. Law ids sort as text (`..._C10` before `..._C2`), as in `asc`. A cursor walks the direction that issued it: changing `order` between pages is a 422 `cursor_query_mismatch`. Anything else is a 422 and is never charged.
- `cursor` string, nullable: 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.
- `limit` integer: 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.

## Headers

- `Idempotency-Key` string, nullable: Optional. 16 to 255 visible ASCII characters (a UUIDv4 works). Repeating the same request with the same key replays the original 2xx response for 24 hours without charging again. The same key on a different request is rejected. With the account's `cacheQueryDerivedData` retention setting off, no body is stored and a retry answers 409 `idempotency_replay_unavailable`, still without a second charge.

## Response `200`

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.

- SessionLawListResponse: Response for `GET /us/session-laws/list`.
  - `processingTimeMs` number: Server-side time for this request in milliseconds, excluding network transit. Not billed on.
  - `creditsConsumed` integer: 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`).
  - `results` SessionLawSummary[]: 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}`.
    - `sessionLawId` string, required: 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}`.
    - `lawId` string, nullable: 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.
    - `jurisdiction` string, required: Lowercase two-letter code of the state, `dc` or `pr`. Federal acts are not served by this family: they are on `/us/statutes/section`.
    - `citation` string, required: 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`.
    - `citableAs` string, nullable: 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.
    - `citationShort` string, nullable: 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.
    - `session` SessionLawSession, required: The legislative session a law was enacted in.
      - `code` string, required: 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`.
      - `label` string, nullable: The session's canonical label, as the publisher names it.
      - `type` string, nullable: `regular`, `special`, `extraordinary`, `fiscal`, `veto` or `unknown`.
      - `year` integer, nullable: The year the session convened, the same year `code` starts with.
    - `series` string, required: 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.
    - `instrumentType` string, required: 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.
    - `number` string, nullable: 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`).
    - `billKey` string, nullable: 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>`.
    - `billNumber` string, nullable: The bill the act originated as, as the publisher prints it. Matches as a citation on `GET /us/session-laws/{sessionLawId}`.
    - `numberingYear` integer, nullable: 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).
    - `title` string, nullable: The act's long title as printed, usually beginning `An act relating to`. It names the code sections the act amends in prose.
    - `shortTitle` string, nullable: The act's short title when the publisher gives one (Ohio, New York, the District of Columbia and a few others do), otherwise null.
    - `approvedDate` string, date, nullable: 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.
    - `approvedDateDerived` boolean: 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.
    - `effectiveFirst` string, date, nullable: 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}`.
    - `effectiveLast` string, date, nullable: Latest of the act's effective dates we hold. Equal to `effectiveFirst` for an act with one date; null when we hold none.
    - `enactmentOutcome` string, required: 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).
    - `isLaw` boolean, nullable: 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`).
    - `textStatus` 'held' | 'withheld' | 'not_held' | 'pending', required: 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.
    - `withheldReason` string, nullable: 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.
    - `charCount` integer, nullable: 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.
    - `estimatedBodyPages` integer, nullable: The most body pages the text can take, so the price of reading the whole law is at most this times the body price. A page holds up to 30,000 characters but is cut back to a paragraph break, so it can be as short as 24,001; the estimate counts every page but the last at that shortest size, so a long act usually takes fewer pages than this and never more. Text that fits one page is 1. Present when the text can be read: `textStatus` is `held`, or `withheld` for a reason we can label (read it with `includeUnverified=true` on `/body`). Null otherwise. Reading a whole law costs `estimatedBodyPages` times the price of one body page (6 credits per page on `GET /us/session-laws/{sessionLawId}/body`); most acts are a page or two.
    - `textSha256` string, nullable: 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.
    - `versionNo` integer, nullable: 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.
    - `amendatoryMarkup` string, nullable: 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.
    - `markupConvention` string, nullable: 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.
    - `documentKind` string, nullable: 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.
    - `identityConfidence` string, required: 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.
    - `officialUrl` string, nullable: The PUBLISHER's page for this act, never a Vaquill URL: where a person goes to read the act at its legislature. Where the legislature keeps one page per bill (California, Virginia, New York) it is that page, rebuilt from the session and bill number, so it is present for a law we hold back or only know of. Elsewhere it is the government file the text was collected from (`sourceUrl`), which can be a volume covering many acts. `officialUrlBasis` says which. Null when we hold neither. Our own copy of the text is `GET /us/session-laws/{sessionLawId}/body`, a Vaquill service, and is never reported here.
    - `officialUrlBasis` string, nullable: How `officialUrl` was found: `bill_page` (the publisher's page for this one act) or `text_source` (the government file the text came from, possibly shared by many acts). Null with `officialUrl`.
    - `licenseNote` string, nullable: 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`.
    - `updatedAt` string, nullable: 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.
  - `count` integer: Rows on this page. Never a total: the list is paged by cursor and has no corpus-wide count.
  - `nextCursor` string, nullable: Opaque cursor for the next page: send it as `cursor`, with the same filters. Null on the last page.
  - `hasMore` boolean: 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.
  - `coverage` SessionLawListCoverage: What we hold of the session or state an EMPTY page was asked about.
    - `scope` 'session' | 'jurisdiction', required: `session` when the request named a `session`, `jurisdiction` when it named only the state.
    - `jurisdiction` string, required: Lowercase two-letter code of the state, `dc` or `pr`.
    - `status` 'complete' | 'partial' | 'not_held' | 'filter_unavailable', required: `filter_unavailable`: the data cannot satisfy a date filter you sent (see `unavailableFilters`): no law of this state or session carries that kind of date, so the empty page says nothing about the law; not charged. `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; not charged.
    - `unavailableFilters` string[]: The date filters you sent that no law of the state (or of the `session` you named) can satisfy because none carries that date: any of `approvedFrom`, `approvedTo`, `effectiveFrom`, `effectiveTo`. Empty unless `status` is `filter_unavailable` (or `not_held`, which also names them). Drop them: the other filters still work.
    - `session` SessionLawSession: The legislative session a law was enacted in.
      - `code` string, required: 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`.
      - `label` string, nullable: The session's canonical label, as the publisher names it.
      - `type` string, nullable: `regular`, `special`, `extraordinary`, `fiscal`, `veto` or `unknown`.
      - `year` integer, nullable: The year the session convened, the same year `code` starts with.
    - `sessionsHeld` integer: How many sessions of this state we hold session laws for. 0 when `not_held`.
    - `partialSessions` string[]: Session codes of this state whose collection is `partial`: the ones an empty page may be missing laws from. At most the 10 newest are listed, oldest first, and `message` says how many earlier ones are left out. Empty when none.
    - `reason` string, nullable: 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.
    - `message` string, required: 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`.

## Other responses

- `401`: Missing, invalid or revoked API key. Not charged.
- `402`: Insufficient credits for this call. Nothing was done and nothing was charged. Read your balance, free, at `GET /credits/balance`.
- `403`: The API key lacks the `research:read` scope. Not charged.
- `409`: Idempotency conflict. `idempotency_in_progress`: the original request with this key is still running (retry after `Retry-After`). `idempotency_replay_unavailable`: it completed but its response was too large to replay; nothing is charged again, so check the credit balance instead of retrying.
- `422`: 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. `idempotency_key_reused`: the `Idempotency-Key` was already used with a different request.
- `429`: Rate limit exceeded for your key. Not charged. Wait `Retry-After` seconds.
- `500`: An unexpected failure on our side. The charge is refunded.
- `503`: The session-laws database is temporarily unavailable. The charge is refunded; retry.

## Changes

- **2026-11-07** `340c0d24d0b6`: 1 warning, 74 info
  - added the new `filter_unavailable` enum value to the `coverage/anyOf[subschema #1: SessionLawListCoverage]/status` response property for the response status `200`
  - added the new optional `query` request parameter `order`
  - added the optional property `candidateCount` to the response with the `401` status
  - added the optional property `candidateCount` to the response with the `402` status
  - …71 more

[Operation history](https://skmtc.dev/vaquill/apis/vaquill-developer-api/changes/api/v1/us/session-laws/list/get.md)

---

[API](https://skmtc.dev/vaquill/apis/vaquill-developer-api.md) - [All operations](https://skmtc.dev/vaquill/apis/vaquill-developer-api/llms.txt) - [OpenAPI document](https://skmtc.dev/vaquill/apis/vaquill-developer-api/revisions/340c0d24d0b6?raw)