JADE APIjade.io ↗
Access Australian legal cases via the JADE.io API. Retrieve recent HCA decisions, full judgment text, and look up cases by medium neutral citation.
What is the JADE API?
The JADE.io API provides 3 endpoints for accessing Australian legal case data, including recent High Court of Australia decisions, full judgment text, and citation-based lookups. The get_recent_cases endpoint returns approximately 49 of the most recent HCA decisions in a single call, including case names, citations, decision dates, and the judges who heard each matter. Article IDs from that response feed directly into get_case and lookup_citation for deeper case retrieval.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/e339b8bc-e111-4f88-afc1-4ff0ce4a07dd/get_recent_cases' \ -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 jade-io-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.
from parse_apis.jade_australian_legal_cases_api import Jade, CaseSummary, Case, Citation
jade = Jade()
# List recent High Court of Australia cases
for summary in jade.casesummaries.list():
print(summary.case_name, summary.citation, summary.date, summary.judges)
# Get full case details from a summary
first = jade.casesummaries.list(limit=1)
for item in first:
full_case = item.details()
print(full_case.title, full_case.court, full_case.catchwords, full_case.full_text[:200])
# Look up a case by medium neutral citation
citation = jade.citations.lookup(year="2023", court="VSCA", number="1")
print(citation.case_name, citation.citation, citation.article_id, citation.article_url)
# Get a case directly by article ID
case = jade.cases.get(article_id="961160")
print(case.article_id, case.case_name, case.citation, case.court)
Retrieves a list of recent High Court of Australia (HCA) cases from the JADE Express page. Returns case names, citations, decision dates, and judges. Typically returns approximately 49 of the most recent HCA decisions. No pagination — entire list returned in one call.
No input parameters required.
{
"type": "object",
"fields": {
"cases": "array of case summary objects with article_id, case_name, citation, date, judges",
"total": "integer count of cases returned"
},
"sample": {
"data": {
"cases": [
{
"date": "10 June 2026",
"judges": "Gageler CJ; Gordon, Edelman, Steward, Gleeson, Jagot and Beech-Jones JJ",
"citation": "[2026] HCA 18",
"case_name": "Commissioner of Taxation v Bendel",
"article_id": "1232288"
}
],
"total": 49
},
"status": "success"
}
}About the JADE API
What the API Returns
The JADE.io API covers Australian court decisions sourced from JADE (Judgment And Decision Enhanced). The get_recent_cases endpoint returns an array of HCA case summaries — each object carries an article_id, case_name, citation, date, and judges. No input parameters are required, and the full list of approximately 49 recent decisions is returned in one response.
Retrieving Full Case Content
The get_case endpoint accepts an article_id (a numeric string such as 1227673) and returns the complete case record: title, case_name, citation, court, catchwords, full_text, and article_id. The full_text field contains the complete judgment. The catchwords field, when present, gives the legal headnotes describing case topics — useful for classification or search indexing.
Citation Lookup
Australian legal citations follow a medium neutral format: [year] court number. The lookup_citation endpoint accepts year, court, and number as separate string parameters — for example, year=2023, court=VSCA, number=1 — and resolves them to a case_name, full citation, article_id, and canonical article_url on jade.io. Supported court codes include HCA, FCA, FCAFC, VSC, VSCA, NSWSC, NSWCA, QCA, QSC, SASC, WASC, VCC, and VCAT.
Scope and Limitations
The get_recent_cases endpoint is scoped to the High Court of Australia only and returns no more than approximately 49 cases without pagination. Citation lookup works across a wider range of Australian courts as long as the correct court abbreviation code is known. The court field in get_case responses may be null for some records.
The JADE API is a managed, monitored endpoint for jade.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when jade.io 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 jade.io 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?+
- Monitor recent HCA decisions by polling
get_recent_casesand storing newarticle_idvalues - Build a case law search index using
full_textandcatchwordsfromget_case - Resolve medium neutral citations in legal documents to full case metadata via
lookup_citation - Extract
judgesdata from recent HCA cases to track judicial participation patterns - Retrieve canonical
article_urlvalues for linking to source judgments in legal research tools - Cross-reference
citationfields across decisions to map related precedents - Populate a legal database with structured case records including court, date, and catchwords
| 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 JADE have an official developer API?+
What does `get_recent_cases` return and can I filter by date or court?+
article_id, case_name, citation, date, and judges. It accepts no input parameters, so there is no built-in filtering by date range or judge. The full list is returned in a single call with no pagination.Does the `get_case` endpoint always return `catchwords` and `court`?+
catchwords field contains legal headnotes when the case record includes them, but it may be null for some decisions. The court field similarly may be null for certain records. The full_text, title, citation, and case_name fields are consistently populated.Does the API cover courts beyond the High Court of Australia?+
get_recent_cases endpoint is limited to High Court of Australia (HCA) decisions. However, lookup_citation and get_case support a wider range of courts, including VSC, VSCA, FCA, FCAFC, NSWSC, NSWCA, QCA, QSC, SASC, WASC, VCC, and VCAT, as long as you supply a valid article_id or citation. There is no equivalent of get_recent_cases for those other courts currently. You can fork this API on Parse and revise it to add a recent-cases endpoint for another court.Is there pagination support for browsing more than ~49 recent HCA cases?+
get_recent_cases endpoint returns the full list in one response with no page or offset parameter. It reflects what is shown on the JADE Express page at the time of the request. You can fork this API on Parse and revise it to add pagination or archival case listing if you need access to older decisions.