Ca APIcourts.ca.gov ↗
Access all California Rules of Court via API: 10 titles, Standards of Judicial Administration, and Ethics Standards. Browse TOC, fetch full rule text.
What is the Ca API?
The courts.ca.gov API provides access to the full California Rules of Court across 11 title groups through 4 endpoints. Use get_rule_text to retrieve the complete text of any specific rule by its identifier, get_table_of_contents to browse the division and chapter hierarchy within a title, or get_chapter_rules to pull multiple rules at once with optional division or chapter filtering.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/ba51fb5a-745f-4615-980e-12cc25144efb/list_titles' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace courts-ca-gov-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: California Rules of Court SDK — browse titles, discover rules, read full text."""
from parse_apis.california_rules_of_court_api import (
CaliforniaRulesOfCourt, TitleSlug, RuleNotFound
)
client = CaliforniaRulesOfCourt()
# List all available titles in the California Rules of Court.
for title in client.titles.list(limit=5):
print(title.title_slug, title.title_name)
# Get a specific title and browse its table of contents (rules list).
trial_title = client.titles.get(title_slug=TitleSlug.TWO)
rule_summary = trial_title.rules.list(limit=1).first()
if rule_summary:
print(rule_summary.rule_id, rule_summary.rule_name, rule_summary.chapter)
# Drill into the full text of that rule via the summary's details() method.
if rule_summary:
full_rule = rule_summary.details()
print(full_rule.rule_title, full_rule.rule_text[:200])
# Fetch multiple rules from a division using get_text on a constructible title.
civil_title = client.title(title_slug="three")
for rule in civil_title.rules.get_text(division="1", limit=3):
print(rule.rule_id, rule.rule_title)
# Fetch a rule directly by ID from the root collection.
try:
rule = client.rules.get(rule_id="rule1_1")
print(rule.rule_title, rule.title_name)
except RuleNotFound as exc:
print(f"Rule not found: {exc.rule_id}")
print("exercised: titles.list / titles.get / rules.list / details / rules.get_text / rules.get")
List all available titles in the California Rules of Court. Returns a static list of title identifiers, their full names, and table-of-contents paths. No pagination — the full catalog fits in one response.
No input parameters required.
{
"type": "object",
"fields": {
"titles": "array of Title objects with title_slug, title_name, and toc_url"
}
}About the Ca API
Coverage and Structure
This API exposes the complete California Rules of Court as published by the California Judicial Branch. Coverage includes Titles 1 through 10 (note: Title 6 is omitted from the source), plus the Standards of Judicial Administration and Ethics Standards for Neutral Arbitrators. Each title is addressed by a title_slug value (e.g., two, standards, ethics) used consistently across all four endpoints.
Browsing and Discovery
list_titles returns the full set of available titles with each entry's title_slug, title_name, and toc_url. To drill into a title, pass its title_slug to get_table_of_contents, which returns every rule under that title along with its rule_id, division, chapter, and path. The total_rules field tells you how many rules exist in that title before you fetch any text.
Fetching Rule Text
get_rule_text takes a rule_id (e.g., rule2_3, ethics1, standard2_1) and an optional title_slug and returns the full rule_text and rule_title for that rule. Rule IDs follow the pattern used in the table of contents, so pairing get_table_of_contents with get_rule_text is the standard lookup flow.
Bulk Retrieval by Division or Chapter
get_chapter_rules lets you fetch multiple rules at once from a title. Supply a division string (e.g., '1' matches Division 1) and/or a chapter string to narrow scope, and use limit to cap the number of rules returned. The response includes a rules array with each rule's rule_id, rule_title, division, chapter, and rule_text, plus division_filter and chapter_filter fields confirming what was applied.
The Ca API is a managed, monitored endpoint for courts.ca.gov — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when courts.ca.gov changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official courts.ca.gov API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Building a searchable index of California civil procedure rules by fetching all rules in Title 3 via get_chapter_rules
- Generating a structured outline of family law rules by pulling the Title 5 table of contents with get_table_of_contents
- Displaying the full text of a specific arbitration ethics standard in a legal research tool using get_rule_text with an ethics rule_id
- Auditing rule changes by storing snapshots of rule_text for each rule_id over time
- Creating a cross-reference tool that maps rule IDs to their division and chapter hierarchy from get_table_of_contents
- Populating a compliance checklist app with probate procedural rules by filtering get_chapter_rules by division
- Feeding California judicial standards text into an LLM for legal Q&A grounded in official rule language
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does courts.ca.gov offer an official developer API?+
What does get_table_of_contents return, and how is it organized?+
rules array where each object includes rule_id, rule_name, division, chapter, and path for every rule in the specified title. The total_rules field gives you a count upfront. You pass a title_slug such as three or standards to target a specific title.Can I filter get_chapter_rules to only a specific chapter within a division?+
division and a chapter parameter simultaneously. Division matching works on substring — '1' matches any entry containing Division 1. You can also use limit to cap how many rules are returned in a single call.Is Title 6 covered by this API?+
list_titles or any other endpoint. The remaining titles — 1 through 5, 7 through 10, Standards, and Ethics — are all accessible. You can fork this API on Parse and revise it to add coverage if Title 6 content becomes available at the source.