Browse the statute hierarchy

What this gets you: a table of contents for any code or title. You can render a browsable tree of a law in your product, the way a person would flip through it, instead of surfacing only single sections from search. Search finds the section that answers a question, but it cannot enumerate a code. When you need the structure (titles, then chapters, then sections, in the order a human reads them), use GET /us/statutes/divisions. Each call returns the immediate children of wherever you are, so you can render a tree, build a table of contents, or walk a whole title without paging through search. Endpoint used: GET /us/statutes/divisions.

Browse supports USC, CFR, STATE, REGULATION, STATE_RULES, CONSTITUTION, STATE_CONSTITUTION and FEDERAL_RULES. Every legend entry on GET /us/statutes/coverage carries a browsable flag that says which, so read it instead of probing. Executive actions, the Federal Register and agency guidance are dated series or share no common tree; reach those with POST /us/statutes/search (see the Quickstart). A request whose filters do not fit the corpus is rejected with 422 before anything is charged.

How drilling works

Pass the deepest level you already know, and the response returns the level directly below it. Which level that is depends on the code, because each section’s own place in its publisher’s hierarchy decides it. A code does not have a fixed number of levels, so read level and each node’s kind on every response instead of assuming a depth, and keep drilling until isLeaf is true.

You pass	You get back (`level`)
`corpusType=USC`	the USC `titles`
`corpusType=USC&titleNumber=42`	the `chapters` in Title 42
`corpusType=USC&titleNumber=42&chapter=21`	the `subchapters` of Chapter 21 (a chapter with no subchapters lists its sections)
`corpusType=USC&titleNumber=42&chapter=21&subchapter=I`	the `sections` in Subchapter I (leaf)
`corpusType=USC&titleNumber=18`	the `parts` of Title 18, which sit above its chapters
`corpusType=USC&titleNumber=8&chapter=12&subchapter=II`	the `parts` of Subchapter II, which sit below the chapter in this title
`corpusType=CFR&titleNumber=17`	the `chapters` in Title 17 (Chapter I and Chapter II, each an agency)
`corpusType=CFR&titleNumber=17&chapter=II`	the `parts` in Chapter II of Title 17
`corpusType=CFR&titleNumber=17&part=240`	the `subparts` and `subjectGroups` of Part 240 (a part with neither lists its sections)
`corpusType=CFR&titleNumber=17&part=240&subpart=A`	the subject groups of Subpart A
`corpusType=STATE&state=tx`	the state’s `codes`
`corpusType=STATE&state=tx&code=tx_pe`	the `titles` of the Texas Penal Code
`corpusType=STATE&state=tx&code=tx_pe&title=5`	the `chapters` in Title 5 of the Texas Penal Code
`corpusType=STATE&state=ca&code=ca_pen`	the `parts` of the California Penal Code, with any section outside a part beside them
`corpusType=STATE&state=il&code=il_225`	the `acts` in 225 ILCS, a code that is a single chapter
`corpusType=STATE&state=ny&code=ny_jud&article=2`	the `sections` in a New York article (New York is divided by article, not chapter)
`corpusType=STATE&state=de&code=de_6&article=2`	the `parts` of UCC Article 2 in Delaware Title 6, which sits outside any chapter
`corpusType=REGULATION&state=ny&code=ny_10&chapter=I`	the `parts` in Chapter I of 10 NYCRR
`corpusType=REGULATION&state=me&code=<code>`	Maine’s `umbrellas`, one per department
`corpusType=REGULATION&state=me&code=<code>&umbrella=10`	the `agencies` under umbrella `10` (Health and Human Services)
`corpusType=REGULATION&state=me&code=<code>&umbrella=10&agency=144`	the `chapters` of agency `144`, the right ones even though a chapter number repeats under other agencies
`corpusType=CONSTITUTION`	the `articles` and amendments of the US Constitution
`corpusType=CONSTITUTION&article=Amendment XIV`	the `sections` of the Fourteenth Amendment (leaf)
`corpusType=STATE_CONSTITUTION&state=nm`	the `articles` of the New Mexico Constitution
`corpusType=FEDERAL_RULES`	the rule sets (`codes`): FRCP, FRE, FRCrP, FRAP, FRBP, Supreme Court Rules
`corpusType=FEDERAL_RULES&code=frcp`	the Federal Rules of Civil Procedure (leaf)
`corpusType=STATE_RULES&state=tx`	the state’s court rule sets, such as the local rules of one trial court
`corpusType=STATE_RULES&state=tx&code=HARRIS`	the levels and rules inside one rule set

The levels in this table are what the corpus recorded on the day it was written. A listing can also mix kinds: a state code lists its chapters followed by loose sections, and a U.S. Code chapter lists any section outside a subchapter beside its subchapters. kind on each node says what it is. Beyond titleNumber, chapter, part, code and article, the listing takes one filter per level a code or rule set can have. Each is passed back the way the listing returned it, with the identifier of a node whose kind names that level, and each is case-insensitive where it is text.

Filter	Level it lists	Where it applies
`title`	a title inside a code (`kind: title`), such as Title 5 of the Texas Penal Code	State codes and regulations; needs `code`. A U.S. Code or CFR title is `titleNumber`.
`subtitle`	a subtitle	U.S. Code (needs `titleNumber`) and state codes (needs `code` and the `title` it sits in)
`division`	a division	U.S. Code, as in Title 54 (needs `titleNumber`), and state or regulation codes such as California’s (needs `code`)
`subdivision`	a subdivision	U.S. Code only, Title 54; needs the `division` it belongs to
`part`	a part	CFR, U.S. Code, and state codes or rule sets wherever a listing returned `kind: part`; on a state code or rule set it needs `code`
`subpart`	a subpart	U.S. Code (needs `part` and `titleNumber`), CFR (needs `titleNumber` and `part`) and Louisiana and Mississippi regulation codes (needs `code` and the `part` it sits in)
`subjectGroup`	a subject group	CFR only; needs `titleNumber` and `part`, and the `subpart` when the group sits inside one
`subchapter`	a subchapter	U.S. Code (needs `titleNumber` and `chapter`) and state codes or rule sets (needs `code`)
`act`	an act	State codes and court rules only, such as an Illinois act inside an ILCS chapter; needs `code`
`umbrella`	an umbrella	State regulations only (Maine groups agencies under a department umbrella); needs `code`
`agency`	an agency	State regulations only (Maine, Virginia, Wyoming); needs `code`. Name it to open the right chapter, because a chapter number repeats under different agencies
`program`	a program	State regulations only (Wyoming prints a program between an agency and its chapters); needs `code`

excludeRepealed and actStatus narrow any listing by section status, the way they do on search. The number of levels between a code and its sections is not fixed: a code lists whatever its own structure has (titles, then chapters, then subchapters, or only articles), and level says what a listing holds. Follow every node you are given, by the filter its kind names, until level is sections; never hard-code the depth. Interior nodes carry a sectionCount and isLeaf: false; drill into one by passing its identifier back, verbatim, as the filter its kind names (title as titleNumber on the U.S. Code and CFR and as title inside a state code, and likewise subtitle, division, chapter, subchapter, part, subpart, subjectGroup, article, act or code, and on state regulations umbrella, agency or program). Leaf nodes are sections with isLeaf: true and an actId you pass straight to /us/statutes/section/{actId}. Every list comes back in statutory (natural) order: 9 before 10, 240.9 before 240.10.

Federal rules are published twice, by the Judicial Conference at uscourts.gov (frcp, fre, …) and as an appendix to the U.S. Code (uscapp_t28a_fre, …). Each is its own rule set in the listing, so no rule appears twice under one heading.

On CFR you can pass the chapter from a citation such as “17 CFR Chapter II, Part 240”: with a part, chapter is accepted and ignored, because part numbers are unique within a title.

One level

curl -G https://api.vaquill.ai/api/v1/us/statutes/divisions \
  -H "Authorization: Bearer vq_key_..." \
  --data-urlencode "corpusType=USC" \
  --data-urlencode "titleNumber=42"

import requests

resp = requests.get(
    "https://api.vaquill.ai/api/v1/us/statutes/divisions",
    headers={"Authorization": "Bearer vq_key_..."},
    params={"corpusType": "USC", "titleNumber": 42},
)
data = resp.json()
print(data["level"], "under", data["parentLabel"])
for node in data["divisions"]:
    print(f'  {node["identifier"]}  {node["name"] or ""}  ({node.get("sectionCount")} sections)')

const url = new URL("https://api.vaquill.ai/api/v1/us/statutes/divisions");
url.searchParams.set("corpusType", "USC");
url.searchParams.set("titleNumber", "42");
const data = await (
  await fetch(url, { headers: { Authorization: "Bearer vq_key_..." } })
).json();
for (const node of data.divisions) {
  console.log(node.identifier, node.name ?? "", `(${node.sectionCount} sections)`);
}

A trimmed response (captured 2026-10-26, two of the chapters shown; names are printed the way the publisher prints them, here in capitals):

{
  "corpusType": "USC",
  "state": null,
  "level": "chapters",
  "parentLabel": "Title 42",
  "divisions": [
    { "identifier": "21", "name": "CIVIL RIGHTS", "kind": "chapter", "isLeaf": false, "actId": null, "sectionCount": 94 },
    { "identifier": "21A", "name": "PRIVACY PROTECTION", "kind": "chapter", "isLeaf": false, "actId": null, "sectionCount": 6 }
  ],
  "count": 2
}

name is null when the publisher prints no heading for that container. See Container names for what each level is called and which jurisdictions name which levels.

State regulations: umbrella, agency and program

Some state regulation codes print the issuing body above their chapters, and a chapter number repeats under different bodies. Naming the body opens the right chapter, so these codes no longer answer a repeated chapter number as one pooled list with a note.

Maine groups agencies under a department umbrella, then lists the agency’s chapters.
Virginia lists agencies, inside a title.
Wyoming lists agencies, then a program between the agency and its chapters. Chapter 1 repeats under every program, so pass the program too.
Louisiana and Mississippi list subpart nodes inside a part. Pass the part and the subpart with code.

Walk Maine one level at a time, passing each identifier back as the filter its kind names. Take code from the codes listing of corpusType=REGULATION&state=me.

# 1. The root of the code lists its umbrellas (kind: umbrella)
curl -H "Authorization: Bearer vq_key_..." \
  "https://api.vaquill.ai/api/v1/us/statutes/divisions?corpusType=REGULATION&state=me&code=CODE"

# 2. umbrella=10 (Health and Human Services) lists its agencies (kind: agency)
curl -H "Authorization: Bearer vq_key_..." \
  "https://api.vaquill.ai/api/v1/us/statutes/divisions?corpusType=REGULATION&state=me&code=CODE&umbrella=10"

# 3. Adding agency=144 lists the chapters of that agency (kind: chapter)
curl -H "Authorization: Bearer vq_key_..." \
  "https://api.vaquill.ai/api/v1/us/statutes/divisions?corpusType=REGULATION&state=me&code=CODE&umbrella=10&agency=144"

Each call costs 1 credit, and a level that turns out to be empty costs nothing. Keep the filters you already passed at every step. The walk helper below needs no change for these codes, because its FILTER map already carries umbrella, agency and program.

Walk a whole title

Drill from a title down until a node is a leaf. A leaf carries the actId you use to fetch metadata or full text. Because a chapter may list subchapters, parts or subparts before it lists sections, the walk is recursive: each node is passed back as the filter its kind names.

Python

import requests

BASE = "https://api.vaquill.ai/api/v1/us"
HEADERS = {"Authorization": "Bearer vq_key_..."}

# The request filter each kind of node drills with. `title` is `titleNumber`
# on the U.S. Code and the CFR, and `title` inside a state code.
FILTER = {"title": "titleNumber", "chapter": "chapter", "subchapter": "subchapter",
          "part": "part", "subpart": "subpart", "subjectGroup": "subjectGroup",
          "subtitle": "subtitle", "division": "division", "subdivision": "subdivision",
          "article": "article", "act": "act", "code": "code",
          "umbrella": "umbrella", "agency": "agency", "program": "program"}


def children(**scope) -> list[dict]:
    """Every node one level down, following `nextCursor` across pages."""
    out, cursor = [], None
    while True:
        params = {**scope, **({"cursor": cursor} if cursor else {})}
        resp = requests.get(f"{BASE}/statutes/divisions", headers=HEADERS, params=params)
        resp.raise_for_status()
        page = resp.json()
        out += page["divisions"]
        cursor = page.get("nextCursor")
        if not cursor:
            return out


def walk(scope: dict, depth: int = 0) -> None:
    for node in children(**scope):
        if node["isLeaf"]:
            # node["actId"] -> feed into POST /us/statutes/sections (see below)
            print("  " * depth + f'§ {node["identifier"]}  {node["name"] or ""}  [{node["actId"]}]')
        else:
            print("  " * depth + f'{node["kind"]} {node["identifier"]}  {node["name"] or ""}')
            walk({**scope, FILTER[node["kind"]]: node["identifier"]}, depth + 1)


walk({"corpusType": "USC", "titleNumber": 4})

A leaf listing is bounded to keep one call fast, so a large container comes back in more than one page. Check truncated on every section listing. When it is true, the response also carries nextCursor: pass it back as cursor and keep going until it is null.

def all_sections(**scope) -> list[dict]:
    out, cursor = [], None
    while True:
        page = divisions(**scope, **({"cursor": cursor} if cursor else {}))
        out += page["divisions"]
        cursor = page.get("nextCursor")
        if not cursor:
            return out

Do not reach for POST /us/statutes/search to finish an enumeration. Ranked search caps at 120 results per query, so it cannot complete a container that browse could not. matchType: "boolean" pages to the end of the matches (up to 10,000), but browse is still the way to enumerate a container.

Rows are sorted into statutory order within each response, and pages are walked in storage order, so concatenating pages does not give you one globally sorted list. The union of every page is the complete container. Sort it yourself once you hold it all.

Export a container with its text

Enumeration gives you identifiers. To turn a chapter into text, batch those actId values through POST /us/statutes/sections with includeBody, 50 at a time.

def export_container(**scope) -> list[dict]:
    ids = [s["actId"] for s in all_sections(**scope) if s.get("actId")]
    out = []
    for i in range(0, len(ids), 50):
        resp = requests.post(
            f"{BASE}/statutes/sections",
            headers=HEADERS,
            json={"actIds": ids[i : i + 50], "includeBody": True},
        )
        resp.raise_for_status()
        out += resp.json()["sections"]
    return out

Two calls per 50 sections, and no per-section round trip. includeBody bills the ordinary body price for each row that returns text; rows whose text cannot be resolved come back with body: null and are not charged for it, so read creditsConsumed on each response instead of computing it. Text is the expensive half of any export. If you are filtering, run the filter on metadata first (omit includeBody) and fetch bodies only for what survives.

Size the container before you walk it. POST /us/statutes/count takes the same scoping filters, runs no ranking, and returns an exact section count for one credit, which tells you what an export will cost before you start it.

Search within a container

Browse and search meet at the parent object. A search result from any browsable corpus carries a parent: the ready-made query that lists its siblings. Every key it carries (titleNumber, chapter, part, code, article) is also a POST /us/statutes/search filter, so you can take any hit and run a search confined to its chapter, part, article or rule set, without building the scope yourself.

A hit from	carries a `parent` like
`USC`	`{"corpusType": "USC", "titleNumber": 42, "chapter": "21"}`
`CFR`	`{"corpusType": "CFR", "titleNumber": 17, "part": "240"}`
`STATE` / `REGULATION`	`{"corpusType": "STATE", "state": "tx", "code": "tx_pe", "chapter": "31"}`
a New York code	`{"corpusType": "STATE", "state": "ny", "code": "ny_jud", "article": "2"}`
`CONSTITUTION`	`{"corpusType": "CONSTITUTION", "article": "Amendment XIV"}`
`STATE_CONSTITUTION`	`{"corpusType": "STATE_CONSTITUTION", "state": "nm", "article": "Article IV"}`
`FEDERAL_RULES`	`{"corpusType": "FEDERAL_RULES", "code": "frcp"}`

The same object replays against GET /us/statutes/divisions unchanged, so one hit gives you both the listing of its container and a search within it.

Python

import requests

BASE = "https://api.vaquill.ai/api/v1/us"
HEADERS = {"Authorization": "Bearer vq_key_..."}


def search(body: dict) -> dict:
    resp = requests.post(f"{BASE}/statutes/search", headers=HEADERS, json=body)
    resp.raise_for_status()
    return resp.json()


# 1. Find one on-point section.
hit = search({"query": "insider trading", "corpusType": "CFR", "limit": 1})["results"][0]

# 2. Reuse its parent to search only within that part (17 C.F.R. Part 240).
neighbors = search({"query": "manipulative devices", "limit": 10, **hit["parent"]})
for r in neighbors["results"]:
    print(r["actId"], r["citation"])

chapter and part accept a single value or a list, and must be paired with titleNumber (USC/CFR) or code (state), which parent always includes. A chapter number alone repeats across every title, so an unpaired chapter/part is rejected with 422. article follows the same logic, because article labels repeat too:

It needs a corpusType from one family: CONSTITUTION / STATE_CONSTITUTION, where it is the article label browse lists (Amendment XIV), or STATE / REGULATION, where it is the article of a code divided by article instead of chapter (New York’s 2-A).
STATE_CONSTITUTION also needs state, since most state constitutions have an Article IV.
On STATE / REGULATION it needs the code it belongs to, and it cannot be combined with chapter.

Pass the identifier exactly as the listing returned it; a case slip such as amendment xiv also matches. A federal rule set is a code under corpusType=FEDERAL_RULES: frcp, fre, frcpsuppadm, or an appendix copy such as uscapp_t28a_fre. Without that corpusType, frcp cannot be told apart from a state code missing its state, so it is refused. code=frcp is the Federal Rules of Civil Procedure alone; source=frcp also covers the FRCP supplemental rules. Each of these shape errors is a 422 decided before anything is charged.

Section Identifiers

The actId you get from a leaf node, and how to fetch its metadata and text.

Corpus Types

The corpora you can browse and how to scope with corpusType and state.

Jurisdictions & State Codes

Which jurisdictions exist, and what the two-letter state codes mean.

Resolve a citation

Go straight to a section from a Bluebook citation instead of walking to it.

DATA COVERAGE

USE CASES

GET STARTED

TRANSLATION

SDKS

BULK, SQL & RIGHTS

CORE CONCEPTS

LAW CHANGE ALERTS

WORKING WITH THE API

ERROR CODES

GROUNDING AI

RECIPES

Browse the statute hierarchy

How drilling works

One level

State regulations: umbrella, agency and program

Walk a whole title

Export a container with its text

Search within a container

Section Identifiers

Corpus Types

Jurisdictions & State Codes

Resolve a citation

​How drilling works

​One level

​State regulations: umbrella, agency and program

​Walk a whole title

​Export a container with its text

​Search within a container

​Related

Section Identifiers

Corpus Types

Jurisdictions & State Codes

Resolve a citation

How drilling works

One level

State regulations: umbrella, agency and program

Walk a whole title

Export a container with its text

Search within a container

Related