--- title: "Get statute full text" method: GET path: "/api/v1/us/statutes/section/{act_id}/body" tags: ["US Statutes"] --- # Get statute full text `GET /api/v1/us/statutes/section/{act_id}/body` ## Request - Base URL: `https://api.vaquill.ai` - URL: `https://api.vaquill.ai/api/v1/us/statutes/section/{act_id}/body` - 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) Get the full text of a statute section in HTML and plain text. **Cost**: 6 credits. You are only charged when text is returned: not-found (404), failed fetches, sections whose text is not yet ingested (`available: false`) and sections the publisher prints as images (`bodyUnavailable: true`) are all refunded. Works across USC, CFR, and state corpora. The text preserves formatting, cross-references, and paragraph numbering as published in the official source. **Response**: `available: true` with `html` + `plain`, or `available: false` with a `note` and `creditsConsumed: 0` when the full text is not yet ingested (metadata is still available from `/us/statutes/section/{actId}`). **A section with no text to return.** Some sections (appendices, forms and maps) are printed by the publisher as images, so there is nothing to extract. They answer `available: false`, `plain` and `html` null, `bodyUnavailable: true`, `bodyUnavailableReason: "image_only_source"`, a `note` and `creditsConsumed: 0`. Both fields are omitted on every other section. This is a final answer, not a failure to retry: the section exists and its metadata is complete. Where we hold an official link for it, `sourceUrl` carries it; it is null where we may not republish the publisher's link. Search rows, `includeBody` and the batch `/sections` route carry the same two fields, with `body` null and no body charge for that row. `sourceUrl` is where the government published this text: cite and verify against that, not against `source`, which names our storage backend. It is null when we hold no official link for the section; only government links are served. ## Tables and figures (`markdown` / `tables` / `figures`) Where a section has a structured rendering, `source` is `r2_render` and the body keeps what a flat text extraction loses: tables as real tables and images at the position the publisher prints them. - `html` -- `` elements with `
`, `colspan` and `rowspan`, and `
` / `` elements whose images are hosted on `statutes-us.vaquill.ai` - `markdown` -- GitHub-flavoured Markdown, tables as pipe tables and figures as `![alt](url)` - `plain` -- tables as one tab-separated line per row, figures as `[Figure N: caption]` placeholders - `tables` / `figures` -- what the body contains, in document order. Each figure carries its hosted `url` and its offset into `markdown` and `plain`, so you can place images in your own layout. A figure we could not fetch is listed with `status: "unavailable"` and keeps its caption in the text. - `hasTables` / `hasFigures` -- quick flags A section in a covered corpus that has no table and no figure returns `tables: []`, `figures: []` and both flags false, with its text in `html` and `plain` as before. Where a corpus has no structured rendering yet, those fields are null, meaning "not known", not "none": a table may still be present in `html`. `markdown` is returned only for `format=all` or `format=markdown`: the default `format=both` leaves it out, because it is a third full copy of the text. `format=markdown` returns only `markdown`, and falls back to `plain` with a `note` when the section has no structured rendering. The price is the same whichever format you ask for. ## Telling the law from the apparatus (`content` / `sourceCredit` / `notes`) `plain` and `html` are the WHOLE body as the publisher prints it: the operative text, then the source credit, then the notes apparatus (historical and revision notes, committee reports, editorial notes, amendments, effective-date notes). For **United States Code** sections that body is mostly not the law: measured 2026-09-02, the operative text is a median 46% of it across USC, and as little as 3.4% on `17 U.S.C. § 107`. So the granule is split into three additional fields, using the field delimiters GPO publishes in the source: - `content` -- the operative text, and nothing else - `sourceCredit` -- the credit line, e.g. `(Pub. L. 94-553, ...)` - `notes` -- the apparatus, kept because it is the legislative history Use `content` if you are feeding sections to a model: the full body invites it to quote a 1992 amendment note as the law in force. Two `format` values act on the split, and the difference between them is how many bytes cross the wire, not what the law says: - `format=content` drops `plain`/`html` and returns all three split fields. The apparatus is still on the response, because for a legislative-history or effective-date question it IS the answer. - `format=operative` drops `notes` as well, returning `content` + `sourceCredit` and nothing else. Measured on `17 U.S.C. § 107`: 95,217 bytes at `both`, 61,003 at `plain`, 30,545 at `content`, 1,564 at `operative`. Same 6 credits either way -- the fetch is identical, so this buys bandwidth and prompt budget, not a discount. Reach for `operative` when you are putting the law in front of a model or a reader and the notes are noise. Reach for `content` when you may need to read the apparatus but want to keep it clearly separated from the law. ⚠️ USC only. CFR and the state corpora carry no equivalent structure in their sources, so all three fields are null there and `plain` remains the whole body. Null means "we cannot split this reliably", never "this section is empty". Both `content` and `operative` fall back to serving `plain` with an explanatory `note` on a corpus that cannot be split, rather than returning a response that claims to carry the text and does not. Pass `structured=true` to also get `markdown` (the body as nested Markdown lists) and `subsections` (a tree you can address by pincite, e.g. `(b)(2)`, each node carrying its pincite path and full pinpoint citation). Same cost. ## One subsection (`pinpoint`) Pass `pinpoint=(c)(1)` to get that unit in the `pinpoint` field, alongside the whole body, for the same price. Write the pinpoint as parenthesised labels, outermost first, without the section number: `(c)`, `(c)(1)`, `(d-1)`, `(f)(1.5)`. A label that contains a hyphen or a dot is one label, so `(f)(1.5)` is the path `["f", "1.5"]`. Anything else is a 422 and is not charged. `pinpoint` carries the unit's own text (`text`), the unit with everything beneath it as printed (`fullText`), each ancestor's own text (`leadIn`, so `(c)(1)` can be read as the sentence it completes), the units directly beneath it (`children`), the labels either side of it (`siblings`) and its character range in `plain` (`charStart`, `charEnd`). Read `matched` first. A pinpoint the section does not contain is `matched: false` with a `reason` and, in `available`, the labels that do exist at the level where the lookup stopped; `matchLevel: ancestor` means only the leading part of your pinpoint exists and the block describes the deepest unit that does (`unmatched` is the rest). A section whose outline we could not recover answers `reason: no_structure`. `structure` says where the outline came from: a stored `artifact` that was checked against the exact text returned here, or `request_time` parsing, and its `quality`. `structured` and `pinpoint` are independent and can be combined: `structured` returns the whole tree in `subsections`, `pinpoint` returns one unit in `pinpoint`. When a stored outline exists both come from it. `pinpoint` cannot be combined with `asOf` (the historical text is plain and carries no outline): that is a 422. ## Point-in-time (`asOf`) Pass `asOf=YYYY-MM-DD` to get the text as it stood on that date instead of today's. Same cost. **One parameter, two engines, and `asOf.engine` says which one answered.** Read it before anything else in the block, because the two make different promises and `isBounded` does not mean the same thing under each. `engine: "stored_edition"` -- we hold the publisher's own printed editions for this corpus and return one verbatim. CFR annual editions, the US Code, the Copyright Compendium and OFAC FAQs. Here `isBounded: true` means your date fell inside an edition we actually hold, which is a verified published printing. Coverage under this engine is ENUMERATED, not continuous, and outside the CFR annual editions it is currently sparse. A date in a gap between two held editions returns `source: "unavailable"`, `isBounded: false`, no text, and an `outOfCoverageReason` naming what we do hold. It is never answered from a neighbouring edition, because the text may have changed in the gap. **For the US Code this is the common case today: most historical dates fall between the editions we hold and are reported out of coverage, with `outOfCoverageReason` naming the editions that are available.** Do not read the presence of this parameter as full US Code point-in-time coverage. `engine: "observed_change"` -- every other corpus. **A reconstruction, not an archive.** The corpus holds one current text per citation; an earlier one is rebuilt from the before-side of the first change we OBSERVED after your date, through the same resolver the watch diff uses. Here `isBounded: true` is the WEAK claim, described below. The `asOf` block reports: - `source` -- on `observed_change`: `live` (nothing captured after your date AND the text we hold took effect on or before it, so today's text stood then), `reconstructed`, or `unavailable`. On `stored_edition`: `published` or `unavailable` - `outOfCoverageReason` -- why no text came back, when none did - `currentVersionEffective` / `earliestHeldVersion` -- when the text we hold took effect, and the earliest version we hold. **If your date PRECEDES the current text's effective date, today's text is never returned as the law on your date**: you get a held prior version (`engine: stored_edition`, `source: published`) or `source: unavailable` with these two dates and NO text, refunded. A section that states no readable effective date and has no capture reaching your date returns today's text with a `note` saying it is unverified for that date - `basisChangeId` -- the change event this answer rests on, readable at `/us/statutes/section/{actId}/changes` - `observedFrom` -- how far back the evidence reaches for this section - `isBounded` -- **read this one, and read `engine` first.** On `observed_change`, true means we observed no change affecting your date, which is not the same as there having been none: capture began long after the corpus did and is per-source. On `stored_edition` it is inverted and stronger, as above: true means a held edition governed your date. `html` is never returned on this path: the text is plain, and synthesising markup the publisher never printed would be a wrong answer on the endpoint whose job is fidelity. A section that did not exist on that date returns `available: false` with `asOf.existed: false` and IS charged, the same way an unresolved citation is charged on `/resolve`: a confident negative is the answer. On `observed_change`, a section we know changed but cannot rebuild returns `source: "unavailable"` and is refunded. On `stored_edition`, an out-of-coverage date is an ANSWER about what we hold and is charged, which is the same rule the CFR annual editions have always followed. ## Path parameters - `act_id` string, required: Section identifier, e.g. `USC_T42_C21_S1983` (Title 42, Chapter 21, Section 1983, which a lawyer writes as 42 U.S.C. § 1983). Take it from a `/us/statutes/search` or `/us/statutes/resolve` result. A citation also works here: `26 U.S.C. § 1`, `42 USC 1983` or `Cal. Civ. Code § 1950.5` is resolved with the same resolver `/resolve` uses, and the section is served. A citation costs this endpoint's price PLUS the `/resolve` price (2 credits), charged as its own line whether or not it resolves, exactly as `/resolve` charges; that is the same total as calling `/resolve` and then this endpoint, in one round trip. An exact act_id costs only this endpoint's price. When a citation resolves, or when the id only matched after surrounding whitespace, quotes or a trailing period were removed, the response carries `resolvedFrom` saying what your input was matched as. Check it the way you would check a `/resolve` answer. A citation containing `/` cannot travel in a URL path segment; resolve it with `GET /us/statutes/resolve` instead. Do not assemble an id from a citation: the title and section are derivable, but the CHAPTER is not, so `USC_T26_S1` misses. A miss returns 404 with `reason` and, where the section exists under another id, `didYouMean`. State session laws (acts as enacted, ids starting `SSL_`) are not code sections: read them at `/us/session-laws/{sessionLawId}`. ## Query parameters - `format` 'all' | 'both' | 'html' | 'markdown' | 'plain' | 'content' | 'operative': Which representations to return. `both` (the default) returns `html` and `plain`. A long section carries the same text twice that way, so `plain` or `html` alone roughly halves the payload. Cost is unchanged: the fetch is the same either way. `all` adds `markdown` where the section has a structured rendering. It is opt-in because it is a third full copy of the text (about 600,000 extra characters on `49 CFR 172.101`), which a model-facing client would pay for in tokens without asking. `markdown` returns only `markdown`. On a section with no structured rendering it falls back to `plain` with a `note` saying so, never to an empty body. `tables` and `figures` are returned on every format, because they are small and describe the text you received. `content` omits `html` and `plain` and returns the split fields (`content`, `sourceCredit`, `notes`). `operative` omits `notes` as well, leaving `content` + `sourceCredit`: the law and what enacted it, and nothing else. This is the smallest representation of a section, and on a note-heavy section it is the difference between a payload that fits in a prompt and one that does not. Measured on `17 U.S.C. § 107`: 95,217 bytes at `both`, 30,545 at `content`, 1,564 at `operative`, all for the same 6 credits. Only United States Code sections can be split, so on any other corpus both values fall back to returning `plain` with a `note` saying why -- `content` will be null there, so read `note` rather than assuming the section was empty. - `structured` boolean: When true, also return a `subsections` tree parsed from the text for pincite addressing, and `markdown` as that tree rendered as nested Markdown lists. Same cost. `structured=true` OWNS `markdown`: on every `format`, and on every `source`, `markdown` is the nested-list rendering, never the table-preserving rendering a `r2_render` section otherwise returns for `format=all`/`markdown` (a `note` says so when that happens). Ask without `structured` for the tables. With `format=markdown` the nested lists are returned alone, without `html` or `plain`. The response's `structure` block says whether the tree came from a stored outline (checked against this exact text) or was parsed on this request. To fetch a single unit instead of the whole tree, use `pinpoint`. - `pinpoint` string, nullable: Return one subsection in `pinpoint`, alongside the whole body. Parenthesised labels, outermost first, without the section number: `(c)`, `(c)(1)`, `(d-1)`, `(f)(1.5)`. A label containing a hyphen or a dot is a single label. Same cost. A malformed pinpoint, or one sent with `asOf`, is a 422 and is not charged. Read `pinpoint.matched` before using the text: a subsection the section does not have is reported as `matched: false`, not answered with the whole section. - `asOf` string, date, nullable: Return the section's text as it stood on this date (`YYYY-MM-DD`, for example `2026-01-15`) instead of today's. Same cost. Cannot be combined with `pinpoint` (a 422, not charged): a historical text carries no subsection outline. **This is a reconstruction, not an archive.** The corpus holds one current text per citation; an earlier one is rebuilt from the before-side of the first change we OBSERVED after your date. The `asOf` block on the response says which version you got (`source`), what it rests on (`basisChangeId`), how far back the evidence reaches (`observedFrom`), and whether the answer is bounded by when capture began rather than by the law (`isBounded`). Read `isBounded` before citing the text. A section that did not exist yet returns `available: false` with `asOf.existed: false`, which is a real answer and is charged. A section we know changed but cannot rebuild returns `source: "unavailable"` and IS refunded, because you asked for a historical text and did not get one. A date that does not exist on a calendar (`2026-02-30`) is a 422 and is not 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` Successful Response - StatuteBodyResponse: Full text of a statute section in HTML and/or plain text. - `actId` string, required: The act_id of the section served. Equal to your request unless `resolvedFrom` is set, in which case it is the id your citation or cleaned-up input resolved to. - `html` string, nullable: The section text as HTML. When `source` is `r2_render` this is our structured rendering of the publisher's source: real `` elements (with `
`, `colspan` and `rowspan`) and `
` / `` elements at the position the publisher prints them, with images hosted on `statutes-us.vaquill.ai`. When `source` is `r2_s3` this is the publisher's own markup (tables, paragraph structure, history lines), cut to the section's own content where we recognise the publisher's page layout. For any other `source` the text was not held as per-section HTML, and `html` carries the same text as `plain` with no markup. - `plain` string, nullable: Plain text version. - `source` string, nullable: Which copy the text came from: `r2_render` (our structured rendering, carrying `markdown`, `tables` and `figures`), `r2_s3` (the publisher's page for this section), `r2_text` (our per-section text extraction), `qdrant_reconstructed` (reassembled from indexed passages), and on `asOf` requests `stored_edition` or `corpus_change_history`. A storage identifier, not a citation: cite `sourceUrl`. - `sourceUrl` string, nullable: Where this text was published by the government, so the bytes you were served can be cited and verified against the official record. Null when we hold no publishable link for the section: only official government links are served here, and an absent link is the correct answer in that case. `source` is a storage identifier and is NOT a citation. - `sourceUrlNote` string, nullable: Says why `sourceUrl` is null. Either we serve no link for this section on purpose and it is cited by `citation` alone, or the publisher issues it only inside a larger file (an archive, spreadsheet or whole volume) that is not a page of the section, or no source link is recorded for it at all. Null when `sourceUrl` is set. - `content` string, nullable: The OPERATIVE TEXT of the section, with the source credit and the notes apparatus removed. This is the law; `plain` is the law plus everything the publisher prints around it. Populated for **United States Code** sections, where GPO delimits the fields in the granule it publishes. Null for CFR and for state corpora, whose sources carry no equivalent structure -- null means "we cannot split this reliably", never "this section is empty", and `plain` is still the whole body. Worth using if you feed sections to a model: the operative text is a median 46% of `plain` across USC and as little as 3.4% (`17 U.S.C. § 107`, where nearly all of the body is committee reports and amendment notes). A model handed the full body can quote a 1992 amendment note as the law in force. - `sourceCredit` string, nullable: The publisher's credit line for the section, e.g. `(Pub. L. 94-553, title I, §101, Oct. 19, 1976, 90 Stat. 2546; ...)`. Split out of the body rather than left inside it. The same value is also on `GET /us/statutes/section/{actId}` as `sourceCredit`; it is repeated here so a caller fetching the text does not need a second call to know what enacted it. - `notes` string, nullable: The notes apparatus the publisher prints after the section: Historical and Revision Notes, committee reports, Editorial Notes (codification and amendments), Statutory Notes and Related Subsidiaries (effective dates), and any guidelines reprinted by the editors. Kept, not discarded: it is the legislative history, and it is the reason a section's body can be twenty times the length of the law. It is simply NOT the operative text, so it is served as its own field. Null where we cannot split the body. Also null, deliberately, when you pass `format=operative`: that is the one format that asks us to leave the apparatus off the wire. Null there means "not sent", not "none exists" -- the same request at `format=content` returns it. - `committeeNotes` CommitteeNoteEntry[], nullable: On a federal rule (Civil, Criminal, Appellate, Bankruptcy, Evidence), its compiled Committee Note split into one entry per amendment, in print order, each with `year`, `kind`, `heading`, `text`, `effectiveDate` and `subdivisionsDiscussed`. The publisher's own notes (References in Text, Amendment by Public Law, Effective Date) come as `editorial` entries, apart from the committee's. The entries rebuild `notes` exactly: they are the same text cut at the headings. `notes` is unchanged and still carries the whole string. Null when the rule has no committee note, when the split could not be made to reproduce the note exactly (then `notes` alone carries it), and, deliberately, when you pass `format=operative`: null there means not sent. - `year` integer, nullable: The year in the note's heading (the year of the amendment order). Null for an undated heading such as the Federal Rules of Evidence's notes on the proposed rules, and for editorial notes. - `kind` 'original' | 'amendment' | 'adoption' | 'congressional_report' | 'explanatory_note' | 'editorial' | 'untitled', required: `original` the rule's first note; `amendment` a later committee note; `adoption` a new rule's committee note under the modern heading; `congressional_report` a House, Senate or Conference report note (Federal Rules of Evidence, Criminal Rule 11); `explanatory_note` a committee's separate explanation of a rule; `editorial` the publisher's own notes (References in Text, Amendment by Public Law, Effective Date), which are not committee notes; `untitled` text before the first heading. - `heading` string, nullable: The heading line exactly as printed. Null for `untitled`. - `text` string, required: The note's text, without its heading. - `effectiveDate` string, nullable: ISO date the amendment took effect, read from the rule's source credit by matching the heading year to the order date. Null when the credit does not settle it (the original rule, congressional reports, editorial notes). - `subdivisionsDiscussed` string[]: Subdivisions the note names, such as `(b)(1)`, in order of first mention. Read from "Subdivision (b)(1)", "Note to Subdivisions (b) and (d)" and a paragraph that opens with the rule's own citation; empty when the note names none. - `committeeNote1937Print` CommitteeNote1937Print: A Federal Rule of Civil Procedure's ORIGINAL 1937 Advisory Committee note as Congress printed it, H.R. Doc. No. 588, 75th Cong., 3d Sess. (1938), and how it compares with the 1937 note in `notes` (the Office of the Law Revision Counsel's compilation). - `document` string, required: The printed document, cited. - `documentTitle` string, nullable: The printed document's title page. - `ruleNumber` string, nullable: The 1937 rule number this note was printed under. - `sourceUrl` string, nullable: The govinfo PDF of the print. - `sourceSha256` string, nullable: sha256 of that PDF's bytes. - `printedHeading` string, nullable: The rule's heading as printed in 1938, which can differ from today's. - `pageStart` integer, nullable - `pageEnd` integer, nullable - `verdict` 'agrees' | 'differs' | 'print_only' | 'none_printed', required: `agrees` the print matches the 1937 note we serve in `notes`; `differs` both exist and disagree, see `disagreements`; `print_only` the print has a 1937 note and the compilation carries none; `none_printed` the 1938 print has no note for this rule. - `similarityToReference` number, nullable: Word-level similarity of the print to the compiled 1937 note, 0 to 1. - `disagreements` object[]: Where the print and the compilation part: `kind` (`missing_from_ocr`, `extra_in_ocr`), word counts and normalised excerpts of each side. - `printText` string, nullable: The note's text as OCRed from the print (AWS Textract). Null for `none_printed`. - `printTextStatus` 'verified' | 'unverified_ocr', nullable: `verified` only when the OCR agrees with the compiled note; every other print text is `unverified_ocr`: quote the scanned page, not this string. - `printTextSha256` string, nullable: sha256 of `printText` (UTF-8). - `referenceTextSha256` string, nullable: sha256 of the compiled 1937 note the print was compared with. - `ocrMethod` string, nullable - `ocrConfidenceMean` number, nullable - `available` boolean: Whether full text is available. - `note` string, nullable: Note if text is unavailable. - `bodyUnavailable` boolean, nullable: Present, and `true`, only on a section that has no text to return: the publisher prints it as images (an appendix, a form, a map), or the text we hold is only a partial copy of the official text. Omitted on every other section. The section is real and its metadata is complete; there is simply no body, so `body` / `plain` / `html` are null, `available` is false on `/body`, and nothing is charged for a body. Read it instead of treating a null body as a fetch failure that is worth retrying. - `bodyUnavailableReason` 'image_only_source' | 'misfiled_source_text' | 'partial_snapshot_text', nullable: Why there is no body, present with `bodyUnavailable`. `image_only_source`: the publisher prints this section as images, so there is no text to extract. Where we hold an official link for the section it is in `sourceUrl`; it is null where we may not republish the publisher's link. `misfiled_source_text`: the text stored under this regulation opens with another rule's number (a prior version filed under a renumbered rule), so it is withheld rather than served as this rule. `partial_snapshot_text`: the text we hold for this section is only a partial copy of the official text, so it is withheld rather than served as if it were complete. - `markdown` string, nullable: The body as GitHub-flavoured Markdown. When `source` is `r2_render` this is the structured rendering: tables as GFM pipe tables (a caption line above, footnotes below, multi-level headers joined as `Parent / Child`) and figures as `![alt](url)` at their position in the text. Returned only when `format` is `all` or `markdown`, not on the default `both`, where it would be a third full copy. For a section with no structured rendering, `markdown` is null unless you pass `structured=true`, in which case it is the body as nested Markdown lists (the pre-existing behaviour). When both exist the structured rendering wins, because it is the one that keeps the tables; `subsections` is returned either way. - `tables` BodyTable[], nullable: The tables in the body, in document order, with their size. An empty list means the section has none. Null means not known: the section's corpus has no structured rendering yet, so a table may still be present in `html`. - `tableId` string, required - `order` integer: 1-based position among the section's tables. - `caption` string, nullable: The table's caption, when it has one. - `rows` integer: Row count, header rows included. - `cols` integer: Column count. - `figures` BodyFigure[], nullable: The figures, equations and form images in the body, in document order, with hosted image urls and each one's offset into `markdown` and `plain`. An empty list means the section has none. Null means not known: the section's corpus has no structured rendering yet. - `figureId` string, required: Stable id for this figure, also carried on the `
` element in `html`. Deterministic, so it does not change between renders of the same source. - `kind` 'figure' | 'equation' | 'image' | 'form': What the image is. `equation` renders inline in the text. - `caption` string, nullable: The publisher's caption, when it prints one. - `alt` string, nullable: Alternative text for the image. - `url` string, nullable: Where the image is hosted, always on `statutes-us.vaquill.ai`. A format a browser cannot display (TIFF, EPS, PDF) is served as a PNG. Null when `status` is `unavailable`. - `sourceUrl` string, nullable: The image as the government publisher serves it. Use it for a "view at source" link, especially when `status` is `unavailable`. Null when we hold no publishable link. - `width` integer, nullable: Pixel width of the hosted image. - `height` integer, nullable: Pixel height of the hosted image. - `mimeType` string, nullable - `order` integer: 1-based position among the section's figures. - `offsetMarkdown` integer, nullable: Character offset of this figure's placeholder in `markdown`, so a client can splice the image into its own layout. - `offsetPlain` integer, nullable: Character offset of this figure's `[Figure N: ...]` placeholder in `plain`. - `status` 'hosted' | 'unavailable': `unavailable` means the publisher's image could not be fetched. The figure is still listed, and its caption and placeholder stay in the text, so a missing figure is never silently dropped. - `hasTables` boolean, nullable: True when the body contains at least one table, false when it contains none. Null when not known, because the section's corpus has no structured rendering yet. - `hasFigures` boolean, nullable: True when the body contains at least one figure, equation or form image, false when it contains none. Null when not known, because the section's corpus has no structured rendering yet. - `subsections` SubsectionNode[], nullable: The section broken into its lettered and numbered subsections, nested as they appear in the text. Use it to quote or link a single clause rather than the whole section. Present only when `structured=true`. - `label` string, required: The marker as printed, e.g. `(b)` or `(2)`. - `pincite` string, required: Full path to this subsection from the top of the section, e.g. `(b)(2)`. Append it to the section's citation to point at this exact passage: 42 U.S.C. § 1983(b)(2). Lawyers call that a pincite, a citation to the precise place rather than the whole section. - `type` string: The drafting level of this node: `subsection`, `paragraph`, `subparagraph`, `clause`, or `subclause`. Use it to render the marker style (letters, numbers, roman). - `citation` string, nullable: Full pinpoint citation when the section citation is known, e.g. `42 U.S.C. § 1983(b)(2)`. - `text` string: This node's own text, excluding nested children. - `children` SubsectionNode[]: Nested subsections one level deeper. - `pinpoint` PinpointResult: A pinpoint located in a section. See `PINPOINT_DESCRIPTION`. - `requested` string, required: The pinpoint as asked for, in canonical form. - `path` string[]: The path of the unit this block describes. Equal to the requested path on an exact match; shorter under `matchLevel: ancestor`; empty when nothing was located. - `label` string, nullable: The unit's label as printed. - `level` string, nullable: The unit's drafting level: `subsection`, `paragraph`, `subparagraph`, `clause` or `subclause`. - `inferred` boolean: True when the located unit was read from inside a paragraph (a run-in list such as `either (i) x, or (ii) y`) and not printed on its own line by the publisher. The rest of the tree is the publisher's own. - `matched` boolean, required: True only when the WHOLE pinpoint exists in the section (`matchLevel: exact`). False is a verdict about the pinpoint, not a failure of the call, and is charged like any resolved section. - `matchLevel` 'exact' | 'ancestor' | 'none', required: `exact`: the whole path exists. `ancestor`: only a leading part exists and the block describes the deepest unit that does. `none`: not even the first label exists, or the section has no recoverable outline. - `text` string, nullable: The unit's own text, without its descendants. Null unless a unit was located. - `leadIn` PinpointLeadIn[]: Each ancestor's own text, outermost first. Empty for a top-level unit. - `path` string[], required: That ancestor's path. - `label` string, required: Its label as printed. - `text` string, required: The ancestor's own text: the lead-in that the located unit completes. - `fullText` string, nullable: The unit and everything beneath it, as printed. Null unless a unit was located. - `children` PinpointChild[]: The units directly beneath this one. - `path` string[], required: The child's path. - `label` string, required: Its label as printed. - `level` string, required: Its drafting level. - `text` string, required: Its own text, without its descendants. - `inferred` boolean: True when the unit was read from inside a paragraph (a run-in list such as `either (i) x, or (ii) y`) and not printed on its own line by the publisher. - `siblings` PinpointSiblings: The labels either side of the located unit, within the same parent. - `previous` string, nullable: The previous sibling's label, null for the first. - `next` string, nullable: The next sibling's label, null for the last. - `charStart` integer, nullable: Offset of the unit's first character in `plain`. - `charEnd` integer, nullable: Offset just past the unit's last character in `plain` (including its children). - `kind` 'range' | 'list', nullable: Present when your citation named more than one unit: `range` (`(a)-(c)`) or `list` (`(a), (b)`). This block describes the FIRST unit only; the others are in `also`. Ask for each with `GET /us/statutes/section/{actId}/body?pinpoint=`. - `also` string[]: With `kind`: the other units your citation named, as pinpoints (`["(b)", "(c)"]`), at most 20. - `unmatched` string[]: Under `matchLevel: ancestor`, the part of the requested path that does not exist, e.g. `["7"]` when `(c)(7)` was asked and the section ends at `(c)(4)`. - `available` string[]: On a miss, the labels that DO exist at the level where the lookup stopped (at most 50), so a mistyped pinpoint can be corrected without another call. - `reason` string, nullable: Present when `matched` is false. `no_such_subsection`: the outline is known and has no such unit. `no_structure`: we could not recover this section's outline, so a pinpoint cannot be located (the section text is still at `/body`). - `note` string, nullable: A sentence saying what happened, when `matched` is false. - `structure` PinpointStructure: How far the outline behind a pinpoint (or a `subsections` tree) can be trusted. - `source` 'artifact' | 'request_time', required: `artifact`: a pre-built outline of this section, used only after its hash matched the exact text we serve. `request_time`: the outline was parsed from the text on this request. - `quality` string, nullable: `native` (built from the publisher's own markup), `verified` (parsed from the text and passed every check), `heuristic` (parsed from the text and failed a check: use it, but confirm against the text) or `none` (no outline could be recovered). Null when the outline carries no grade. - `builder` string, nullable: Which builder produced the outline. - `textSha256` string, nullable: SHA-256 of the `plain` text every `charStart` / `charEnd` offset indexes into. Hash your copy of `plain` to confirm the offsets apply to it. - `structure` PinpointStructure: How far the outline behind a pinpoint (or a `subsections` tree) can be trusted. - `source` 'artifact' | 'request_time', required: `artifact`: a pre-built outline of this section, used only after its hash matched the exact text we serve. `request_time`: the outline was parsed from the text on this request. - `quality` string, nullable: `native` (built from the publisher's own markup), `verified` (parsed from the text and passed every check), `heuristic` (parsed from the text and failed a check: use it, but confirm against the text) or `none` (no outline could be recovered). Null when the outline carries no grade. - `builder` string, nullable: Which builder produced the outline. - `textSha256` string, nullable: SHA-256 of the `plain` text every `charStart` / `charEnd` offset indexes into. Hash your copy of `plain` to confirm the offsets apply to it. - `asOf` AsOfProvenance: Where an `asOf` body came from, and how far the evidence reaches. Every field but `text` on the parent exists so this answer cannot be over-read. The corpus holds ONE current text per citation; an earlier one is RECONSTRUCTED from observed changes, and observation started when it started. - `requested` string, required: The date you asked for, echoed back (`YYYY-MM-DD`). - `engine` 'stored_edition' | 'observed_change': WHICH BACKEND ANSWERED. `asOf` is one parameter over two engines and they make different promises. `stored_edition`: the answer is a publisher's own printed edition of the text, held verbatim. Used wherever we hold published editions, which today is `corpusType=CFR_ANNUAL` (annual editions per title), the US Code, the Copyright Compendium and OFAC FAQs. The date is resolved to a held edition and that edition's text is returned as printed. Coverage under this engine is per corpus and is NOT continuous. The CFR annual editions tile the calendar per title; the others are ENUMERATED editions with gaps between them. A date that falls in a gap returns `source: "unavailable"` with `outOfCoverageReason` and NO text, rather than the neighbouring edition, because the text may have changed in the gap. For the US Code in particular, most dates are currently out of coverage: see `outOfCoverageReason` for which editions we hold. `observed_change`: the answer is RECONSTRUCTED from changes we observed, and reaches back only as far as capture began for that source. Every other corpus. Read this before `isBounded`, which does not make the same claim on both engines. - `source` 'live' | 'reconstructed' | 'unavailable' | 'published', required: The detail WITHIN the engine above. On `observed_change` -- `live`: we captured no change to this section after your date, AND the text we hold took effect on or before your date (or states no effective date, in which case the `note` says the answer is unverified). A date that PRECEDES the effective date of the text we hold is never `live`: it is `unavailable` with `outOfCoverageReason`, `currentVersionEffective` and `earliestHeldVersion`, and is refunded. `reconstructed`: rebuilt from the before-side of the first change we captured after your date. `unavailable`: we know it changed but cannot rebuild the earlier text, so no text is returned. That is different from the section being empty, and different again from it not existing. On `stored_edition` -- `published`: an edition we hold answered, verbatim. `unavailable`: the date is out of coverage for this section and no text is returned, and `outOfCoverageReason` says why in a sentence. Out of coverage means the date falls outside every edition we hold, or inside a gap between two of them; it is never answered from a neighbouring edition. - `existed` boolean, required: False when the earliest thing we ever captured for this section is its ADDITION and that addition postdates your date, so it demonstrably did not exist yet. A real answer, not a miss. - `basisChangeId` integer, nullable: The change event whose before-side supplied this text. Null when `source` is `live`. Pass it to `/us/statutes/section/{actId}/changes` to see the event this answer rests on. - `observedFrom` string, nullable: The earliest change we ever captured for this section. Null when we captured none. This is how far back the reconstruction can see, and it is a property of when capture began for this source, not of the age of the law. - `resolvedEditionYear` integer, nullable: `stored_edition` only. The revision year actually served, read from the edition's own printed revision statement. 🔴 This is NOT always the year the schedule computes: a publisher reprints an unchanged volume into the next year without re-dating it, so the 2024 printing of 4 CFR is the January 1 2019 revision. Render THIS year, never `scheduledEditionYear`. - `scheduledEditionYear` integer, nullable: `stored_edition` only. The edition the revision schedule says SHOULD cover your date. Differs from `resolvedEditionYear` whenever the publisher reprinted an unchanged volume. Exposed so the disagreement is auditable, not so it can be displayed. - `editionsObserved` integer[], nullable: `stored_edition` only. Every edition year in which this exact text was observed, enumerated. An ENUMERATION, not a range: a year between the first and last that is absent here is an edition nobody read, and a date resolving to it is reported out of coverage rather than answered from a neighbour. - `outOfCoverageReason` string, nullable: Why no text was returned, in a sentence safe to show a reader. Null when text was returned. - `currentVersionEffective` string, nullable: `YYYY-MM-DD`. The day the CURRENT text we hold took effect, when the section states one. Present on `observed_change` answers that were checked against it. When it is later than your date, today's text is never served as the law on your date: you get a prior version we hold or `source: unavailable`. Null when the section states no effective date we can read, in which case a `live` answer is UNVERIFIED for your date and the response `note` says so. - `earliestHeldVersion` string, nullable: `YYYY-MM-DD`. The effective date of the earliest version of this section we hold (current or prior). Set on `unavailable` answers that predate the current text, so you can ask for a date we can answer. - `isBounded` boolean, required: ⚠️ This flag does NOT make the same claim on both engines. Read `engine` first. On `stored_edition`, TRUE means your date falls inside the editions we actually parsed for this title, so the text is a verified published printing rather than an inference. FALSE means out of coverage, and no text is returned. On `observed_change`, TRUE means: we observed no change affecting your date, and that is NOT the same as there having been none. Set when your date predates `observedFrom`, or when we captured no change for this section at all. Change capture began long after the corpus did and is per-source, so a bounded answer is our best reconstruction rather than a verified historical text. Surface it. Rendering a bounded answer as authoritative point-in-time law makes a claim we did not make. - `coverage` string, required: Prose statement of the same limit, safe to show a reader verbatim. - `resolvedFrom` SectionIdentifierResolution: How the identifier you sent was matched, when it was not an exact act_id. Present only when the input did NOT match as sent. Absent (null) means the section is exactly the act_id in your request. - `input` string, required: The identifier exactly as you sent it. - `actId` string, required: The act_id it matched. Send this next time to skip resolution. - `via` 'normalized_id' | 'citation', required: `citation` -- your input was a citation, resolved with the same resolver as `GET /us/statutes/resolve`. Check it the way you would check a `/resolve` answer. `normalized_id` -- your input was an act_id carrying surrounding whitespace, quotes, a trailing period or double percent-encoding, which were removed. - `subsection` string, nullable: The pincite your citation carried, e.g. `(h)(11)` for `26 U.S.C. § 1(h)(11)`. The WHOLE section is served; use `pinpoint=(h)(11)` on `/body` to get that subsection, or `structured=true` for the whole tree. - `matchLevel` 'container' | 'multiple' | 'repaired' | 'register_reference', nullable: Present only when `section` is NOT the exact unit you cited. `container`: you cited a container in one of the supported forms (a Missouri, New Jersey, West Virginia or Wyoming regulation series or chapter, a constitution article or amendment, an Indiana chapter, an Illinois article, or a U.S. Code chapter such as `18 U.S.C. ch. 96`; a U.S. Code subchapter is not read), and `section` is the FIRST section inside it (see `container` for how many there are and what they are). A state STATUTE chapter, subchapter, title, article or part cited with its container word and a code name we read for that state (`8 Del. C. ch. 1, subch. VII`, `Tex. Penal Code ch. 19`, `N.Y. Penal Law art. 125`, `Mass. Gen. Laws ch. 93A`, `La. R.S. Title 14`) also answers `container`, with `section` the first live section in statutory order, but only where we hold that container and its number is unique within the code. A container we do not hold, a missing or unrecognised code name, a regulation or rule set, or a number that repeats in the code (California repeats chapter numbers across its titles) when the citation names more than one level, returns `resolved: false` with `missReason: container_not_supported`. An article that IS the section unit (`La. Civ. Code art. 2315`, `Tex. Code Crim. Proc. art. 38.23`) is read as a section. To browse chapters, titles and articles use `GET /us/statutes/divisions`. `multiple`: you cited several sections (`§§ 8, 10`, `§§ 1983-1985`) and `section` is the first of them (see `citedSections`), or your citation fits more than one held section (`D.C.COLO.LR 7.1` is both Local Civil and Local Criminal Rule 7.1) and every candidate is listed in `container`; a state statute container number that repeats within its code (`Cal. Penal Code tit. 8` is a title of each of four parts) lists each candidate container's first section there, never picking one, when there are at most 10. `repaired`: the code name you wrote is a recognised miscite and `section` is the one it names (see `repair`); or (`repair.kind: prior_edition`) the text you cited has been replaced by a current one, and `section` is NOT the text you cited: a C.F.R. or U.S.C. section the current code no longer holds, answered with the MOST RECENT historical annual edition we hold, or a superseded rule set whose rule numbers were kept, answered with the current rule (`Tex. R. Civ. Evid. 803` is answered by `Tex. R. Evid. 803`), or a state regulation we hold only as superseded filings, answered with the latest filing (`W. Va. Code R. § 64-14-5`); `repair.interpretedAs` names what was served and why, and `repair.alternatives` lists the other held editions, if any; or (`repair.kind: former_law`, `former_number`) you cited a FORMER section number, recodified or renumbered since, and `section` is the successor the state's own disposition table or history line names, never the former text (a former section split into several answers `multiple`, every successor in `citedSections`). or (`repair.kind: code_name_inferred`) your citation named no code (`CODE ANN. § 73.001`, `Code 4121-3-34`) and `section` is the only one in the state that carries that number, so the code was inferred from the number and not read from your citation; or (`repair.kind: repealed_range`, `renumbered_range`, `range_member`) you cited a New York or California section the publisher printed only inside a run of sections (`6 NYCRR 420.4` inside `420.3 to 420.4`), and `section` is that stub, not the section's own text (`repair.interpretedAs` names the range); `register_reference`: you cited a state register page, and `section` is a rule whose history cites it (see `registerReference`). `resolved` keeps its meaning (a section was returned) and is true at every level; read `matchLevel` to tell an exact section from a first-of-several. Absent for an exact match. - `container` ResolveContainerInfo: What the citation named, and what lies inside it. - `kind` string, required: What was cited: `chapter`, `subchapter`, `series` (a rule group number such as `5th Cir. R. 47`, held only as `47.1` to `47.10`), `article`, `section` (a constitution section made of numbered paragraphs, or a California regulation held as one document per subsection, `18 CCR 17071` being `(a)` to `(q)`), `amendment`, `document` (a rule set stored as one document holding several editions) or `alternatives` (with `matchLevel: multiple`: the held sections the citation could mean). - `label` string, required: The container, as we read your citation. - `childCount` integer, required: How many sections the container holds. Always exact, even when `children` is cut. - `children` ResolveContainerChild[]: The sections inside, in document order. `section` is the first of them that is in force (the first of all when none is), so it is `children[0]` unless that one is repealed or otherwise not in force. For an `amendment` of a state whose constitution is held as amended text, these are the sections whose own note credits that amendment, which is what the corpus records; a section the corpus does not annotate is not listed. - `actId` string, required: The child section's id. - `citation` string, nullable: The child's own citation. - `status` string, nullable: Its status in the corpus (`in_force`, `repealed`, ...). - `truncated` boolean: True when `children` lists fewer than `childCount` sections. - `citedSections` string[], nullable: Set with `matchLevel: multiple`. The sections your citation named, as written (a range such as `1983-1985` is one entry); `section` is the first. - `repair` ResolveRepairInfo: A miscite we recognised, and how we read it. - `kind` string, required: What was repaired: `code_name` (a recognised miscite of the code name); `prior_edition` (the text you cited has been replaced, so `section` is not it: a C.F.R. or U.S.C. section held only as a historical annual edition, where `interpretedAs` names the edition and its year and `alternatives` the other editions; or a superseded rule set whose numbers were kept, such as the former Texas Rules of Civil and Criminal Evidence, answered with the current rule and the reason in `interpretedAs`; or a state regulation held only as superseded filings, where `interpretedAs` names the latest filing's date and `alternatives` the earlier filings); `code_name_inferred` (the citation named no code, so the only section in the state with that number was served: `interpretedAs` is that section's citation, `cited` the head as you wrote it, and `alternatives` is empty because a number held by two codes is refused, never guessed); `former_law` (you cited a section number the state's code no longer carries, and the state's own disposition table, a code commission comparative table, a revisor's renumbering stub or the Code's history credits, says which current section it became; `cited` is the number you wrote, `interpretedAs` the successor's citation with what the table says: recodified, renumbered or merged, the effective date when the table gives one, and the source. The former text itself is not served; with `matchLevel: multiple` the former section was SPLIT and `citedSections` lists every successor); `former_number` (the same, read from the successor's own history line where the state prints its lineage there: Georgia's `Code 1933, §` and Washington's `Formerly RCW`). Other values name the kind of miscite that was read through, such as `act_section`, `article_edition`, `ca_ucc_article_number`, `cfr_exchange_act_rule`, `cfr_five_digit_part`, `cfr_listing_of_impairments`, `cfr_part_number_mixed`, `cfr_part_omitted`, `cfr_part_truncated`, `cfr_separator`, `cfr_title`, `cfr_title_typo`, `code_article_for_constitution`, `dash_spacing`, `dotted_subdivision`, `duplicated_act`, `federal_label_state_rule`, `footnote_digit`, `former_code_name`, `former_collected`, `former_lpra_repealed_twin`, `former_title_renumbered`, `fused_subdivision`, `fused_subsection`, `fused_subsection_letter`, `glued_et_seq`, `glued_paragraph_letter`, `habeas_rules_stray_number`, `hyphen_restored`, `inside_range`, `letter_suffix_pinpoint`, `local_rule_series_inferred`, `lost_section_sign`, `merged_section`, `nm_rule_set_prefix`, `number_spelling`, `nycrr_title`, `ocr_digits`, `padded_decimal`, `part_and_section`, `pr_appendix_evidence`, `range_member`, `renumbered_provision`, `renumbered_range`, `renumbered_rule`, `renumbered_title`, `restated_rule`, `roman_section`, `set_label`, `slash_for_hyphen`, `snapshot_numbering`, `source_table`, `source_table_split`, `statute_cited_as_regulation`, `tex_statute_under_rule_label`, `title_chapter_form`, `title_dropped`, `title_inferred`, `title_moved`, `trailing_rule`, `transposed_chapter`, `truncated_section`, `usc_appendix_range_point`, `usc_appendix_unique_act`, `usc_cfr_miscite`, `usc_patent_rule_miscite`, `usc_state_code_miscite`, `wrong_rule_set_same_state`, `zero_padded_rule`, `zero_padded_section`, `zero_padding`. The set grows as repairs are added, so treat `kind` as an open string, not a closed enum; `interpretedAs` always says in words what was read. - `cited` string, required: The part of your citation we corrected. - `interpretedAs` string, required: What we read it as. - `alternatives` ResolveRepairAlternative[]: Other sections the name you wrote could also have meant. Empty when the repair was the only reading. - `actId` string, required: Another held section the cited name could also have meant. - `citation` string, nullable: That section's own citation. - `registerReference` ResolveRegisterReference - `citation` string, required: The register citation, as we read it. - `state` string, required: Two-letter state code of the register. - `kind` 'page' | 'range' | 'issue' | 'filing', required: How the citation matched the rules' history notes. `page`: a note cites exactly this volume and page. `range`: a note cites a page range that contains it. `issue`: the citation names a register issue (Colorado, Michigan). `filing`: it names a filing identifier (Washington WSR, Nevada LCB file, Indiana LSA document, Wisconsin register number). - `ruleCount` integer, required: How many held rules cite it. Always exact, even when `rules` is cut. - `rules` string[]: Their act_ids in document order, starting with the one returned as `section`. - `registerItemHeld` boolean: False when `section` is a RULE whose history cites the item (the item itself is not held for this state). True when `section` IS the register item, held under `corpusType=STATE_REGISTER`; then `rules` is that one item and `kind` is `page` (the cite names the page the item starts on) or `range` (a later page of the item). - `processingTimeMs` number: Server-side time for this request in milliseconds, excluding network transit. Useful for spotting a slow query; not billed on. - `creditsConsumed` number: Credits actually charged for this call. Read it rather than assuming the list price: failed and refunded work bills 0, and batch endpoints charge per item returned, so a partial result costs less than a full one. ## Other responses - `401`: Missing, invalid or revoked API key. - `402`: Insufficient credits. - `404`: Section not found. `reason` says why and `didYouMean` what to send. - `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`: Validation error: `detail` plus one `errors` entry per rejected field. `idempotency_key_reused`: the `Idempotency-Key` was already used with a different request. - `429`: Rate limit exceeded. --- [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)