eCourtsIndia APIecourtsindia.com ↗
Search 239M+ Indian court cases and retrieve case details, hearing history, judgments, and orders from Supreme Court, High Courts, and District Courts.
What is the eCourtsIndia API?
The eCourtsIndia API provides access to over 239 million Indian court cases across three endpoints: search_cases for full-text search by party name, case number, or legal term; get_case_detail for complete case records by CNR; and get_high_court_judgments for filtered judgment and order documents from High Courts. Each search result returns a CNR identifier that links directly into the detail and judgment endpoints.
curl -X GET 'https://api.parse.bot/scraper/dba279e1-d9cb-4165-bcca-233d98085095/search_cases?page=1&query=murder' \ -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 ecourtsindia-com-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: eCourtsIndia SDK — bounded, re-runnable; every call capped."""
from parse_apis.eCourtsIndia_Case_Search_API import ECourtsIndia, Query, CaseNotFound
client = ECourtsIndia()
# Search High Court judgments and orders for a keyword
for doc in client.high_court_documents.search(query=Query.MURDER, court="Kerala", limit=3):
print(doc.cnr, doc.case_title, doc.doc_type, doc.doc_date, doc.court_name)
# Search general cases
for case_summary in client.case_summaries.search(query=Query.LAND_DISPUTE, limit=3):
print(case_summary.cnr, case_summary.case_title, case_summary.case_status)
# Get full detail for a specific case via the navigation op
item = client.case_summaries.search(query=Query.MURDER, limit=1).first()
try:
detail = item.details()
print(detail.case_title, detail.case_status, detail.hearing_count)
for order in detail.judgment_orders:
print(order.order_date, order.order_type)
except CaseNotFound as e:
print("case gone:", e.cnr)
print("exercised: high_court_documents.search, case_summaries.search, CaseSummary.details")
Full-text search across Indian court cases. Matches party names, case numbers, offenses, and legal terms. Returns 20 case summaries per page with pagination metadata. Each CaseSummary carries a CNR suitable for point-lookup via get_case_detail.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number (1-indexed) |
| queryrequired | string | Search query — party name, case number, offense keyword, or legal term (e.g. 'murder', 'land dispute', 'State vs Kumar') |
{
"type": "object",
"fields": {
"cases": "array of CaseSummary objects",
"query": "string - the search query echoed back",
"page_size": "integer - results per page (20)",
"total_hits": "integer - total matching cases",
"total_pages": "integer - total pages available",
"current_page": "integer - current page number",
"has_next_page": "boolean",
"has_previous_page": "boolean"
},
"sample": {
"data": {
"cases": [
{
"cnr": "UPAL010095512024",
"judges": "Addl. District Judge Court No. 06",
"case_type": "SC",
"bench_type": "",
"case_title": "State Government vs Kumari Kamlesh",
"court_code": "UPAL01",
"court_name": "District & Sessions Judge, Aligarh, Uttar Pradesh",
"case_status": "PENDING",
"filing_date": "2024-08-28",
"petitioners": "State Government",
"respondents": "Kumari Kamlesh",
"case_category": "INDIAN PENAL CODE - Punishment for culpable homicide not amounting to murder-304",
"decision_date": null,
"filing_number": "8422/2024",
"judicial_section": "",
"acts_and_sections": "",
"next_hearing_date": "2026-03-16",
"registration_date": "2024-08-29",
"registration_number": "1917/2024",
"petitioner_advocates": "",
"respondent_advocates": ""
}
],
"query": "murder",
"page_size": 20,
"total_hits": 138829,
"total_pages": 6942,
"current_page": 1,
"has_next_page": true,
"has_previous_page": false
},
"status": "success"
}
}About the eCourtsIndia API
Case Search and Lookup
The search_cases endpoint accepts a query string and an optional page integer, returning up to 20 CaseSummary objects per page alongside total_hits, total_pages, and has_next_page for pagination. Query strings can include party names, case numbers, offense keywords such as murder or land dispute, or general legal terms. Each summary includes a cnr field — the Case Number Record — which is the key identifier for point-level lookups.
Case Detail Records
Passing a cnr to get_case_detail returns a structured record covering case_title (formatted as Petitioner vs Respondent), judges, court_name, district, case_type, bench_type, purpose, and state. The same endpoint surfaces full hearing history, interlocutory applications, judgment orders, FIR information, and a complete case timeline. CNRs follow a consistent format such as KLHC010203672022 (Kerala High Court) or SCIN010425532018 (Supreme Court).
High Court Judgments
The get_high_court_judgments endpoint filters results to High Court cases that carry attached judgment or order documents. It accepts query, court (partial match on names like Kerala, Bombay, or Delhi), doc_type, and date-range parameters from_date and to_date in ISO YYYY-MM-DD format. Each returned document object includes cnr, case_title, court_name, doc_type, doc_date, judgment_url, petitioners, and respondents. The court_filter and doc_type_filter fields in the response confirm which filters were applied.
Coverage Notes
The database covers the Supreme Court of India, all High Courts, and District Courts. The state field in case detail records reflects the court's state jurisdiction. Pagination across all three endpoints is 1-indexed. For High Court judgments, total_hits reflects the broader search count before High Court filtering is applied, so the number of returned documents per page may be lower than page_size.
The eCourtsIndia API is a managed, monitored endpoint for ecourtsindia.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when ecourtsindia.com 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 ecourtsindia.com 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?+
- Track the status and hearing schedule of a specific case using its CNR via get_case_detail
- Research all cases involving a named party or legal entity using search_cases with a party name query
- Pull Kerala or Bombay High Court judgments within a date range using get_high_court_judgments with court and from_date/to_date filters
- Aggregate FIR-linked criminal cases by querying offense keywords such as 'IPC 302' through search_cases
- Build a case-monitoring dashboard that polls get_case_detail for updated purpose and hearing history fields
- Compile judgment documents for a specific doc_type across multiple High Courts for legal research
- Identify all land dispute cases in a district by querying 'land dispute' combined with pagination across total_pages
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 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.