How to Use the CourtListener API: Auth, Endpoints, Rate Limits

Short answer: to use the CourtListener API, create a free account, copy your token from your profile, then send Authorization: Token <your-token> on requests to https://www.courtlistener.com/api/rest/v4/. A new free account gets 5 requests per minute, 50 per hour, and 125 per day (Free Law Project, API overview, REST API v4.7, read 6 October 2026). A Free Law Project membership (free for students and academics through the EDU tier, from $10 a month otherwise) or a commercial agreement raises those limits.

Reviewed and corrected on 6 October 2026. This is general information, not legal advice; check the cited documentation before relying on it.

TL;DR

• What it is: programmatic access to more than nine million US court decisions from more than 2,000 courts, plus PACER docket data through the RECAP archive, oral arguments, judge records, and citation lookup (Free Law Project, May 2026).
• Current version: REST API v4.7, base URL https://www.courtlistener.com/api/rest/v4/. Auth is Authorization: Token <key>.
• Some endpoints work with no token, most do not. On 6 October 2026, anonymous requests to search, courts and audio returned 200, while dockets, clusters, opinions and citation lookup returned 401.
• Rate limits changed in May 2026. A new account gets 5/min, 50/hr, 125/day, down from the old 5,000-per-hour default. Higher limits come with a membership or a commercial deal.
• Two things break copy-pasted tutorials: a search result has no top-level id (the opinion ID is inside opinions), and the page_size parameter does nothing on search.
• Two ways in: raw REST (curl or the official Python SDK), or the official MCP connector if you work inside Claude, Cursor or another MCP client.

Part of our MCP and developer guide series.

For related MCP / API / developer coverage, see CourtListener Citation Lookup API: Resolve and Validate Citations and CourtListener MCP: US Federal & State Court Research.

Official docs, as of 6 October 2026

The source of truth is Free Law Project's own documentation. The REST API overview (v4.7) says: "By default, authenticated users may make up to 5 requests per minute, 50 requests per hour, and 125 requests per day." (Free Law Project, REST API v4.7)

• REST API overview, v4.7: auth, rate limits, maintenance window.
• Search API and citation lookup API.
• API Usage API, query refinement and the throttling FAQ.
• Change log and membership tiers.

Free Law Project asks that API questions go to its GitHub Discussions forum.

What changed in 2026: on 7 May the default limit fell from 5,000 requests an hour to the numbers above. The API moved from v4.4 to v4.7: v4.5 removed text lookups such as contains and icontains, v4.6 added the API Usage API, and v4.7 limits GET requests on the PACER Fetch API to your own items. On 12 May Free Law Project launched an official MCP connector for Claude.

Why CourtListener exists

CourtListener is run by the Free Law Project, a non-profit that grew out of a UC Berkeley master's project and has spent more than fifteen years collecting and publishing a large corpus of US case law on the open web.

As of May 2026, Free Law Project says the API gives access to more than nine million decisions from more than 2,000 courts, including a detailed collection of SCOTUS opinions. PACER federal-filing data lives alongside the opinions through the RECAP archive (Free Law Project, 7 May 2026).

If you are building anything that needs to ground an answer in a US court opinion (a citation-checking widget, a research agent, a docket monitor), the CourtListener API is a practical place to start. Free Law Project also maintains juriscraper, the open-source library that collects opinions from court websites, so you do not have to scrape the courts yourself.

One note before the technical part: Free Law Project is a non-profit funded by donations. Every CourtListener account gets API access, and membership raises the limits. If your product makes money on top of the data, the project's policy says that is a conversation about a commercial agreement, covered in Step 2.

A short history of CourtListener

CourtListener started in 2009 as a master's project at the UC Berkeley School of Information. Michael Lissner and Brian Carver, then an assistant professor at the school, are credited as its creators. In September 2013 the two announced Free Law Project as a non-profit home for the work, after what they called "four years developing free and open legal technologies." At the time the site held nearly a million opinions from 331 jurisdictions, and its traffic had doubled since July of that year.

Both founders said plainly why they were doing it. Lissner: "Since the birth of this country, legal materials have been in the hands of the few, denying legal justice to the many." Carver, who had practiced law before moving to academia, said "In many cases, it isn't enough to know the statute. You also need to know how it has been interpreted and applied over many years of case law." The announcement also named the funding model that still applies. The founders expected to pursue foundation grants, and hoped supporters would donate directly so the non-profit could put more developers to work (Free Law Project, September 2013, UC Berkeley School of Information, September 2013).

That model explains the rest of this guide. A small non-profit runs the servers, so the free tier is modest, memberships carry real weight, and commercial users are expected to talk to the project.

Where is my CourtListener API key? (it is called a token)

CourtListener calls the credential a token. Sign in at courtlistener.com, then open your API token page (it needs a login) and copy the token. If it leaks, the docs say you can reset it from your account profile. Free Law Project's MCP documentation adds that an API token does not expire and never rotates on its own.

Treat it like a password. Limits apply to your account, so a leaked token spends your quota. Free Law Project also forbids creating more than one account per person, project or organization to get more quota, and asks you not to share API keys across people or organizations.

Step 1: send the token

The token goes in the Authorization header, prefixed with the word Token and a space:

GET /api/rest/v4/search/ HTTP/1.1
Host: www.courtlistener.com
Authorization: Token abc123yourtokenhere

In curl:

curl -H "Authorization: Token abc123yourtokenhere" \
  "https://www.courtlistener.com/api/rest/v4/search/?q=qualified+immunity&type=o"

The docs call out the most common mistake: "A common mistake is to forget the word 'Token' in the header." The overview lists three authentication methods: the token header, cookie/session auth, and HTTP Basic. It recommends the token header for programmatic access.

What works without a token

Free Law Project's docs say "many of our APIs are open by default" and warn that the biggest gotcha is forgetting to turn authentication on before you deploy. Anonymous requests on 6 October 2026 returned:

Anonymous traffic is throttled as well, and the anonymous throttle errors named limits of 5 per minute and 50 per hour. Anonymous access is fine for trying an endpoint and wrong for a product. The change log says v4.3 began enforcing authentication on dockets, clusters and opinions.

401, 403 and 429 in plain terms

Step 2: rate limits and what they mean (read this, it changed in 2026)

This is the part that trips up anyone following an older tutorial. On May 7, 2026 Free Law Project lowered the default API rate limits and folded the higher tiers into membership (Free Law Project, "Full CourtListener Data Access via API Now Included with Membership," May 7, 2026). The old default of 5,000 requests per hour is gone.

Free Law Project gave its reasons in the same announcement: "AI has broadened the scope of who can write code, and like others, we have found our existing systems need some tweaks." It added that most users never came close to the old limit, and it did not pretend the change was painless: "We know a rate reduction may sting." In exchange, endpoints that used to need special permission, including the PACER APIs, opened to everyone with an account.

The current limits, from the membership page and the API overview (read 6 October 2026; prices and limits can change):

Three rules from the docs matter in practice. Limits are a rolling window, "Rates have no concept of what day or time it is," so going over earns a 429 and you wait for earlier requests to fall out of the window. All throttles apply at once, and the most restrictive one controls. Changes to your limits, such as a new membership, can take up to 30 minutes to take effect. Accounts that had ever made 1,000 or more requests were grandfathered to their old rate.

Membership is not a route to a commercial product. The membership page says API access is for small law firms, small governmental bodies, legal service organizations, small media outlets, academics, and pre-revenue, pre-funding organizations. Free Law Project's allowed-usage policy says membership access "may not be used to power a revenue-positive commercial product, service, or feature," and that internal tooling for an organization counts as commercial use. Commercial agreements come with higher limits and support.

What this means in practice: 125 requests per day on a free account is tiny. A search call returns 20 results per page, so one broad crawl uses the quota fast. The page_size parameter does not change that: a page_size=2 request to the search and courts endpoints on 6 October 2026 still returned 20 results, and the docs never mention it. Use the documented controls instead: search paginates with a cursor inside the next URL, and list endpoints take page up to 100 pages. Deep pagination, when you order by id, date_modified or date_created, uses the next and previous URLs and ignores page. Add count=on to get only the total.

Check your usage, and handle a 429

Since v4.6 there is an API Usage API at /api/rest/v4/api-usage/. It needs a token, reports your live usage in each scope and when each window frees up, and has its own throttle (the docs example shows 10 per minute and 120 per hour), so you can call it while your main quota is exhausted. The throttling FAQ shows what a 429 looks like: a Retry-After header and the body Request was throttled. Expected available in 85774 seconds. Read the header rather than guessing. A retry loop that sleeps for Retry-After is in Worked example 2.

The throttling FAQ adds two warnings. If your usage page shows little activity but you are throttled, your code is probably not authenticating and your traffic is counted as anonymous. And it is a violation of the terms to set up multiple accounts to get around a limit.

Free Law Project also runs a weekly maintenance window from 21:00 to 23:59 Pacific on Thursday nights, so scheduled crawls may see downtime then.

The seven endpoints most integrations start with

The v4 root lists dozens of endpoints. Most integrations start with these seven. All of them need a token except search and audio:

1. /search/ is the workhorse. Boolean queries against opinions (type=o), federal dockets with nested documents (type=r), oral arguments (type=oa), and judges (type=p). Returns matching clusters or dockets.
2. /opinions/ returns a single opinion by ID, with its text.
3. /clusters/ groups the opinions of a single decision (majority, concurrence, dissent). Opinion URLs on the CourtListener website contain a cluster ID rather than an opinion ID, so a case you can see in a browser maps to a cluster.
4. /dockets/ returns case-level metadata. It does not list docket entries, parties or attorneys: those live at /docket-entries/?docket=<id> and /parties/?docket=<id>.
5. /citation-lookup/ takes text or a volume, reporter and page, and returns the matching clusters. It is a POST endpoint.
6. /people/ is the judge database.
7. /audio/ is the oral-argument archive.

Worked example 1: search SCOTUS opinions and fetch the full text of one

You want Supreme Court opinions from 2024 that mention "qualified immunity", then the full text of the first one. The search call needs no token:

curl "https://www.courtlistener.com/api/rest/v4/search/?q=qualified+immunity&type=o&court=scotus&filed_after=2024-01-01&filed_before=2024-12-31"

On 6 October 2026 this returned count 33 and 20 results. The top-level keys of a result include caseName, cluster_id, citation, dateFiled, docket_id and a nested opinions list. There is no top-level id and no top-level snippet. The opinion ID is inside the list, and so is the snippet. Here is the first hit, trimmed:

{
  "caseName": "O'Connor-Ratcliff v. Garnier",
  "cluster_id": 9484376,
  "citation": ["601 U.S. 205"],
  "dateFiled": "2024-03-15",
  "docket_id": 67931181,
  "opinions": [{ "id": 9950989, "type": "combined-opinion" }]
}

Counts and ordering change as new data lands, so expect a different first hit later. To pull the opinion ID out of the response with jq:

curl -s "https://www.courtlistener.com/api/rest/v4/search/?q=qualified+immunity&type=o&court=scotus&filed_after=2024-01-01&filed_before=2024-12-31" \
  | jq '.results[0].opinions[0].id'

Then fetch the opinion. This call returns 401 without a token:

curl -H "Authorization: Token YOUR_TOKEN" \
  "https://www.courtlistener.com/api/rest/v4/opinions/9950989/?fields=id,html_with_citations,plain_text"

The fields parameter limits the response to the columns you name, which Free Law Project recommends to speed up your system and ease the load on theirs.

Which text field you want is documented. Free Law Project's case-law docs say: "In general, the best field for the text of a decision is html_with_citations, in which each citation has been identified and linked. This is the field that is used in the CourtListener website." They add that plain_text is populated when the opinion came from a court's website as a PDF or Word document. Other fields (html, html_columbia, html_lawbox, xml_harvard, html_anon_2020) are filled depending on the source, and xml_harvard "is not always perfect due to being created by OCR." So read html_with_citations first, strip the HTML for LLM input, and fall back to the other fields only if it is empty.

Worked example 2: the same search in Python (raw requests and the official SDK)

The first option is the requests library against the raw API. This script reads your token from the COURTLISTENER_API_TOKEN environment variable. The search runs without one. The opinion call needs one and raises an HTTP 401 error without it. It retries once after a 429, but only when Retry-After is short:

import html
import os
import re
import time

import requests

BASE = "https://www.courtlistener.com/api/rest/v4"

# The token is optional for the search call and required for the opinion call.
token = os.environ.get("COURTLISTENER_API_TOKEN")
headers = {"Authorization": f"Token {token}"} if token else {}


def get_json(url, **kwargs):
    """GET with one polite retry on 429, honoring Retry-After."""
    for attempt in range(2):
        r = requests.get(url, headers=headers, timeout=60, **kwargs)
        if r.status_code != 429:
            r.raise_for_status()
            return r.json()
        wait = int(r.headers.get("Retry-After", "60"))
        if attempt == 1 or wait > 120:
            raise RuntimeError(f"Throttled. Retry in {wait} seconds. {r.text}")
        time.sleep(wait + 1)


# 1. Search SCOTUS opinions mentioning qualified immunity, filed in 2024
params = {
    "q": "qualified immunity",
    "type": "o",
    "court": "scotus",
    "filed_after": "2024-01-01",
    "filed_before": "2024-12-31",
}
search = get_json(f"{BASE}/search/", params=params)
first = search["results"][0]  # a cluster: it has cluster_id and a nested opinions list
opinion_id = first["opinions"][0]["id"]
print(first["caseName"], first["citation"], "opinion", opinion_id)

# 2. Fetch the opinion text (this call needs a token)
op = get_json(
    f"{BASE}/opinions/{opinion_id}/",
    params={"fields": "id,html_with_citations,plain_text"},
)
raw = op.get("html_with_citations") or op.get("plain_text") or ""
text = html.unescape(re.sub(r"<[^>]+>", " ", raw))
print(len(text), "characters")

The second option is the official Python SDK, courtlistener-api-client, maintained by Free Law Project (Free Law Project, GitHub / PyPI, version 1.2.0, Python 3.10 or later). It reads your token from COURTLISTENER_API_TOKEN and handles pagination for you:

from courtlistener import CourtListener

client = CourtListener() # reads COURTLISTENER_API_TOKEN, or pass api_token="..."

# List queries return a ResourceIterator that paginates automatically
results = client.opinions.list(cluster__case_name="Miranda")
for opinion in results: # iterates across all pages
    print(opinion)

# Fetch one opinion by ID
opinion = client.opinions.get(1)

The SDK README also documents client.api_usage.get() for the usage endpoint and an AsyncCourtListener client. It is the faster path for ordinary list-and-fetch work. Drop to raw requests when you need a field or filter the SDK does not surface yet.

The dockets endpoint, step by step

Dockets need a token (anonymous requests return 401). A docket is the case-level record: in the case-law database it sits above opinion clusters, and in the PACER database it links to docket entries, parties and attorneys. To fetch one by ID, the docs use this call:

curl -H "Authorization: Token YOUR_TOKEN" \
  "https://www.courtlistener.com/api/rest/v4/dockets/4214664/"

The docs state that the response "will not list the docket entries, parties, or attorneys for the docket (doing so doesn't scale)". Docket entries come from a separate endpoint filtered by docket, and so do parties:

curl -H "Authorization: Token YOUR_TOKEN" \
  "https://www.courtlistener.com/api/rest/v4/docket-entries/?docket=69510553"

curl -H "Authorization: Token YOUR_TOKEN" \
  "https://www.courtlistener.com/api/rest/v4/parties/?docket=123"

Where do docket IDs come from? A type=r search result carries a docket_id, and so does a case-law search result (the example above has docket_id 67931181). The number in a courtlistener.com/docket/<id>/... URL is the same ID. pacer_case_id on the docket is a different number. You can also filter by docket number and court, for example dockets/?docket_number=23A994&court=scotus, because docket numbers are not unique across courts.

Fresh PACER documents are a separate matter. The PACER Fetch API "is a free API to use, but it uses your PACER credentials to purchase and download PACER content," and Free Law Project notes you still pay your PACER bill. It queues up to 30 requests per minute on its own limit, and the judiciary requires PACER passwords to change every 180 days. PACER charges $0.10 per page, never more than $3 per document, and waives fees if you spend $30 or less in a quarter (PACER). Our PACER API guide covers that side in more depth.

How to use the CourtListener API for citation verification

This is the endpoint to use for a citation-verification feature. It is a POST endpoint and it needs a token. You send a block of text and it parses and looks up every citation in it (Free Law Project, Citation Lookup and Verification API). The docs example:

curl -X POST "https://www.courtlistener.com/api/rest/v4/citation-lookup/" \
  --header "Authorization: Token YOUR_TOKEN" \
  --data 'text=Obergefell v. Hodges (576 U.S. 644) established the right to marriage among same-sex couples'

The response is an array, one object per citation found, each with a status, the normalized_citations (typo-corrected forms), start_index and end_index positions, an error_message, and a clusters array of matching cases. The status is the field you branch on:

A 404 means CourtListener could not match the citation. Treat it as unverified and check the court's own site before concluding it is fake. A match shows the case exists. It does not show the case supports your proposition or is still good law.

You can also look up one citation by passing volume, reporter and page instead of text. Limits to design around:

• 250 citations per request. Extra citations are parsed but not matched, and come back with status 429. A follow-up request that starts at the next start_index continues the job.
• 60 valid citations per minute. Once a request pushes you over, further requests are refused with HTTP 429 and a JSON body that carries the time you can retry.
• 64,000 characters per text request, about 50 pages. Chunk longer briefs.
• Each lookup also uses one request from your main quota, which is only 5 per minute on a free account.
• The API does not look up statutes, law journals, id. or supra citations, or citations without a volume and page.

What developers say

The most useful voice here is the maintainer's. In April 2024 Lissner, who introduced himself as the director of Free Law Project, wrote on Hacker News that Juriscraper, the library that collects opinions from court websites, is used "to scrape and parse millions of court records" and has "had several hundred point releases over the years as we adapt to changing court websites" (mlissner, Hacker News, April 2024). He ties those releases to courts changing their websites, which is one reason coverage and text quality can vary from court to court.

One side effect is duplicates. A commenter wrote in 2014 that "Many courts will post opinions, correct typos (and who knows what else), and then re-post them later, as new opinions or just edits" (thinkcomp, Hacker News, June 2014). That comment is more than a decade old, so check how the current data handles it, but it is a good reason to group results by decision before you count or display them.

On the plus side, the project gets credit from people who care about open court data. In a June 2026 thread about court records, one commenter wrote that CourtListener "is providing a much better service at no cost to the public through donations" (awinter-py, Hacker News, June 2026). The donation model is also the reason for the tight free tier, and both are true at the same time.

Gotchas worth knowing

Pin to v4 and read the real response shape. The current version is v4.7. The change log moves quickly: v4.5 removed text lookups such as contains, icontains, endswith and iendswith (use startswith, exact, or the Search API instead), and v4.3 turned on authentication for dockets, clusters and opinions. Read the actual JSON rather than trusting an older tutorial, as the missing id on search results shows.

First searches can be slow. A cold query can take several seconds, and repeats are faster (search results are cached for ten minutes, per the Search API docs). Add retries and debounce user input if you show search to end users.

Use fields and omit. Both parameters trim the response, which keeps large text columns out of list calls. Free Law Project lists field selection as its first performance tip.

Use the next URL for paging. Search paginates with a cursor inside next. Deep pagination on list endpoints, ordered by id, date_modified or date_created, uses next and previous and ignores page.

Old v3 URLs in tutorials. Posts and Stack Overflow answers still link to /api/rest/v3/. The v3 root still answers, but anonymous v3 search returned 403 on 6 October 2026. v4.0 moved search to Elasticsearch with cursor pagination. Use the v4 URLs.

RECAP downloads cost real money. See the dockets section: a fresh PACER pull is billed to your PACER account. Check whether a docket entry is already in the RECAP archive first.

Semantic search, the November 2025 addition

CourtListener added semantic search to its /search/ API on November 5, 2025 (Free Law Project, "Semantic Search API Now Live!," Nov 5, 2025), and rolled it out to the website in May 2026 (Free Law Project, "Semantic Search Is Now on CourtListener," May 4, 2026). It changes the kind of queries you can send.

Keyword search does Boolean matching plus relevance ranking. Semantic search uses an encoder model fine-tuned for information retrieval, so a natural-language query returns conceptually similar opinions even when no keywords overlap. In the API, add semantic=true to a GET search. To keep the query private, POST a JSON body {"embedding": [...]} with a vector of 768 numbers instead. Semantic search covers case law only. An anonymous semantic=true search returned 200 on 6 October 2026.

If you are building an LLM-driven research agent, semantic search is often what you want. If you are building a Boolean precision tool for litigators, keep keyword search. Many apps offer both.

Using CourtListener inside Claude (the official MCP connector)

On May 12, 2026 Free Law Project announced: "CourtListener is now available inside Claude as a new MCP Connector." (Free Law Project, 12 May 2026) The server lives at https://mcp.courtlistener.com/ and signs you in with your CourtListener account over OAuth, so you do not need a separate API token. Clients that cannot run OAuth can send an API token as Authorization: Token <key>, according to the MCP README.

• In Claude (web, desktop or mobile): Customize > Connectors > Browse Connectors, add CourtListener, grant access to your account.
• In Claude Code: claude mcp add --transport http courtlistener https://mcp.courtlistener.com/. The first tool call opens a browser window for OAuth.
• In another MCP client such as Cursor or VS Code: add a custom server, enter https://mcp.courtlistener.com/ as the URL, choose OAuth if asked, and sign in.

The connector uses your own API access, so the rate limits above apply to it. Free Law Project says nothing produced through the connector is legal advice. It is building a free tool for checking whether a case is still good law, so today a citation check confirms that a case exists and says nothing about whether it is still good law. Our CourtListener MCP guide covers the tools and clients in more detail.

When you should not call the API directly

Three cases where the raw API is the wrong layer:

1. You are building inside Claude, Cursor, ChatGPT or another MCP client. The official connector above wraps the API in MCP-native tools, including search, citation analysis and alerts, so you skip the integration work.

2. You need a finished answer. The CourtListener API returns opinions and records. If you need a synthesized answer to a legal question, you also need a model plus verification on top of the raw retrieval.

3. You need statutes or regulations. CourtListener's strength is case law, dockets, oral arguments and judges. Its v4 endpoint list has no US Code, state statutes or regulations, so those come from another source.

What to do next

1. Create a free account at courtlistener.com and copy your token from your API token page.
2. Run the search example from Worked example 1. It works without a token, so also try /api/rest/v4/dockets/ and confirm you get a 401, then a 200 once you add the header.
3. Pick your layer. For list-and-fetch in Python, install the official courtlistener-api-client SDK. For raw control, use curl or requests. If you are building inside Claude, Cursor or VS Code, use the official connector.
4. Before you ship anything past testing, talk to Free Law Project about a commercial agreement, and consider a membership for your own research use. The free 125-requests-per-day cap will not carry a product, and both options fund the corpus you depend on.

For more depth on the related pieces, see CourtListener Citation Lookup API: Resolve and Validate Citations, how to verify AI legal citations before filing, and how reliable CourtListener data is.

For the US statutes, regulations and court rules these laws sit in, see the US primary law API.

FAQ

Is the CourtListener API free? Every CourtListener account gets API access at no charge, at 5 requests per minute, 50 per hour and 125 per day. Higher limits come with a Free Law Project membership. EDU memberships for students, faculty and researchers are free, as are group memberships for qualifying non-profit legal services organizations; individual tiers start at $10 a month (Free Law Project, read 6 October 2026).

What are the current CourtListener API rate limits? A new free authenticated account gets 5 requests per minute, 50 per hour, and 125 per day on a rolling window (Free Law Project, REST API v4.7). The old 5,000-per-hour default was removed on May 7, 2026. Accounts with 1,000 or more historical requests were grandfathered, and memberships or commercial agreements raise the cap.

Where do I find my CourtListener API key? It is called a token. Sign in and open your API token page. Send it as Authorization: Token <your-token> on every request. A common mistake is leaving out the word Token.

What is the latest version of the CourtListener API? REST API v4.7 was the live version on 6 October 2026, at https://www.courtlistener.com/api/rest/v4/. The v3 root still responds, but anonymous v3 search returned 403, and older tutorials that use v3 paths are out of date. The change log moves fast, so read the live JSON.

Can I use the CourtListener API without a token? Some endpoints, yes. Search, courts and audio answered anonymous requests on 6 October 2026, at a low anonymous throttle. Dockets, clusters, opinions, people and citation lookup returned 401. Anonymous access is for experiments, not products.

Why does my search result have no id field? Search results are clusters. They carry cluster_id, and the opinion IDs sit in a nested opinions list. Take the opinion ID from results[0]["opinions"][0]["id"].

Is there an official CourtListener Python library? Yes. Free Law Project maintains courtlistener-api-client, installable with pip install courtlistener-api-client. It reads your token from COURTLISTENER_API_TOKEN and handles pagination through a ResourceIterator. Drop to raw requests when you need a field or filter the SDK does not expose.

How do I check a citation with the CourtListener API? POST text to /api/rest/v4/citation-lookup/ with your token. It returns one object per citation, each with a status (200 found, 404 not found in CourtListener, 400 unknown reporter, 300 ambiguous, 429 past the first 250 in the request). It matches up to 250 citations per request, 60 valid citations per minute, and 64,000 characters of text.

How do I get docket entries and parties? The /dockets/ endpoint returns only case metadata. Docket entries come from /docket-entries/?docket=<id> and parties from /parties/?docket=<id>. All three need a token.

Is there an official CourtListener MCP server for Claude? Yes. Free Law Project launched an official connector on May 12, 2026, at https://mcp.courtlistener.com/. You sign in with your CourtListener account, and it runs against your own API limits.

Does the CourtListener API include statutes? No. CourtListener covers case law, dockets, oral arguments, and judges. Its v4 endpoint list has no US Code, state statutes, regulations or court rules.

What is the difference between an opinion and a cluster? A cluster is the decision-level record that groups the opinions for a single case (majority, concurrence, dissent). An opinion is one of those documents. Most "cases" in plain English map to clusters, so reach for /clusters/ when you want the case and /opinions/ when you want a specific document's full text.

Priyansh Khodiyar

Co-Founder & CTO

Priyansh leads engineering and AI at Vaquill AI: the pipelines that pull statutes, regulations and court rules from every US jurisdiction's official publisher, and the REST API, MCP server and open dataset that serve them.