eCourtsIndia APIecourtsindia.com ↗
Search and retrieve detailed records from 239M+ Indian court cases. Access case status, hearing history, judges, parties, FIR details, and orders via 2 endpoints.
What is the eCourtsIndia API?
The eCourtsIndia API covers over 239 million court cases across India's Supreme Court, High Courts, and District Courts via 2 endpoints. Use search_cases to find cases by keyword, party name, or case number, and get_case_detail to pull full records including hearing history, judge assignments, interlocutory applications, FIR details, and judgment orders — all indexed by CNR number.
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.
from parse_apis.ecourtsindia_case_search_api import ECourtsIndia, CaseSummary, Case, CaseNotFound
client = ECourtsIndia()
# Search for court cases matching a keyword
for case_summary in client.casesummaries.search(query="land dispute", limit=5):
print(case_summary.cnr, case_summary.case_title, case_summary.case_status, case_summary.court_name)
# Get full detail for a specific case by constructing from a known CNR
detail = client.casesummary(cnr="KLHC010203672022").details()
print(detail.case_title, detail.case_status, detail.case_duration_days, detail.purpose)
print(detail.fir_details.police_station, detail.fir_details.year)
# Walk hearing history on the detail
for hearing in detail.history_of_case_hearings:
print(hearing.judge, hearing.business_on_date, hearing.purpose_of_listing)
# Walk judgment orders
for order in detail.judgment_orders:
print(order.order_date, order.order_type)
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
Searching Cases
The search_cases endpoint accepts a query string — anything from a legal term like "land dispute" or "theft" to a party name or case number — and returns paginated results of 20 cases per page. Each result includes the CNR (Case Number Record), case_title (formatted as Petitioner vs Respondent), case_type, case_status, filing_number, filing_date, and registration_number. The response also surfaces total_hits, total_pages, has_next_page, and has_previous_page so you can walk through large result sets programmatically using the page parameter.
Case Detail Records
The get_case_detail endpoint takes a single cnr parameter (e.g., KLHC010203672022 for a Kerala High Court case or SCIN010425532018 for a Supreme Court case) and returns a full case record. Fields include judges (semicolon-separated list), court_name, court_code, district, state, bench_type, case_type, and purpose (the current scheduled purpose of the next hearing). The detail response also covers hearing history, interlocutory applications, FIR details where applicable, and judgment orders — making it suitable for reconstructing a complete case timeline.
CNR Format and Court Coverage
CNR numbers encode the court hierarchy: the first few characters identify the state and court. This means you can identify whether a case originated in a district court, a High Court, or the Supreme Court directly from the CNR. The API spans all three tiers of the Indian judiciary, giving consistent access to cases filed from across all states and union territories.
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 active litigation involving a specific party by searching their name and monitoring
case_statusacross paginated results. - Build a case timeline tool by combining
get_case_detailhearing history and judgment order fields for a given CNR. - Monitor FIR-linked criminal cases by querying keywords and inspecting FIR details returned in the detail endpoint.
- Aggregate judge workload data by extracting
judgesandcourt_namefields from multiple case detail records. - Research land dispute case density across Indian courts by querying keywords and reading
total_hitsper term. - Validate case registration status before filing by searching a case number and checking
registration_numberandfiling_date. - Feed a legal research platform with structured case metadata including
case_type,bench_type, anddistrictfor filtering and analysis.
| 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 eCourtsIndia have an official developer API?+
What does `get_case_detail` return beyond basic case info?+
cnr, case_type, and case_title, the detail response includes the full hearing history, assigned judges (semicolon-separated), interlocutory applications, FIR details where the case involves a criminal matter, judgment orders, and the current scheduled purpose. The bench_type and court_code fields let you distinguish between division benches and single-judge matters.Can I filter `search_cases` results by state, court type, or date range?+
query string and an optional page number — there are no built-in filter parameters for state, court tier, date range, or case type. You can fork this API on Parse and revise it to add filtering parameters if your use case requires pre-filtered result sets.