Gov APIjudgments.ecourts.gov.in ↗
Search Indian court judgments from the eCourts platform. Filter by keyword, court type, and state. Returns case titles, judges, dates, and PDF paths.
What is the Gov API?
The eCourts Judgments API exposes a single search_judgments endpoint that queries the National Judicial Data Grid's judgments portal across Supreme Court, High Courts, and SCR courts. Each response returns up to 10 results per page with 8 structured fields per judgment, including case title, presiding judge, court name, CNR number, registration date, judgment date, disposal nature, and a direct PDF path to the full ruling.
curl -X GET 'https://api.parse.bot/scraper/31ab4ecd-705a-430c-822f-4066a14f34f0/search_judgments?query=CGST&start=0&court_code=DEL&court_type=2' \ -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 judgments-ecourts-gov-in-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: Ecourts Judgments SDK — search Indian court judgments."""
from parse_apis.ecourts_judgments_api import Ecourts, CourtType, CaptchaFailed
client = Ecourts()
# Search for tax-related judgments in High Courts (default court type)
for judgment in client.judgments.search(query="CGST", court_type=CourtType.HIGH_COURT, limit=3):
print(judgment.case_title, judgment.court, judgment.judgment_date)
# Filter by state — Delhi High Court
first = client.judgments.search(query="property", court_code="DEL", limit=1).first()
if first:
print(first.cnr, first.judge, first.disposal_nature)
# Search Supreme Court judgments
for j in client.judgments.search(query="tax", court_type=CourtType.SUPREME_COURT, limit=3):
print(j.case_title, j.cnr)
# Handle captcha failures gracefully
try:
results = client.judgments.search(query="contract", limit=2)
for j in results:
print(j.case_title, j.registration_date)
except CaptchaFailed as exc:
print(f"Captcha solving failed: {exc}")
print("exercised: judgments.search with court_type filter / court_code filter / error handling")
Full-text search across Indian court judgments and orders. Matches keywords against case text. Results are paginated in batches of 10, ordered by most recent judgment date. Internally solves an image captcha per request; due to OCR reliability, requests may occasionally need retrying. Each result includes case title, judge, court, CNR number, dates, and a path to the judgment PDF.
| Param | Type | Description |
|---|---|---|
| queryrequired | string | Search keyword to match against judgment text (e.g. 'CGST', 'property', 'tax') |
| start | integer | Pagination offset (results returned in batches of 10) |
| court_code | string | High Court state code to filter results by state (e.g. 'DEL' for Delhi, 'BOM' for Bombay) |
| court_type | string | Court type: '1' for Supreme Court, '2' for High Court, '3' for SCR |
{
"type": "object",
"fields": {
"start": "integer current pagination offset",
"total": "integer total number of matching results",
"results": "array of judgment objects with case_title, judge, court, cnr, registration_date, judgment_date, disposal_nature, pdf_path",
"app_token": "string session token"
},
"sample": {
"data": {
"start": 0,
"total": 18963,
"results": [
{
"cnr": "JHHC010063922026",
"court": "High Court of Jharkhand",
"judge": "HON'BLE THE CHIEF JUSTICE,HON'BLE MR.JUSTICE RAJESH SHANKAR",
"pdf_path": "court/cnrorders/jhar_pg/orders/JHHC010063922026_1_2026-06-08.pdf#page=&search=%20",
"case_title": "WPC/3674/2026 of M/S RISHAV ENTERPRISES THROUGH ITS PROPRIETOR SMT. JANE DOE Vs UNION OF INDIA THROUGH SECRETARY, MINISTRY OF FINANCE",
"judgment_date": "08-06-2026",
"disposal_nature": "Disposed of as Withdrawn",
"registration_date": "13-05-2026"
}
],
"app_token": "REDACTED_TOKEN"
},
"status": "success"
}
}About the Gov API
What the API Returns
The search_judgments endpoint accepts a keyword query and returns paginated judgment records from judgments.ecourts.gov.in. Each result object includes case_title, judge, court, cnr (the unique Case Number Record identifier), registration_date, judgment_date, disposal_nature, and pdf_path. The total field in every response tells you the full result count so you can calculate how many pages exist before iterating.
Filtering and Pagination
You can narrow results by passing court_type — '1' for the Supreme Court, '2' for High Courts, or '3' for SCR — and court_code for a specific state (for example, 'DEL' for Delhi High Court). Pagination is controlled via the start offset; the platform returns results in batches of 10, so set start=10 for the second page, start=20 for the third, and so on. The response also returns an app_token session string that is used internally across paginated calls.
Reliability Considerations
The eCourts judgments platform uses image-based CAPTCHAs to gate search access. The API handles solving these automatically with multiple retry attempts, but individual requests can occasionally fail because of CAPTCHA variance. Build retry logic into any pipeline that needs consistent throughput, especially for bulk keyword searches or large offset ranges.
Official API Availability
The eCourts platform does not publish an official developer API for judgment search. Access through this Parse API is the practical way to integrate structured judgment data into applications without building and maintaining your own access layer.
The Gov API is a managed, monitored endpoint for judgments.ecourts.gov.in — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when judgments.ecourts.gov.in 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 judgments.ecourts.gov.in 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?+
- Pull all judgments mentioning 'CGST' to track GST-related High Court rulings for a tax compliance dashboard
- Aggregate case outcomes by
disposal_natureacross multiple keywords to analyze litigation trends in a practice area - Build a CNR-based case tracker by storing the
cnrfield and monitoring for new judgment dates on known cases - Download the full text of rulings via
pdf_pathto feed a legal research or document summarization pipeline - Filter by
court_codeandcourt_typeto scope alerts to a specific state High Court for regional legal monitoring - Extract
judgefield data across many search queries to map which judges are ruling on specific subject matters
| 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 judgments.ecourts.gov.in have an official developer API?+
What does the `search_judgments` endpoint return for each result?+
case_title, judge, court, cnr, registration_date, judgment_date, disposal_nature, and pdf_path. The pdf_path points to the actual ruling document. The top-level response also includes total (the full match count) and start (the current pagination offset).How should I handle occasional request failures?+
Can I retrieve the full text of a judgment through this API?+
pdf_path for each judgment but does not return extracted text content. The current endpoint covers structured case metadata and a link to the PDF. You can fork this API on Parse and revise it to add a document-fetch endpoint that retrieves and parses the PDF content.Can I filter results by a specific district court or tribunal?+
court_type parameter covers Supreme Court, High Courts, and SCR, and court_code filters to a state-level High Court. District courts and tribunal-level filtering are not exposed. You can fork this API on Parse and revise it to add those filtering parameters if your use case requires sub-High Court coverage.