Discover/Gov API
live

Gov APIhcourt.gov.au ↗

Access High Court of Australia judgments (1998–present), CLR volumes 1–100 (1903–1959), and Full Court cases via 6 structured endpoints.

Endpoint health
verified 1d ago
search_judgments
get_judgment
list_cases
search_clr
get_clr_case
6/6 passing latest checkself-healing
Endpoints
6
Updated
1d ago

What is the Gov API?

The hcourt.gov.au API exposes 6 endpoints covering the High Court of Australia's published judgments from 1998 to the present, digitised Commonwealth Law Reports volumes 1–100 (1903–1959), and the Full Court case registers. The search_judgments endpoint lets you filter by year, justice surname, keywords, or case number and returns neutral citations, bench composition, and judgment slugs. get_judgment retrieves the full record for a single case including catchwords and downloadable judgment files.

This call costs2 credits / call— charged only on success
Try it
1-based page number within the filtered result set.
4-digit judgment year, e.g. 2024. Omitted = all years from 1998 onward.
Surname of one justice who sat on the judgment, letters only with no spaces or hyphens (e.g. Gageler, Gordon, BeechJones). Omitted = all justices. An unknown surname yields an empty result.
Free-text keywords matched against case name / party names (e.g. Minister).
Exact High Court case number as shown on the site, e.g. S68/2026. Omitted = no case-number filter.
Results per page; the site accepts only 12, 25, 50 or 100.
→ api.parse.bot/scraper/9297a2c2-15ee-4213-9904-2c2be8f290ec/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/9297a2c2-15ee-4213-9904-2c2be8f290ec/search_judgments?keywords=Minister' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

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 hcourt-gov-au-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: High Court of Australia SDK — bounded, re-runnable."""
from parse_apis.hcourt_gov_au_api import (
    HighCourt, CaseStatus, InputNotFound,
)

client = HighCourt()

# Browse recent decided cases, capped at 5 items total.
for case_summary in client.case_summaries.list(
    status=CaseStatus.DECIDED, limit=5,
):
    print(case_summary.title, case_summary.case_number)

# Drill into the first decided case via the summary→detail navigation.
first_case_summary = client.case_summaries.list(
    status=CaseStatus.DECIDED, limit=1,
).first()
if first_case_summary is not None:
    case = first_case_summary.details()
    print(case.title, case.catchwords)
    for doc in case.documents or []:
        print("  ", doc.date, doc.description)

# Search judgments by keyword and fetch full detail for the first hit.
hit = client.judgment_summaries.search(keywords="Minister", limit=1).first()
if hit is not None:
    judgment = hit.details()
    print(judgment.title, judgment.citation, judgment.date)
    for f in judgment.files:
        print("  ", f.label, f.size)

# Point lookup by slug discovered from the earlier search.
if hit is not None:
    try:
        same = client.judgments.get(slug=hit.slug)
        print(same.title, same.before)
    except InputNotFound:
        print("Judgment not found")

# Search the digitised Commonwealth Law Reports (volumes 1-100, 1903-1959).
clr_hit = client.clr_case_summaries.search(volume=1, limit=1).first()
if clr_hit is not None:
    clr_case = clr_hit.details()
    print(clr_case.title, clr_case.clr_citation, clr_case.date)
    for f in clr_case.files:
        print("  ", f.label, f.size)

print("exercised: case_summaries.list / details / judgment_summaries.search / details / judgments.get / clr_case_summaries.search / details")
All endpoints · 6 totalmissing one? ·

Searches the High Court's published judgments from 1998 to the present and returns one page of judgment summaries (title, neutral citation, bench, judgment date, case number, and the slug used by get_judgment). Results are ordered newest first by the site. Optional filters narrow by party-name keywords, exact case number, a single justice's surname, and judgment year; all filters combine. Paging is caller-controlled: page is a 1-based page number (omitted = first page) and items_per_page must be one of 12, 25, 50 or 100 (omitted = 25); total is the site's count for the filtered set and has_more tells whether a further page exists. A valid search with no matches returns an empty judgments array with total 0. The bench (before) is not published for some older judgments and is null there.

Input
ParamTypeDescription
pageinteger1-based page number within the filtered result set.
yearstring4-digit judgment year, e.g. 2024. Omitted = all years from 1998 onward.
justicestringSurname of one justice who sat on the judgment, letters only with no spaces or hyphens (e.g. Gageler, Gordon, BeechJones). Omitted = all justices. An unknown surname yields an empty result.
keywordsstringFree-text keywords matched against case name / party names (e.g. Minister).
case_numberstringExact High Court case number as shown on the site, e.g. S68/2026. Omitted = no case-number filter.
items_per_pageintegerResults per page; the site accepts only 12, 25, 50 or 100.
Response
{
  "type": "object",
  "fields": {
    "page": "integer: the 1-based page returned",
    "total": "integer: site-reported number of judgments matching the filters",
    "has_more": "boolean: whether a further page exists",
    "judgments": "array of judgment summaries, each with slug (key for get_judgment), title, citation (neutral citation, e.g. [2026] HCA 38), before (bench as published, null when not published), date (ISO YYYY-MM-DD judgment date), case_number, url",
    "items_per_page": "integer: page size applied"
  },
  "sample": {
    "data": {
      "page": 1,
      "total": 232,
      "has_more": true,
      "judgments": [
        {
          "url": "https://www.hcourt.gov.au/cases-and-judgments/judgments/judgments-1998-current/morton-v-minister-immigration-and-citizenship",
          "date": "2026-10-14",
          "slug": "morton-v-minister-immigration-and-citizenship",
          "title": "Morton v Minister for Immigration and Citizenship",
          "before": "Gageler CJ, Jagot, Beech-Jones JJ",
          "citation": "[2026] HCA 38",
          "case_number": "S68/2026"
        },
        {
          "url": "https://www.hcourt.gov.au/cases-and-judgments/judgments/judgments-1998-current/minister-immigration-and-multicultural-affairs-v-mzapc",
          "date": "2025-03-05",
          "slug": "minister-immigration-and-multicultural-affairs-v-mzapc",
          "title": "Minister for Immigration and Multicultural Affairs v MZAPC",
          "before": null,
          "citation": "[2025] HCA 5",
          "case_number": "P21/2024"
        }
      ],
      "items_per_page": 25
    },
    "status": "success"
  }
}

About the Gov API

Judgments (1998–present)

The search_judgments endpoint queries the High Court's published judgments index. Filters include year (4-digit, 1998 onward), justice (surname only, no spaces or hyphens), keywords (matched against party names), and case_number (exact format, e.g. S68/2026). Results come back newest-first, with each entry carrying a slug, title, neutral citation, before (bench), and judgment_date. Page size is fixed to 12, 25, 50, or 100 via items_per_page. Pass the slug to get_judgment to retrieve catchwords (one string per published paragraph), case_number, files (label, URL, file name, human-readable size), and the date in ISO format.

Full Court Case Registers

list_cases covers both the Current Cases and Decided Cases registers for matters referred to the Full Court since February 2011. The status parameter selects the register (current or decided); you can also filter by initial letter (letter), free-text keywords, or sort_order. Each row returns title, case_number, status, and a slug. Calling get_case with that slug returns the full case file: a chronological documents array (date, description, size, URL), catchwords, lower_court_citation, lower_court_url, case_summary_files, and a recording_url for hearing AV where available.

Commonwealth Law Reports (1903–1959)

search_clr indexes the 3,702 reported cases in CLR volumes 1–100. Filter by year (1903–1959), volume (1–100), or keywords. Each result carries a clr_citation formatted as (year) volume CLR page, plus volume and first_page integers used as keys. get_clr_case returns the full record: date, before, catchwords, files, clr_citation, and the neutral citation where one exists. Bench and catchwords are sourced from the published case page.

Reliability & maintenanceVerified

The Gov API is a managed, monitored endpoint for hcourt.gov.au — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when hcourt.gov.au 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 hcourt.gov.au 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.

Last verified
1d ago
Latest check
6/6 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Building a citation lookup tool that resolves a High Court neutral citation to its full judgment record and downloadable PDF.
  • Tracking which justices appear most frequently in judgments filtered by year using the justice parameter in search_judgments.
  • Assembling a dataset of all Full Court decided cases with their lower-court citations for appellate research.
  • Archiving the chronological documents list for current Full Court cases to monitor filing activity via get_case.
  • Searching the digitised CLR archive by volume and keyword to locate early 20th-century constitutional decisions.
  • Extracting catchwords from get_judgment responses to build a taxonomy of High Court subject matter over time.
  • Linking hearing AV recordings to case records using the recording_url field returned by get_case.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 req/min

Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does the High Court of Australia provide an official developer API?+
The High Court does not publish an official developer API. The hcourt.gov.au Parse API provides structured access to the same judgment, CLR, and case register data available on the public website.
What does get_judgment return beyond the basic citation?+
get_judgment returns the full published record for one judgment: ISO judgment date, bench (before), case_number (comma-separated for joined matters), catchwords as an array of strings (one per published paragraph covering subject matter, words and phrases, and legislation cited), and a files array with label, URL, file_name, and human-readable size for each published document. The neutral citation is read from the published file name and may be null if no file carries one.
Does the API cover judgments before 1998?+
search_judgments covers 1998 to the present. For earlier decisions, search_clr covers CLR volumes 1–100 (1903–1959) with 3,702 reported cases. The gap between 1960 and 1997 is not currently covered by either endpoint. You can fork the API on Parse and revise it to add an endpoint targeting that period if the High Court publishes accessible data for it.
How does pagination work across the endpoints?+
All listing endpoints (search_judgments, list_cases, search_clr) use 1-based page numbering via the page parameter. The response includes a total count and a has_more boolean so you can iterate until has_more is false. Accepted page sizes differ slightly: search_judgments and search_clr accept 12, 25, 50, or 100; list_cases accepts 12, 24, 50, or 100. Passing any other value may cause the site to fall back to a default.
Does the API return the full text of judgments or CLR reports?+
The API returns metadata and file listings (URLs, file names, sizes) for published PDFs, not the extracted full text. Catchwords are returned as structured arrays, but the body text of judgments is not parsed out. You can fork the API on Parse and revise it to add a content-extraction endpoint if you need the judgment body as text.
Page content last updated . Spec covers 6 endpoints from hcourt.gov.au.
Related APIs in Government PublicSee all →
jade.io API
Access Australian legal cases from JADE, including recent High Court of Australia decisions and full case content retrieved by article ID or medium neutral citation. Look up specific cases quickly using their standardized citation format to stay informed on the latest Australian legal precedents.
nzlii.org API
Access data from nzlii.org.
ecourtsindia.com API
Search and retrieve detailed information about court cases across India's Supreme Court, High Courts, and District Courts from a database of over 239 million cases. Find case details, track legal proceedings, and access comprehensive court records to stay informed about judicial matters across the Indian court system.
oscn.net API
Search Oklahoma State Court Network records across 80+ counties to find cases, review detailed docket information, and track daily court filings. Quickly look up case details by county and district court type to stay informed on legal proceedings and filing activity.
bailii.org API
Search and retrieve court judgments and case law from British and Irish courts across multiple jurisdictions, with filtering by date range and location. Access complete case details including full judgment text and metadata to research legal precedents and decisions.
judgments.ecourts.gov.in API
Search for Indian court judgments and orders across multiple courts to access legal rulings, case decisions, and judicial orders. Find relevant court cases by searching through a comprehensive database of Indian judicial decisions.
scholar.google.com API
Search and retrieve case law from Google Scholar by keyword, with optional filtering by date range and court type. Fetch full case details including citations, court, and opinion text for any case returned by search.
judyrecords.com API
Search and retrieve detailed court records including case information and statistics from a comprehensive legal database. Access specific case details and view aggregated court record stats to research legal proceedings and case outcomes.