Indian court data, inside your AI assistant
The CourtMesh MCP server turns our 18 court data endpoints into tools that Claude, Claude Code and Cursor can call on their own. Ask a research question in the client you already use, and the assistant searches 315.6 million Indian court records, opens the judgment and cites what it actually read.
Live, and nothing to install. The hosted endpoint at https://mcp.courtmesh.ai/mcp is accepting connections and serves all 18 tools over Streamable HTTP. Point a client at it with your key and you are connected; there is no package, binary or build step on your side. Your API key travels with the request, either as an Authorization Bearer header or as a token query parameter, and calls are billed against the same API credits as the REST API. Access follows your API plan, so if the REST API is not enabled for your account yet the tools will return the same 401 the API returns.
Background
What is the Model Context Protocol?
MCP is an open standard for connecting AI assistants to outside systems. A server publishes a set of tools, the client discovers them at connect time, and the model decides when to call them. Write one server, and every compatible client can use it.
Why it matters for lawyers
A general purpose model asked about Indian case law will sometimes produce a citation that looks immaculate and does not exist. Reported judgments are the one place in legal work where a plausible invention is worse than no answer at all. With the CourtMesh tools connected, the assistant stops guessing and starts retrieving. It runs a real search, opens the real record, and hands back a case identifier and a link to the judgment PDF you can open before anything reaches a draft. Research that used to mean twenty browser tabs becomes a conversation that ends with sources you can verify.
Why it matters for developers
You skip the integration entirely. There is no client library to pin, no pagination helper to write, no retry logic and no schema to keep in sync with our releases. Point Claude Code or Cursor at one URL, and your coding agent can query real judgments while it builds the feature that consumes them. When you are ready to ship, the same 18 operations are available as plain REST, so a prototype driven from a chat window turns into production code without a rewrite.
Tools
18 tools, one connection
Each tool maps one to one onto a documented CourtMesh REST endpoint, so anything an assistant can do here you can also do from your own backend. Credit costs are identical across both surfaces.
| Tool | REST endpoint | Credits | What it does |
|---|---|---|---|
| search_indian_court_cases | POST /search/cases | 1 | Keyword search across 315.6 million Indian court records with filters for court, year, judge, case type and date, plus cursor pagination for long result sets. |
| semantic_search_cases | POST /search/cases/semantic | 10 | AI semantic search over the vector index. The assistant can ask in plain language, for example find judgments where a delay condonation application was allowed despite a two year delay. |
| get_case | GET /cases/{id} | 1 | Full structured case record: parties, bench, court, dates, citations, statutes referenced and judgment text. |
| get_case_analysis | GET /cases/{id}/analysis | 1 | Reads a stored AI analysis of a judgment if one already exists, so the assistant does not regenerate work you have already paid for. Not available on the Free tier. |
| find_related_cases | GET /cases/{id}/related | 1 | Related documents and the derived order timeline sharing the same case number, useful for tracing a matter through its appeals. |
| get_case_pdf_url | GET /cases/{id}/pdf | 5 | Returns a signed link to the judgment PDF so the assistant can cite or attach the original document. |
| analyze_case | POST /cases/{id}/analyze | 100 | Generates a full AI analysis: issues framed, arguments of both sides, statutes applied, precedent treatment and case strength signals. Not available on the Free tier; a stored analysis is billed at the cache hit price. |
| analyze_consolidated_case | POST /cases/{id}/analyze-consolidated | 400 | Consolidated analysis across every document attached to a matter, for when one judgment is not the whole story. Not available on the Free tier. |
| screen_party_litigation | POST /party/screen | 100 | Screens a person or company name against the corpus and returns confidence banded matches with evidence and an honest coverage statement. Priced like an analysis call on a match, far less on a genuine no match, with an optional adjudication surcharge; DPDP purpose is required on every call. |
| get_court_coverage | GET /coverage | 0 | Reads published corpus coverage and freshness by court and year. Free and unmetered, so the assistant can check what the corpus contains before it searches. |
| search_judges | GET /judges/search | 1 | Looks up Supreme Court and High Court judges by name, the fastest way to resolve a bench reference before a search. |
| request_case_timeline | POST /request-timeline | 20 | Starts an asynchronous job that assembles the orders and hearing timeline for a case number. |
| get_case_timeline | GET /get-timeline/{requestId} | 0 | Polls a timeline job and returns the assembled timeline once ready. Free, so the assistant can wait without burning credits. |
| check_api_health | GET /health | 0 | Service availability probe. Free and unmetered. |
| get_api_usage | GET /usage | 0 | Reports this key's tier, wallet balance, per period limits and per endpoint call volume for the current billing month. Unmetered: checking usage never itself consumes a credit. |
| list_reference_courts | GET /reference/courts | 0 | Reads the court taxonomy accepted by the court filter on search and litigation check, so the assistant can pass an exact, valid value instead of guessing a spelling. Free and unmetered. |
| list_reference_case_types | GET /reference/case-types | 0 | Reads every caseType value accepted by the search endpoints' caseType filter. Free and unmetered. |
| screen_party_litigation_batch | POST /party/screen/batch | 100 | Screens up to 25 person or company names against the corpus in a single call, each priced independently on the same schedule as a single screen. Not available on the Free tier. |
Full request and response schemas for each underlying endpoint are in the API documentation, and the credit cost of every call is published on the API pricing page.
Setup
No install. One command for Claude Code.
The server is remote and stateless: there is no package to install, no binary to run and no build step to maintain, on any client. Claude Code connects in a single command; other clients take one pasted URL or config block.
1. Issue an API key
Create a CourtMesh account and generate a key from the API settings screen. Keys look like cm followed by a random string. API access is available on Enterprise accounts and through self serve signup, including a free credit grant, and the pricing page has the ladder in full.
2. Point your client at the server
Add the configuration below to Claude Desktop, Claude Code or Cursor. The server speaks streamable HTTP at a single URL and takes your API key as a bearer token, so there is nothing to install, host or keep updated.
3. Ask in plain language
Restart the client and the CourtMesh tools appear in its tool list. Ask a research question the way you would ask a junior, and the assistant picks the right tool, runs the search and cites the judgment it used.
Claude Code
Run this once with your API key in place of the sample below. There is nothing to install first; the command registers the hosted server directly, and the CourtMesh tools are available the next time you start Claude Code.
claude mcp add --transport http courtmesh https://mcp.courtmesh.ai/mcp \
--header "Authorization: Bearer cm-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxx"URL only, no custom header
Some clients, a Claude Desktop custom connector for example, only accept a server URL and cannot send an Authorization header. For those, the same key can travel as a token query parameter instead of a header.
https://mcp.courtmesh.ai/mcp?token=cm-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxSecurity note. A key carried in a URL can end up in shell history, browser history, server access logs and screen shares in a way a header does not. Prefer the Authorization header form above wherever your client supports it, and use this convenience form only when the client genuinely gives you no other choice.
Claude Desktop
Open Settings, then Developer, then Edit Config, and merge this into claude_desktop_config.json. Restart Claude Desktop and the CourtMesh tools appear in the tools menu. If your build of Claude Desktop instead offers a custom connector field that only takes a URL, use the URL-only form above.
{
"mcpServers": {
"courtmesh": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://mcp.courtmesh.ai/mcp",
"--header",
"Authorization: Bearer ${COURTMESH_API_KEY}"
],
"env": {
"COURTMESH_API_KEY": "cm-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxx"
}
}
}
}Claude Code, shared with your team
The one command above adds the server to your own user scope. To share the same connection with everyone on the repository instead, commit this as .mcp.json in the repository root.
{
"mcpServers": {
"courtmesh": {
"type": "http",
"url": "https://mcp.courtmesh.ai/mcp",
"headers": {
"Authorization": "Bearer cm-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxx"
}
}
}
}Cursor
Add this to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json inside a single repository. Then enable CourtMesh under Settings, MCP.
{
"mcpServers": {
"courtmesh": {
"url": "https://mcp.courtmesh.ai/mcp",
"headers": {
"Authorization": "Bearer cm-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxx"
}
}
}
}Other clients
Any client that supports remote MCP servers over streamable HTTP with a custom header will work, including ChatGPT custom connectors, Windsurf, Zed, VS Code agent mode and anything you build with an MCP SDK. Supply the server URL and an Authorization header carrying your key as a bearer token. The REST API accepts the same key in an X-API-Key header if you prefer that style in your own client. If a client only lets you configure a URL and no headers, fall back to the URL-only form above, with the same security tradeoff.
Billing
No new bill, just your API credits
The MCP server is a different doorway into the same API. There is no MCP subscription, no per seat charge and no separate wallet to top up.
Same credits, same prices
A tool call costs exactly what the underlying endpoint costs. Search is 1 credit, semantic search is 10, a stored analysis read is 1. Health checks and timeline polling are free.
Free to start
Every CourtMesh account begins with 2,500 API credits that never expire, plus 500 more free credits every month for as long as the account exists. That is enough to run the tools daily at no cost.
Your balance is the ceiling
An assistant can never spend credits you have not already bought. When the balance is short, the call is refused before it runs and nothing is charged. There is no overage invoice.
Usage is logged per API key, so you can see what an assistant spent and separate it from your backend traffic. If a workflow starts consuming real volume, prepaid packs start at ₹1,000 for 10,000 credits and the Scale plan carries 1,00,000 credits a month with rollover. The full ladder is on the API pricing page, and application plans for the Research, My Cases and My Agreements products are on the pricing page.
FAQ
MCP server questions
Indian Court Cases API
The REST surface behind every tool on this page.
OpenLitigation Check API
Screen a party name and get a confidence scored answer.
OpenCoverage and freshness
Records by court and year, free, no API key needed.
OpenAPI pricing
Credit cost of all 18 confirmed endpoints, free tier and packs.
OpenDocumentation
Authentication, schemas, pagination and error codes.
OpenContact us
Rollout access, enterprise volume and security review.
OpenGive your assistant a law library
Issue a key, paste one configuration block, and the next research question you ask Claude or Cursor comes back with real Indian judgments attached. Your first 2,500 credits are free and they never expire.