Skip to main content
Glama

Search PACER Cases

search_pacer_cases

Search federal court case records by party, court, case type, and date range. Retrieve case metadata including title, parties, and filing date.

Instructions

Search federal court case records from PACER. Filter by party name, court code, case type, and date range. Returns case metadata including title, parties, court, and filing date. Source: PACER, updated daily. Note: This dataset is coming soon and may not have data yet.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
partyNoParty name to search for (plaintiff or defendant)
courtNoFederal court code (e.g. cacd = Central District of California, nysd = Southern District of New York, txed = Eastern District of Texas)
case_typeNoCase type (e.g. civil, criminal, bankruptcy)
date_fromNoStart date for filing date range (YYYY-MM-DD)
date_toNoEnd date for filing date range (YYYY-MM-DD)
limitNoMaximum number of results (default 25, max 100)

Implementation Reference

  • The registerPacerTools function registers 'search_pacer_cases' (and two other tools) onto the MCP server. Called from src/index.ts line 41.
    export function registerPacerTools(server: McpServer): void {
      // ── Search cases ─────────────────────────────────────────────────────────
    
      server.registerTool(
        "search_pacer_cases",
        {
          title: "Search PACER Cases",
          description:
            "Search federal court case records from PACER. Filter by party name, court code, " +
            "case type, and date range. Returns case metadata including title, parties, court, " +
            "and filing date. Source: PACER, updated daily. " +
            "Note: This dataset is coming soon and may not have data yet.",
          inputSchema: {
            party: z
              .string()
              .optional()
              .describe("Party name to search for (plaintiff or defendant)"),
            court: z
              .string()
              .optional()
              .describe(
                "Federal court code (e.g. cacd = Central District of California, " +
                "nysd = Southern District of New York, txed = Eastern District of Texas)",
              ),
            case_type: z
              .string()
              .optional()
              .describe("Case type (e.g. civil, criminal, bankruptcy)"),
            date_from: z
              .string()
              .optional()
              .describe("Start date for filing date range (YYYY-MM-DD)"),
            date_to: z
              .string()
              .optional()
              .describe("End date for filing date range (YYYY-MM-DD)"),
            limit: z
              .number()
              .int()
              .min(1)
              .max(100)
              .optional()
              .describe("Maximum number of results (default 25, max 100)"),
          },
        },
        async ({ party, court, case_type, date_from, date_to, limit }) => {
          const res = await apiGet<PacerCasesResponse>("/api/v1/pacer/cases", {
            party,
            court,
            case_type,
            date_from,
            date_to,
            limit: limit ?? 25,
          });
    
          if (!res.ok) {
            if (res.status === 404) {
              return {
                content: [
                  {
                    type: "text" as const,
                    text: "PACER dataset is not yet available. This data source is coming soon.",
                  },
                ],
              };
            }
            return {
              content: [
                {
                  type: "text" as const,
                  text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
                },
              ],
              isError: true,
            };
          }
    
          const { count, data } = res.data;
          const summary = `Found ${count} PACER case(s).`;
          const json = JSON.stringify(data, null, 2);
    
          return {
            content: [{ type: "text" as const, text: `${summary}\n\n${json}` }],
          };
        },
      );
  • The async handler function for 'search_pacer_cases'. It calls apiGet to /api/v1/pacer/cases with query parameters (party, court, case_type, date_from, date_to, limit), handles 404 for unavailable dataset, and returns formatted results.
    async ({ party, court, case_type, date_from, date_to, limit }) => {
      const res = await apiGet<PacerCasesResponse>("/api/v1/pacer/cases", {
        party,
        court,
        case_type,
        date_from,
        date_to,
        limit: limit ?? 25,
      });
    
      if (!res.ok) {
        if (res.status === 404) {
          return {
            content: [
              {
                type: "text" as const,
                text: "PACER dataset is not yet available. This data source is coming soon.",
              },
            ],
          };
        }
        return {
          content: [
            {
              type: "text" as const,
              text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
            },
          ],
          isError: true,
        };
      }
    
      const { count, data } = res.data;
      const summary = `Found ${count} PACER case(s).`;
      const json = JSON.stringify(data, null, 2);
    
      return {
        content: [{ type: "text" as const, text: `${summary}\n\n${json}` }],
      };
    },
  • Zod-based input schema for 'search_pacer_cases': optional fields party, court, case_type, date_from, date_to, and limit (int, 1-100, default 25).
    title: "Search PACER Cases",
    description:
      "Search federal court case records from PACER. Filter by party name, court code, " +
      "case type, and date range. Returns case metadata including title, parties, court, " +
      "and filing date. Source: PACER, updated daily. " +
      "Note: This dataset is coming soon and may not have data yet.",
    inputSchema: {
      party: z
        .string()
        .optional()
        .describe("Party name to search for (plaintiff or defendant)"),
      court: z
        .string()
        .optional()
        .describe(
          "Federal court code (e.g. cacd = Central District of California, " +
          "nysd = Southern District of New York, txed = Eastern District of Texas)",
        ),
      case_type: z
        .string()
        .optional()
        .describe("Case type (e.g. civil, criminal, bankruptcy)"),
      date_from: z
        .string()
        .optional()
        .describe("Start date for filing date range (YYYY-MM-DD)"),
      date_to: z
        .string()
        .optional()
        .describe("End date for filing date range (YYYY-MM-DD)"),
      limit: z
        .number()
        .int()
        .min(1)
        .max(100)
        .optional()
        .describe("Maximum number of results (default 25, max 100)"),
    },
  • The apiGet helper function used by the handler to make HTTP GET requests to the Verilex API.
    export async function apiGet<T = unknown>(
      path: string,
      params?: Record<string, string | number | undefined>,
    ): Promise<ApiResponse<T>> {
      const url = buildUrl(path, params);
    
      const headers: Record<string, string> = {
        Accept: "application/json",
        "User-Agent": "verilex-mcp-server/0.1.0",
      };
    
      // Forward x402 payment token if present in env (for paid endpoints)
      const paymentToken = process.env.VERILEX_PAYMENT_TOKEN;
      if (paymentToken) {
        headers["X-Payment-Token"] = paymentToken;
      }
    
      const res = await fetch(url, { headers });
      const data = (await res.json()) as T;
    
      const stale = res.headers.get("X-Data-Stale");
      const lastUpdated = res.headers.get("X-Data-Last-Updated");
      const ageSeconds = res.headers.get("X-Data-Age-Seconds");
    
      return {
        ok: res.ok,
        status: res.status,
        data,
        stale: stale === "true",
        lastUpdated: lastUpdated ?? undefined,
        ageSeconds: ageSeconds ? Number(ageSeconds) : undefined,
      };
    }
  • src/index.ts:41-42 (registration)
    Registration call site - registerPacerTools(server) is invoked to register all PACER tools including search_pacer_cases.
    registerPacerTools(server);
    registerWeatherTools(server);
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must convey behavior. It discloses source (PACER), update frequency (daily), and the note that data may be empty (coming soon). However, it does not explicitly state read-only nature or that it returns a list of results (though implied). Adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences plus a brief note. No redundant information. Every sentence adds value: what it does, how to filter, what it returns, source, and update cadence, plus an important caveat.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, description explains return fields (title, parties, court, filing date) and provides source, update frequency, and the important 'coming soon' note. For a search tool with 6 parameters and no output schema, this is complete enough for agent use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 100% parameter description coverage. The description lists filters (party, court, case type, date range) which overlaps with schema. No additional semantic detail beyond what schema provides. Baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses specific verb 'Search' and resource 'federal court case records from PACER', lists filters, and mentions return fields. Clearly distinguishes from sibling tools like get_pacer_case (retrieve single case) and pacer_stats (aggregated stats).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Clearly states the tool is for searching PACER cases with multiple filters. Does not explicitly exclude use cases or compare to alternatives, but the note about data being 'coming soon' provides important context. Implicitly different from get_pacer_case and pacer_stats.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/carrierone/verilexdata-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server