--- title: "Get a state session law, by id or by citation" method: GET path: "/api/v1/us/session-laws/{session_law_id}" tags: ["US Session Laws"] --- # Get a state session law, by id or by citation `GET /api/v1/us/session-laws/{session_law_id}` ## Request - Base URL: `https://api.vaquill.ai` - URL: `https://api.vaquill.ai/api/v1/us/session-laws/{session_law_id}` - Auth: one of: - HTTP bearer - API key in header `X-API-Key` - TypeScript: (a function with typed inputs; its response is checked against the schema) Everything we hold about one STATE session law except its text: identity and citation, session, approval date, every printed effective date (`effectiveDates`, always a list), other printed dates, the code sections the publisher's own table lists the act as affecting (`codeSectionsAffected`), its sources with hashes, and whether its text is held. Fetch the text itself, paged, from `/us/session-laws/{sessionLawId}/body`. **Cost**: 2 credits. Pass a citation where the id goes and it adds the `/us/statutes/resolve` price (2 credits), kept whenever we gave a verdict on the citation (a served law, an unresolved or ambiguous citation), so `creditsConsumed` is then 4 when it is served. It is refunded when the session the citation points into is only partly collected, and on a failure on our side (500, 503). A 404 never keeps this route's own price. A 422 is never charged. **Id or citation.** Send a `sessionLawId` from a list result, or a citation or bill number (`S.F.No. 1552`); the `sessionLawId` path parameter says which forms are matched and how. `resolvedFrom` tells you what your input matched, and the `sessionLawId` to send next time. A citation matching several laws is a 404 with `reason: ambiguous_citation`, every candidate in `didYouMean`, and none chosen for you. Prefer the id: it is free of the resolve fee and unambiguous. When a citation names no state (`Laws 2025, ch. 1`), pass the optional `jurisdiction` (`mn`) to scope it: it supplies the state, and it vetoes a conflicting one (`Minn. Laws 2025, ch. 1` with `jurisdiction=tx` is a 404 `unresolved_citation`). It has no effect on an id. **Citing and sourcing.** `citableAs` is the law in the form a lawyer writes (`Minn. Laws 2025, ch. 1`), and `citationShort` a compact label for tables (`MN ch. 1 (2025)`); either is null where we do not know the state's form, never a guess, and `citableAs` names this law; where a special session restarts the numbering (Minnesota 2025 has two Chapter 1s) it is the conventional reading, so sending it is a 404 `ambiguous_citation` that lists both laws and marks this one `defaultSessionLawId`. Send that id to read it. `sourceUrl` is the official page the text was collected from, on a government host, and is present on a withheld law too. `licenseNote` says what the law's licence class permits. **What the dates mean.** `approvedDate` is when the act was signed and is never an effective date. Where the registry holds none but the publisher dates the governor's signature among its other milestones (South Dakota's `Signed by the Governor`), we fill it from that label and say so with `approvedDateDerived: true`; a presented or passed date is never read as an approval, and a derived date is not matched by the list's `approvedFrom` and `approvedTo`. `effectiveDates` holds the dates the publisher prints as effective and is empty, not guessed, when none is printed or it is printed as a rule ("the day following final enactment"); empty does not mean the act is not in force. `otherDates` holds the rest (approval, filing, presentment) each with its `kind`. `codeSectionsAffected` is the publisher's table as printed and is empty when the publisher prints none, though `title` usually names the sections in prose. **What the publisher printed.** `publisher` carries what the publisher itself states about the act: `publisherFields`, its own structured fields verbatim (Texas gives the bill's full action history with journal pages, Maryland the committees and reading dates, North Carolina and New Mexico a history that can include vote counts, most states little more than a bill number and a sponsor), plus `publisherIds`, `otherCitations`, `legislatureNumber`, `sessionLastYear`, `printedPageStart` and `printedPageEnd` and the label the document carries for its own kind (`documentKindAsPrinted`). The keys of `publisherFields` differ by state and are the publisher's words, not ours: nothing is normalised, and a key that is absent is not a fact about the act. `provenance` says how the text was obtained (`textMethod`, `pagesWithText`, and the bound `volume` and pages it was cut from) and lists the collector's own `caveats` on the record, verbatim: most say something about the act or its text a reader should know, and some are working notes about how the record was assembled. `session.coverageStatus` says whether we hold the whole session (`complete`) or only part of it (`partial`, so a missing neighbour may exist). These three are omitted, not null, if they cannot be read; the rest of the answer and its price are the same. **Withheld text.** A law whose text has a measured defect is still returned in full, with `textStatus: withheld` and the `withheldReason`; only its text is held back (`/body` answers `available: false`, free). Check `amendatoryMarkup` before quoting an amending act: where it is `lost`, deleted words can read as law. **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/SSL_MN_2025R_G_Y2025_C1" \ -H "Authorization: Bearer $VAQUILL_API_KEY" # the same law by bill number (URL-encode the citation) curl "https://api.vaquill.ai/api/v1/us/session-laws/S.F.No.%201552" -H "Authorization: Bearer $VAQUILL_API_KEY" # a citation that names no state, scoped to one curl "https://api.vaquill.ai/api/v1/us/session-laws/Laws%202025,%20ch.%201?jurisdiction=mn" -H "Authorization: Bearer $VAQUILL_API_KEY" ``` ```javascript const id = "SSL_MN_2025R_G_Y2025_C1"; const res = await fetch(`https://api.vaquill.ai/api/v1/us/session-laws/${encodeURIComponent(id)}`, { headers: { Authorization: `Bearer ${process.env.VAQUILL_API_KEY}` }, }); const law = 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`. ## Path parameters - `session_law_id` string, required: A STATE session law's id, for example `SSL_MN_2025S1_G_Y2025_C1`, from a `/us/session-laws/list` result. A citation also works here on `GET /us/session-laws/{sessionLawId}`, and `resolvedFrom` says what your input matched. Name the state in the citation: `Minn. Laws 2025, ch. 1`, `2025 Minn. Laws ch. 1`, `Ch. 1, Laws of Minnesota 2025`, `Ch. 2025-12, Laws of Fla.`, `2025 Wash. Sess. Laws ch. 12`, `La. Acts 2025, No. 12`, `Pa. Act 12 of 2025`, `Minn. S.F. 1552 (2025)`, `MN: Laws 2025, ch. 1`. A form only one state uses needs no state: `P.A. 104-0001` (Illinois), `Pub. Act No. 26-151` (Connecticut), `S.L. 2025-12` (North Carolina), `Stats. 2025, ch. 12` (California), `D.C. Law 25-713`. The publisher's printed form (`CHAPTER 2025-12`, `S.F.No. 1552`) and the `citation` we print on every law also work. A form several states share (`Laws 2025, ch. 1`, `HB 123`, `Act 12 of 2025`) is a 404 with `reason: needs_jurisdiction`, the states it exists in and one candidate per state: we never guess the state. A citation naming several laws of one state (Minnesota 2025 has two Chapter 1s) is a 404 listing all of them, `candidateCount` and `truncated` saying whether the list is complete, and `defaultSessionLawId` the regular session's law where there is exactly one conventional reading. An id or citation that matches nothing in a session we have only partly collected is a 404 with `reason: session_not_fully_collected` and that session's coverage: the law may exist and not be held yet, so it is never charged, the resolve price included. A citation costs the route's price PLUS the `/us/statutes/resolve` price (2 credits), the second kept whether or not it resolves (an unresolved or ambiguous citation is a charged verdict) and refunded only on a partly collected session or a failure. URL-encode the citation; one containing `/` cannot travel in a path segment. Federal session laws (`SAL_...`, `Pub. L. 118-5`, the Statutes at Large) are served by `/us/statutes/section`, not here, and code citations (`26 U.S.C. ยง 1`) by `/us/statutes/resolve`. ## 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', nullable: Optional two-letter state code that scopes how a CITATION sent in place of the id is read. It supplies the state a citation does not name (`Laws 2025, ch. 1` with `jurisdiction=mn` is Minnesota's) and it vetoes a state the citation does name or whose form belongs to another: `Minn. Laws 2025, ch. 1` with `jurisdiction=tx` is a 404 `unresolved_citation` (the resolution fee is kept), never answered from Minnesota. Ignored, with no effect, when you send an id. The same codes as the list's `jurisdiction`: the 50 states, `dc` and `pr`, case-insensitive; `federal` or an unknown code is a 422 and is never charged. ## Headers - `Idempotency-Key` string, nullable: Optional. 16 to 255 visible ASCII characters (a UUIDv4 is ideal). A retry with the same key and the same request replays the original 2xx response for 24 hours without charging again. The same key with a different request is rejected. Scope is the API key, method, path and body. The stored response body is a query-derived cache controlled by the account's data retention setting cacheQueryDerivedData: when it is false the body is never stored and a retry answers 409 idempotency_replay_unavailable, without charging again. ## Response `200` The law's record. `textStatus` says whether its text is served; `resolvedFrom` is present when a citation was sent in place of an id. - SessionLawResponse: Response for `GET /us/session-laws/{sessionLawId}`. - `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`). - `sessionLawId` string, required: Permanent identifier of the law, the key to use everywhere. Shape `SSL_{state}_{session code}_{series}[_Y{numberingYear}]_{C|B}`. 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` SessionLawDetailSession, required: The session block of a single law: the session, and whether we hold all of it. - `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. - `coverageStatus` 'complete' | 'partial', nullable: Whether we hold every law of this session. `complete`: every law the publisher lists for the session is accounted for, so a law absent from the list does not exist. `partial`: the collection of the session stopped short, so a law that is not found may exist, and this law's neighbours may be missing. The same verdict, with the counts behind it, is in the `sessionLaws` block on `GET /us/statutes/coverage`. Omitted when it cannot be read. - `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`. - `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: 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. - `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. - `citationAsPrinted` string, nullable: The citation exactly as the publisher prints it. Null when none is printed. - `vetoStatusAsPrinted` string, nullable: The publisher's own words on the governor's action. `enactmentOutcome` is our normalised reading of it. - `pageCount` integer, nullable: Pages in the source document when it is a PDF. Null for HTML sources. - `sourceUrl` string, nullable: The official page or file the act's text was collected from, on a government publisher's host: the first `sources` entry whose `role` is `text` and whose `hostClass` is `gov`. Open it to verify the text against the publisher. Null when we hold no such source (a law we know exists and have not collected) or when the text source is not a government host. Present on a withheld law too: the official copy is always where to go when we hold the text back. - `effectiveDates` SessionLawDate[]: Every effective date the publisher prints for the act, in printed order. Always a list, never null; empty when none is held. Empty does NOT mean the act is not in force: a date printed as a rule (`the day following final enactment`) or not printed in the publisher's metadata is not guessed, and the approval date is never substituted for it. An act can take effect in parts, so a date may carry a `scopeAsPrinted`. - `kind` string, nullable: What the date is, on `otherDates`: `approved`, `filed` or `other` (`kindAsPrinted` carries the publisher's label for `other`). Null on `effectiveDates`, where every entry is an effective date. - `date` string, date, nullable: The date as ISO 8601 when the printed text could be read as one. Null when the publisher's wording is not a calendar date. - `dateAsPrinted` string, nullable: The date exactly as the publisher wrote it, including any time of day. - `kindAsPrinted` string, nullable: The publisher's own label for what the date is, when it prints one. - `scopeAsPrinted` string, nullable: What the date applies to when it is not the whole act, as printed: an act can take effect in parts. Null when the date applies to the act as a whole. - `otherDates` SessionLawDate[]: Every other date printed on the act, each with its `kind`: the approval date, filing dates and the publisher's own milestones (presentment to the governor). - `kind` string, nullable: What the date is, on `otherDates`: `approved`, `filed` or `other` (`kindAsPrinted` carries the publisher's label for `other`). Null on `effectiveDates`, where every entry is an effective date. - `date` string, date, nullable: The date as ISO 8601 when the printed text could be read as one. Null when the publisher's wording is not a calendar date. - `dateAsPrinted` string, nullable: The date exactly as the publisher wrote it, including any time of day. - `kindAsPrinted` string, nullable: The publisher's own label for what the date is, when it prints one. - `scopeAsPrinted` string, nullable: What the date applies to when it is not the whole act, as printed: an act can take effect in parts. Null when the date applies to the act as a whole. - `codeSectionsAffected` CodeSectionAffected[]: The code sections the publisher's own table lists the act as affecting, as printed. Always a list. Empty when the publisher prints no such table, which is common: the title still names sections in prose. We do not read sections out of the act text into this list. - `sectionAsPrinted` string, required: The code section the act changes, as the publisher's table prints it. Not normalised and not linked to an `actId` on `/us/statutes`. - `actionAsPrinted` string, nullable: What the act does to that section, in the publisher's own words or abbreviation (`AMD` amended, `ADD`, `REP`, ...). - `codeAsPrinted` string, nullable: The code the section belongs to, as printed. - `actSectionAsPrinted` string, nullable: The section of the act itself that makes the change. - `sources` SessionLawSource[]: The publisher documents the record was collected from, with the hash and fetch time of each: the audit trail from this response back to the official copy. - `sourceIndex` integer, required: Position of this source in the law's source list, starting at 0. - `role` string, nullable: What this document supplied: `text` (the act itself), `identity` (the publisher page that lists and numbers the session's laws), `metadata` (dates, veto and status tables), `code_sections` or `certified_image`. - `url` string, nullable: The publisher's URL for this document, as we fetched it. Null when the document did not come from a government publisher (`hostClass` `other`) and its host is not one we publish a link to: the document is still archived and `sha256` still describes it, but no link to a third-party host is served. - `fetchedAt` string, nullable: When we fetched the document, ISO 8601 UTC with a `+00:00` offset. - `contentType` string, nullable: The document's media type as the publisher served it. - `sha256` string, nullable: SHA-256 (hex) of the exact bytes we fetched and archived. - `byteLength` integer, nullable: Size of the fetched document in bytes. - `hostClass` string, nullable: `gov` when the document comes from a government publisher (including an official publisher on a non-`.gov` host), otherwise `other`. - `publisher` SessionLawPublisher: What the publisher itself printed or published about an act, beyond the record's dates and citation. - `legislatureNumber` integer, nullable: The number of the legislature that enacted the act, as the publisher counts them (Minnesota's 94th Legislature, Alaska's 34th). Null where the publisher does not number its legislatures on the act's own pages; a gap in what we hold, not a fact about the act. - `sessionLastYear` integer, nullable: The last calendar year of the session the act belongs to, for a session that spans two (the District of Columbia's Council Period 25 runs 2023 to 2024, California's regular session 2025 to 2026). Equal to `session.year` for a session inside one year. - `printedPageStart` string, nullable: The page number printed on the act's first page in the publisher's bound volume, as printed and therefore a string (`1`, `ix`, `42A`). Not the physical page of a PDF: see `provenance.volume`. Null where the act is not printed in a volume. - `printedPageEnd` string, nullable: The page number printed on the act's last page, as printed. Null as above. - `documentKindAsPrinted` string, nullable: The label the publisher's own document carries for what kind of text it is, exactly as printed: `Enrolled version` (Texas), `As Adopted`, `Pamphlet Law` (New Jersey), `As Enacted`, `slip copy of this session law`. Our normalised reading of it is `documentKind`. Null where the document prints none. - `publisherIds` SessionLawPublisherId[]: The identifiers the publisher itself gives the act, in the order it presents them: South Carolina's ratification number, California's `bill_id`, the District of Columbia's act and bill numbers, Maryland's `BillNumber`. Useful for joining to the publisher's own site or data. Which identifiers exist differs by state. Empty when the publisher exposes none. - `name` string, required: The publisher's own label for the identifier, exactly as it prints or exposes it, so it is not a vocabulary: `RAT#` (South Carolina), `bill_id` (California), `num type="act"` (District of Columbia), `BillNumber` (Maryland), `L.D.` (Maine). - `value` string, required: The identifier's value as the publisher gives it, always a string: `5`, `202520260SB26`, `25-5`, `HB0001`. - `otherCitations` string[]: Other citations the publisher prints for the same act, each exactly as printed: `Act No. 1` beside `CHAPTER 1`, `A.L.2025, c.1`, `70 DCR 1863`, `D.C. Act 25-5`. They are accepted as citations on `GET /us/session-laws/{sessionLawId}`. Empty when the publisher prints one form only. - `publisherFields` object: The publisher's own structured fields for this act, as the publisher states them and otherwise untouched: an object whose keys, nesting and values are the publisher's own words. The keys DIFFER BY STATE and are not normalised or renamed: Texas gives the bill's full action history with journal page numbers (`Actions`), Maryland the committees and the reading and hearing dates in each chamber, North Carolina and New Mexico a history that can carry vote counts, most states little more than the bill number and a sponsor. What a given state supplies is whatever its publisher printed; do not assume any key exists, and do not read a missing key as a fact about the act. Votes in particular are present only where a publisher printed them. A few values are the publisher's own HTML: treat every string as untrusted text and never render it unescaped. `{}` when the publisher printed no such fields. A value too large to serve is left out and its key named in `publisherFieldsOmitted`. - `publisherFieldsOmitted` string[]: Keys of `publisherFields` that exist on the record but were too large to serve inline (past 64 KiB of JSON the largest values are left out, whole, never cut). Typically a publisher's full-bill HTML copy, whose text is on the body route in any case. Empty when nothing was left out, which is almost always. - `provenance` SessionLawProvenance: How the text of an act was obtained, and what the collector noted about the record. - `textMethod` string, nullable: How the text was extracted from the publisher's document: `pdf_text_layer`, `html`, `xml`, `docx`, `doc`, or `none` when no text was extracted. An open list. `none` is the same fact as `textStatus: not_held` for a collected law. - `pagesWithText` integer, nullable: For a PDF, how many of its `pageCount` pages had a text layer to read. A figure below `pageCount` means some pages (a signature page, a scanned stamp) contributed no text. Null for a source that has no pages. - `volume` SessionLawVolume: The bound volume an act's text was cut out of. - `url` string, required: The publisher's URL of the whole volume (a PDF of every act of the session) that this act's text was cut from. A government host. - `pageStart` integer, required: First physical page of the act in that volume, counted from 1 at the first page of the file. Not the page number printed on the page: see `publisher.printedPageStart` for that. - `pageEnd` integer, required: Last physical page of the act in that volume, the same counting as `pageStart`. - `boundaryHeading` string, nullable: The heading in the volume at which the act's text begins, which is how the cut was found. Null when none is recorded. - `caveats` string[]: The collector's own remarks on this record, one string each, verbatim and in order. Most say something about the act or its text that a reader should know: where the chapter number came from when the act does not print one, that the publisher prints no strike-through so there is no amendatory markup to carry, that an effective date is the publisher's wording rather than a calendar date, that the text layer has kerning damage. Some are working notes about how the record was assembled and are published as written; they are free text for a person to read, not a vocabulary to branch on, and their wording can change. Notes that only describe how a page was fetched or decoded are not included. `[]` when there are none. - `extrasUnavailable` boolean: Present and `true` only when the read behind `publisher`, `provenance` and `session.coverageStatus` failed on this request. Those three are then absent because we could not read them, not because the act has none: repeat the request to get them. Omitted when the read succeeded. - `resolvedFrom` SessionLawResolution: How a citation sent in place of a `sessionLawId` was matched. - `input` string, required: What you sent in the path, exactly. - `sessionLawId` string, required: The id it resolved to. Send this next time to skip resolution and its fee. - `via` 'normalized_id' | 'citation' | 'earlier_entry', required: `citation`: your input was a citation and matched exactly one law's citation form. `normalized_id`: your input was an id carrying surrounding whitespace, quotes or a trailing period, which were removed. `earlier_entry` (batch only): your input was an id exactly as sent, but an earlier entry of `ids` already produced that law, so it appears once in `laws`. - `matchedForm` string, nullable: Which of the law's citation forms your input matched: `as_printed` (its printed citation), `bill` (its bill number) or `other_as_printed` (another printed form). Null for `normalized_id`. ## 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. - `404`: Unknown id, an unresolved or ambiguous citation, a federal act, or an endpoint name where the id goes. `reason` says which, `didYouMean` lists real ids, and `defaultSessionLawId` is the conventional reading of an ambiguous citation. The route's own price is never kept; a citation's resolve fee is kept on `unresolved_citation` and `ambiguous_citation`. - `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: `sessionLawId` empty or over 300 characters, or `jurisdiction` not a state. 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. --- [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/fbac9b87775e?raw)