uscis api for case status

The USCIS Case Status API lets you programmatically fetch real-time immigration case information, including application status, background check results, and decision notices. This RESTful API is ideal for building case-tracking dashboards, integration with immigration law platforms, and automating status notifications for clients and applicants.

What Is the USCIS Case Status API?

The U.S. Citizenship and Immigration Services (USCIS) provides a public API for retrieving case status and receipt information. Rather than requiring users to manually log into the USCIS website or call phone lines, developers can integrate programmatic case lookups into applications. The API returns structured JSON responses containing case details, pending actions, background check status, and historical timeline information.

This API powers the official USCIS status tracker and is available for public use at no cost. It handles millions of queries annually for immigration petitions, adjustment of status, employment authorization documents (EAD), advance parole, and other case types processed by USCIS.

Core Endpoints and Capabilities

The USCIS API provides a single primary endpoint for case retrieval. You query by receipt number—a unique 13-character identifier assigned to each case (format: three letters followed by ten digits, e.g., EAC2412345678). The API returns case status, application type, field office or service center handling the case, and key milestone dates.

Key response fields include:

• Status: Case received, biometrics pending, decision, etc.
• Case Type: Form I-485 (adjustment of status), Form I-765 (EAD), Form I-131 (advance parole), and others
• Processing Location: The USCIS office responsible for the case
• Timeline Events: Application receipt date, biometrics appointment, decision date
• Background Checks: Field office name verification, biographical checks status

The API is rate-limited to protect infrastructure but accommodates typical business volumes. Responses include cache headers so applications can respect freshness intervals and avoid redundant queries.

Authentication and Setup

The USCIS Case Status API requires no API key or OAuth authentication—it's a public REST endpoint. To use it, you make HTTP GET requests with the receipt number as a query parameter or path component. This simplicity makes it easy to prototype but requires client-side rate limiting and caching in production.

Basic request format:

GET https://egov.uscis.gov/processing-times/api/casestatus/{receiptNumber}

The endpoint returns JSON with status code 200 on success. A 404 indicates the receipt number was not found in the system (either invalid format, not yet received, or future case); a 429 indicates rate limiting. For MCP integrations, configuring exponential backoff and local caching of recent queries reduces load and improves user experience.

Building Case-Tracking Applications

A typical use case is a law firm or immigration consultant building a client portal. Instead of asking clients to visit the USCIS website and search manually, you embed case-status lookups directly in your application. The user enters or confirms their receipt number once, and your app polls the API on a schedule (e.g., daily or weekly) to fetch updates and notify the user of status changes.

For individual applicants, common patterns include:

• Status Widgets: Display the current status and estimated processing time based on the case's service center
• Timeline Visualization: Show key milestones (application received, biometrics scheduled, decision) on a chronological chart
• Alerts: Notify users when status changes or when a new action is required (e.g., biometrics appointment)
• Bulk Tracking: Law firms query statuses for multiple clients in a single operation, aggregating results for reporting

To avoid overwhelming the API, implement local caching. Store the last-known status and timestamp; only query the USCIS API if a minimum time has elapsed (e.g., 1 hour). This also improves user-facing response times significantly.

Integration with MCP Tools and Agents

When building MCP-based immigration tools or agents that handle case inquiries, the USCIS API becomes a core data source. An agent handling client intake can automatically look up case status when given a receipt number, eliminating manual lookup steps. Tools for immigration law practices can expose the API as an in-app function, allowing paralegals and attorneys to check status without context-switching.

Key integration patterns:

• Stateless Queries: Treat each case-status lookup as independent; cache results in your application's database for historical tracking
• Error Handling: Handle invalid receipt numbers gracefully (suggest format or ask for confirmation); handle 429 errors with exponential backoff
• Data Enrichment: Combine USCIS status with your internal case notes, documents, and fee information to present a unified view
• Scheduled Updates: For active cases, poll the API periodically and log changes; alert users or internal staff when significant status changes occur

Rate Limiting and Performance Considerations

The USCIS API does not publish explicit rate limits but operates on a fair-use basis. Aggressive querying (e.g., thousands of requests per minute from a single client IP) will be throttled with 429 responses. In production, implement:

• Client-Side Caching: Cache results for at least 1 hour; use conditional requests if the API supports ETags or Last-Modified headers
• Deduplication: When multiple users request the same receipt number, share a single API call and distribute results
• Batch Processing: If querying many cases, space requests over time rather than in parallel bursts
• Fallback Display: If the API is unavailable, show the last-known status and a refresh timestamp so users understand the data may be stale

Typical response times are under 500ms. The API is hosted on USCIS infrastructure and is generally reliable, but plan for occasional maintenance windows or brief outages.

Working with Receipt Numbers and Case Types

Receipt numbers are case identifiers assigned when USCIS receives an application. The format is three letters (indicating the service center) followed by ten digits. Examples: EAC (Eastern Adjudication Center), LIN (Lincoln Service Center), WAC (West Adjudication Center).

Common case types queried via the API include:

• I-485 (Adjustment of Status): Applications to become a lawful permanent resident (green card) while in the U.S.
• I-765 (Employment Authorization): Requests to work while awaiting status decisions (e.g., during I-485 processing)
• I-131 (Advance Parole): Permission to travel abroad during pending applications
• I-140 (Immigrant Petition): Employment-based sponsorship of foreign workers
• N-400 (Naturalization): Applications for U.S. citizenship

The API response includes the case type, so you can apply type-specific logic (e.g., I-485 cases typically require biometrics; I-765 cases benefit from work-start notifications).

Privacy and Data Security

Receipt numbers are semi-public identifiers; anyone with a valid receipt number can look up status via the USCIS website or API. When building applications, treat receipt numbers with care:

• Validation: Confirm the applicant is authorized to view this case (e.g., they own the receipt number or are an authorized representative)
• Secure Storage: Encrypt receipt numbers in your database; use HTTPS for all API calls
• Audit Logging: Log who accessed which cases for compliance and fraud detection
• Compliance: If handling cases on behalf of clients, ensure you have appropriate privacy agreements and comply with relevant regulations

The API itself returns no sensitive personal information beyond what the USCIS status tracker displays publicly; it confirms status, processing location, and milestone dates only.

Live pricing — developer

Connect via MCP

$ curl -X POST https://apibase.pro/api/v1/tools/account.timeseries/call \
  -H "Content-Type: application/json" -d '{"params": {}}'

FAQ

Does the USCIS API require an API key or authentication?

No. The USCIS Case Status API is public and requires no authentication. You make HTTP requests with the receipt number, and the API responds with case information. This simplicity enables quick prototyping but means you should implement client-side rate limiting and caching to avoid overwhelming the service.

How often is case status updated in the API?

Case status updates in the API as USCIS processes cases. Updates typically occur within hours of internal status changes, but processing milestones (e.g., biometrics appointments) can take days or weeks to appear. For frequently-changing cases, polling every 1-6 hours is reasonable; for stable cases, daily checks suffice.

What should I do if a receipt number isn't found?

A 404 response typically means the receipt number is invalid, not yet received by USCIS (possibly mailed but not yet logged in the system), or formatted incorrectly. Suggest the user verify the number on their receipt notice or other official documents. New applications may take 1-2 weeks to appear in the system after mailing.

Can I query multiple cases in a single request?

The API does not support batch queries; each request must include one receipt number. For bulk lookups, make individual requests and implement caching to minimize API load. Spacing requests by a few hundred milliseconds prevents rate limiting.

Is the USCIS API suitable for real-time notifications?

Yes, but with caveats. You can poll the API on a schedule (e.g., hourly) and compare results to detect status changes, then send notifications. However, USCIS does not provide webhooks or push notifications, so pull-based polling is your only option. For better accuracy, combine API status with email notifications from USCIS (users can opt in via their USCIS accounts).

What service centers or locations are covered by the API?

The API covers all USCIS service centers and field offices. The response includes the processing location (office name or code), so you can look up detailed processing times from USCIS's public processing-times page for that location.

How can I integrate this into my law firm's practice-management system?

Build a custom integration or use an immigration software vendor that already integrates the USCIS API. Internally, query the API when a client asks about status, display results in your case management interface, and log the lookup in your case file. Consider periodic automatic polling for active cases and alerting staff or clients of changes.

Recommended next step

1. STEP 1/2 Connect your MCP client
2. STEP 2/2 Browse the full catalog

Related guides

• model context protocol mcp
• api composite list
• free weather api
• bing visual search api

Published: 2026-10-12Source: live apibase.pro catalog snapshot