Introduction

This documentation describes an API for accessing data from US courts, including from PACER.

Background

What is a docket?

Court cases are organized into “dockets.” A new docket is created when a person sues another, files for bankruptcy, is prosecuted for a crime, or appeals a judgment. The docket is a list of public documents in the case. Every time a document is submitted to the judge, the document appears on the court “docket.” Every time the judge issues an order, it also appears on the docket. Typical cases have anywhere from a few docket entries to several thousand.

A docket entry usually consists of a date, a short summary, and a PDF file. Below is an example of a docket entry:

The docket entry above contains a date, a document with filing number 459, a PDF attachment, and a summary. Note that the summary may contain HTML formatting.

What does the Docket Alarm API do?

Docket Alarm provides a single unified REST API to hundreds of US courts (including PACER), to retrieve docket metadata and the associated PDF court filings. By providing a single API and response schema, your application can access data from hundreds of courts with one API.

The API supports legal automation, research, and alerting workflows. There are over 675M tagged court dockets and OCRed PDF documents, with internal text searchable. Read more about boolean query support here. Motion analysis (motion type/outcome/importance) is available, contact support@docketalarm.com for details on obtaining additional value-added metadata.

Docket Alarm’s connection to the USPTO (PTAB/TTAB, TSDR, PAIR), allows for automating IP portfolio analysis and other prosecution/litigation related workflows. See a full listing of available jurisdictions here.

Why You Need This API

The Docket Alarm API is quite powerful and customizable, but for many users, it’s overkill. We receive many inquiries about our API for projects that can be solved with a standard Docket Alarm subscription. The guidelines below can help you decide if your organization really needs access to the API, or can suffice with a standard Docket Alarm subscription.

Feel free to reach out to questions@docketalarm.com to get more information.

Getting Started and Libraries

The following is the typical flow of API calls:

• Log into the Docket Alarm API with login/.
• Run a full-text-search for dockets or documents with search/.
• (Optional) Search PACER directly for dockets with searchpacer/.
• Update a docket with fresh court information with getdocket/.
• Retrieve PDF documents associated with the docket.
• Setup docket tracking with track/.
• Receive API push notifications of docket updates.

Docket Alarm provides a python client library and a sample test program to help you get started. If you are developing in python, it is highly recommended that you look to that library first when developing your application.

The source code and corresponding documentation is available here:
     https://github.com/speedplane/docketalarm-api

Quickstart Sample Code

Below is a quick Python 2/3 code snippet that finds recent cases where Doordash or Uber were sued, and prints out the 3 most recent dockets.

# We'll use the json library to decode the responses.
import json
# Helpful for printing.
import pprint
# There are many python libraries for downloading API data (Requests,
# urllib3, etc.). Below, we import the built-in python `urllib` routines and
# use the six library for Python 2 and 3 compatibility.
from six.moves.urllib.request import Request, urlopen
# A python helper function used to turn dictionaries into url-encoded requests.
from six.moves.urllib.parse import urlencode
# All API calls start with this URL
base_api = "https://www.docketalarm.com/api/v1/"

#########
# Login: calls to login/ require a POST request, so "data= ... user/pass ..."
req = Request(base_api + "login/", data = urlencode({
    'username' : 'YOUR_EMAIL',
    'password' : 'YOUR_DOCKET_ALARM_PASSWORD'
}))
# Make the HTTP request.
response = urlopen(req).read()
# Convert the JSON response into python dictionary
json_response = json.loads(response)
# If there's a problem logging in, `success` is False and `error` has a
# description (e.g., bad password).
if not json_response['success']:
    raise Exception("Cant login to Docket Alarm API: " + json_response['error'])
login_token = json_response['login_token']

#########
# Search: calls to search/ are a GET, so use query param encoding "?q=..."
req = Request(base_api + "search/" + "?" + urlencode({
    # The login token from the previous call
    'login_token' : login_token,

    # A research note or internal matter number, useful for tracking.
    'client_matter' : 'first-api-search-test',

    # The query below searches for dockets where Doordash or Uber were sued.
    # The query language is powerful, and can do a number of fielded searches.
    # Detailed documentation is below, you can also test queries on the website.
    # https://www.docketalarm.com/posts/2014/6/23/Terms-and-Connectors-Searching-With-Docket-Alarm/
    'q' : 'party:(name:(door-dash OR uber) type:defendant) is:docket',

    # Newest first (also try -date_last_filing, random, or blank for relevance).
    # Note: The query language supports additional date filters for precise bucketing.
    'o' : '-date_filed',

    # Offset and limit allow for paging through results. You can get up to 50 at
    # a time, and offset up to 1000. After that, use date bucketing or scroll api.
    # The settings below get the first 3 results.
    'offset' : 0,
    'limit' : 3,
}))
# Make the request. In production, wrap with a try/except to handle errors.
search_response = json.loads(urlopen(req).read())
# Print out the total count. This is the total number of results, which may be
# much higher than the limit of 3.
print("Search found " + str(search_response['count']) + " results")

#########
# Loop over the results
count = 0
for result in search_response['search_results']:
    count += 1
    print("----------------------------------------------------------------")
    print("Getting Result " + str(count) + " for: " + result['title'] +
        ", " + result['docket'] + " " + result['court'])

    # The getdocket/ request uses GET, so again use "?"
    req = Request(base_api + "getdocket/" + "?" + urlencode({
        # Same login token as before
        'login_token' : login_token,

        # Another research/billing/client code of your choice.
        'client_matter' : 'first-api-getdocket-test',

        # The court name and docket number from the search result:
        'court' : result['court'],
        'docket' : result['docket'],

        # Important: You have a choice of pulling Docket Alarm's most recent
        # copy of the docket, or getting an update directly from the court.
        # If you set cached=True, you will get Docket Alarm's copy.
        # Setting cached=False (or leaving it blank), will contact the court to
        # retrieve an updated docket sheet. For Federal cases, PACER fees apply
        # for pulling updated docket sheets (no other courts charge for this).
        'cached' : True,
    }))
    docket_response = json.loads(urlopen(req).read())
    # Take a look at the docket.
    pprint.pprint(docket_response)
print("Done!")

Unexposed and Deprecated Features

Docket Alarm is capable of more features than those exposed in the API. Some unexposed features in the documentation are noted below. If you require unexposed functionality, or any other functionality, reach out to us and ask. We welcome all feedback on requested features.

Also, from time-to-time, we may deprecate certain functionality of the API for technical or business reasons. When an API endpoint is deprecated, it is accessible, but will be removed from a future release. Accordingly, users should not use deprecated API functionality. If you are using deprecated API functions that you need, let us know.

Please send questions and comments to support@docketalarm.com.

Recent API Changes

Unless otherwise noted, all changes are backwards compatible. Feel free to contact us about any specific changes.

API Conventions

API calls are either GET or POST made to the following base address:

https://www.docketalarm/api/v1/

All calls should be made with HTTPS, otherwise login credentials may be intercepted. Unless otherwise noted, all data sent via POST request must be in HTTP form data format with the Content-Type header set to application/x-www-form-urlencoded.

Return Values

Calls to most endpoints always return a HTTP 200 message and a JSON body. All JSON responses have the following parameters:

When successfully retrieving a PDF document, a 200 Response is returned and the body is the binary PDF file. When unsuccessful, the response may be 403 and JSON will be returned as the body.

Also note that all dates that are returned are in the form mm/dd/yyyy (e.g., '02/08/2012') and all parameters which contain dates must be submitted in the same format.

API Versions

Whenever we increase an API point version number (e.g., 1.0 to 1.1), all changes are backwards compatible. That means that a Docket Alarm API client written for 1.0 will always work for version 1.1, 1.2, etc.

When we increase major version numbers (e.g., 1.0 to 2.0) we may break compatibility with prior API versions. However, when we do so, we will also change the endpoint URL and we may continue to support the older API versions.

Testing

Certain API calls may incur fees. To reduce costs while testing, we have provided a test-bed system that returns fake data. To use the test system, add the parameter test to each GET or POST request. You will not be charged when using this parameter.

Note: You only need to include the test parameter to put the API in test mode, i.e., you do not need to give it a value.

Testing Push Notifications

Push notifications are only sent when there is a new item that posts to the docket. You can test push notifications with fake data by making a POST call to track/ and adding test as a parameter.

How to Setup a Test Account

To access test data, you do not need a paid Docket Alarm account, you just need a login email and password. To create an account, go to docketalarm.com, select "Signup", and enter a username and password. You will be presented with a payment form, but you can ignore that. The test API is already enabled on your account.

Retrying Failed Requests

In several API calls below, Docket Alarm contacts the court to request refreshed information. The connection to the court systems can fail due to regular maintenance, heavy court server load, or a CAPTCHA failure. We recommend that you implement a retry and backoff system when making requests to Docket Alarm's API, and limit your request rate to these endpoints.

For reference, the API endpoints that may contact the court are: searchdirect/, getdocket/ with cached set to false, and pulling documents.

Authentication

All requests to the Docket Alarm API must be authenticated with a valid Docket Alarm username and password. If you do not have a Docket Alarm account, create one at www.docketalarm.com. You will need a credit card or your PACER credentials to download PACER documents.

There are two methods of authentication. You may choose either based on what is most convenient and secure for your needs:

To obtain a temporary token, send a username and password to the login/ endpoint and obtain a login_token. The login_token must then be used in all subsequent requests. The login_token is active for 90 minutes, after which a new call to login must be made.

POST Parameters

Return Values

If the username or password is invalid, an error will be generated. Otherwise, it will return:

Example

A successful login request and response.

Request:

	POST https://www.docketalarm.com/api/v1/login/
		username=foo%40example.com&
		password=aaa

Response:

200
{
	'login_token':'839dbcf5fa7768ea912341011ba754c354bc75792494804fb6f56538',
	'success': true
}

Types of Searching

There are two ways of searching court records on Docket Alarm: search Docket Alarm's database, or use Docket Alarm as an intermediary to search a court directly. One method may be preferred to the other in various circumstances.

Search Docket Alarm

Docket Alarm has been retrieving court records for many years, and has built one of the largest databases available, with over 675M dockets and documents (Aug. 2022). We index these records in a variety of ways, and allow you to use a unified search system to perform full text as well as complex fielded searches. Docket Alarm offers more powerful searching, with higher data limts, than any court system provides.

To search Docket Alarm, use the search/ endpoint.

The limitation of searching Docket Alarm's database is that it relies on Docket Alarm to have already pulled in the data. We pull down an enormous number of records, but sometimes you may need further customization on our own update schedule. In these cases, cases, you'll want to search courts directly.

Searching Courts Directly

Docket Alarm provides another means of searching: searching courts directly. In this case, Docket Alarm connects to the court, and makes a request on your behalf. It then returns the results in a standardized format.

The difficulty with searching courts directly is that each court has its own set of search options, update schedule, request rate limit, and in some cases cost. This API provides a unified interface to the otherwise haphazard system of searching state and agency courts.

The direct search APIs are divided into two:

• searchpacer/: For searching PACER / Federal courts.
• searchdirect/: For searching everything else.

The two endpoints deliver very similar data, but they are split into two because as of Dec. 2020, the searchpacer/ can incur additional court fees whereas searchdirect/ cannot.

Summary Chart

When integrating with the API, you must decide whether you want to search Docket Alarm or use Docket Alarm to search the court directly.

Search Docket Alarm

As of March 2023, Docket Alarm has more than 732 million records in its database, making it one of the largest such databases available. Searching on Docket Alarm is fast and easy, and is the preferred search option unless you have specific requirements.

The search/ endpoint searches every docket and document on Docket Alarm.

GET Parameters

Return Values

search_results

Each search result is a JSON dictionary object with the following key value pairs

Note: even though search results do not return snippets, we provide a separate undocumented API for creating them. Contact support for more details.

import urllib
import json

# Create all the GET arguments
get_args = {
    # Generate the login token using the login endpoint described above.
    'login_token': '',
    # This is the query that is used to run the search
    'q': 'is:docket party:(3M) type:trademark',
    # Limit to 20 results at a time
    'limit': 20,
    # Start with the first result.
    'offset': 0,
    # Newest cases first.
    'o' : '-date_filed',
}
# URL Encode all of the arguments together
get_args_encoded = urllib.urlencode(get_args)
# Append to search endpoint
full_url = 'http://www.docketalarm.com/api/v1/search/?' +  get_args_encoded

# Execute the API command
fp = urllib.urlopen(full_url)
# Read its contents
contents = fp.read()
# Decode the contents from JSON into a python dictionary.
json_contents = json.loads(contents)

# Print the output
print(json_contents)

import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.util.HashMap;
import java.util.Map;
import java.net.URL;
import java.net.URLEncoder;
import java.net.HttpURLConnection;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
  public static void main(String[] args) throws MalformedURLException,
                                   UnsupportedEncodingException, IOException {
        // Create all the GET arguments
        Map<String, String> get_args = new HashMap<String,String>();
        get_args.put("login_token", "");
        // This is the query that is used to run the search
        get_args.put("q", "is:docket party:(3M) type:trademark");
        // Limit to 20 results at a time
        get_args.put("limit", "20");
        // Newest cases first.
        get_args.put("o", "-date_filed");

        // Start with the base url
        String base_url = "https://www.docketalarm.com/api/v1/search/?";
        // We will add parameters
        String encoded_params = "";
        // using for-each loop for iteration over Map.entrySet()
        for (Map.Entry<String, String> entry : get_args.entrySet()) {
            // URL Encode the value.
            String v = URLEncoder.encode(entry.getValue(), "UTF-8");
            encoded_params += "&" + entry.getKey() + "=" + v;
        }
        // Combine the base url with the encoded values
        URL url = new URL(base_url + encoded_params);
        // Print out the generated URL
        System.out.println("Encoded API URL: " + url);
        // Create the HTTP Request
        HttpURLConnection con = (HttpURLConnection)url.openConnection();
        con.setRequestMethod("GET");
        // Make the request and
        try(BufferedReader br = new BufferedReader(
          new InputStreamReader(con.getInputStream(), "utf-8"))) {
            StringBuilder response = new StringBuilder();
            String responseLine = null;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
        }
        // Print out the generated URL
        System.out.println("API Response: " + response);
        // You will want to parse the JSON with a library like GSON
  }
}

Scrolling Results

If your application requires scrolling through more than 1000 results, you must use the scroll API. This API can be somewhat complex, so if possible, you should divide your search results into chunks smaller than 1000 results and use the normal search API.

If you need to scroll through many thousands or millions of records efficiently, the scroll API can help. It also supports parallel searches allowing you to make multiple requests at once.

1. Scroll API - Setup

To use the API, you must first decide how many parallel requests you want to use to scan through results. This will be scroll_parallel. If don't want to do requests in parallel, set to 1.

Then, make scroll_parallel number of search requests. The requests take the same paramaters as a normal search, but you must also include two new parameters: scroll_parallel, set to the number of parallel requests. In addition, scroll_index, corresponding to the request number, ranging from 0 to scroll_parallel-1.

2. Scroll API - Scrolling

After each of the setup requests complete, the result will contain a list of results just like the normal search command, but will also include an additional field called scroll. This field's value contains state about the search.

For each of your parallel requests, take the previous result scroll and pass it into the next requests, along with the other parameters scroll_parallel and scroll_index. The scroll values may vary from request to request, always use the last one.

The following parameters should be added to your request to search/:

Example of Scrolling with 3 Parallel Threads

This example uses three requests that can be run in parallel (i.e., you don't need to wait for one to complete to start the next). The first 3 requests set things up (and also return results):

GET https://www.docketalarm.com/api/v1/search/?q=...&scroll_parallel=3&scroll_index=0
GET https://www.docketalarm.com/api/v1/search/?q=...&scroll_parallel=3&scroll_index=1
GET https://www.docketalarm.com/api/v1/search/?q=...&scroll_parallel=3&scroll_index=2

If successful, the result will be (abbreviated):

200
{
  "count": 355,
  "search_results": [{ ... }, ...],
  "success": true,
  "scroll": "DnF1...="
}

200
{
  "count": 355,
  "search_results": [{ ... }, ...],
  "success": true,
  "scroll": "DnF2...="
}

200
{
  "count": 355,
  "search_results": [{ ... }, ...],
  "success": true,
  "scroll": "XS12...="
}

Subsequent requests will include the scroll parameter returned by the first. You do not need to include scroll_parallel or scroll_index on subsequent requests.

GET https://www.docketalarm.com/api/v1/search/?q=...&scroll=Dnf1...=
GET https://www.docketalarm.com/api/v1/search/?q=...&scroll=Dnf2...=
GET https://www.docketalarm.com/api/v1/search/?q=...&scroll=XS12...=

Search PACER

Search for PACER dockets using the searchpacer/ endpoint.

Blank GET Request

If no GET parameters (besides the required login_token and client_matter) are supplied, we return a dictionary with information that can be helpful to this search method:

GET Parameters

Return Values

search_results

Each search result is a JSON dictionary object with the following key value pairs

Example

Search for cases where Sony is a party:

	
	GET https://www.docketalarm.com/api/v1/searchpacer/?login_token=...&party_name=Sony&client_matter=&page=2
	

If successful, the result will be (abbreviated):

200
{
	'page_max': 4,
	'search_results':
	[
		{
			'title': 'Broadcast Music Inc et al v. Camp Lounge L L C et al',
			'court': 'Louisiana Western District Court',
			'docket': '6:13-cv-01271',
			'party_role': 'Plaintiff',
			'party_name': 'Sony A T V Tree Publishing',
			'date_filed': '5/29/2013',
			'date_terminated': '',
			'link': 'https://www.docketalarm.com/cases/Louisiana_Western_District_Court/6--13-cv-01271/Broadcast_Music_Inc_et_al_v._Camp_Lounge_L_L_C_et_al/',
			'nature_of_suit': '820'
		},
		...
		{
			'title': 'Adaptix, Inc. v. Sony Mobile Communications, Inc. et al',
			'court': 'Texas Eastern District Court',
			'docket': '6:13-cv-00442',
			'party_name': 'Sony Mobile Communications (USA), Inc.',
			'party_role': 'Defendant',
			'date_filed': '5/28/2013',
			'date_terminated': '',
			'link': 'https://www.docketalarm.com/cases/Texas_Eastern_District_Court/6--13-cv-00442/Adaptix_Inc._v._Sony_Mobile_Communications_Inc._et_al/',
			'nature_of_suit': '830'
		},
	],
	'success': true
}

Search Direct

Search state and agency dockets directly with the searchdirect/ endpoint.

Because this endpoint contacts the court directly, it does not rely on Docket Alarm having a copy of the case. However, it is more challenging to use and has fewer search options than the search/ endpoint. This endpoint is analogous to searchpacer/, but for non-PACER courts.

Note: many courts do not have robust servers, and it is common for requests to fail due to high server load or maintenance. Accordingly, users of this endpoint should be prepared to handle errors and retry requests.

There are generally three steps that need to be performed when using this endpoint:

• GET Request: Return a list of courts that support the searchdirect/ endpoint.
• GET Request with a court Parameter: Get the required and optional search arguments for searching with the searchdirect/ endpoint.
• POST Request: Run the search.

Blank GET Request

A blank GET request is used to get the list of courts supported by this endpoint (login_token and client_matter are still required).

Returns a dictionary with a courts parameter, listing every court that is covered by this endpoint.

    200
    {
        'courts': [
            "Supreme Court of the United States",
            "California State Supreme Court",
            "Connecticut State, Supreme Court",
            "Florida State, Supreme Court",
            "Minnesota State, Supreme Court",
            "Nevada State, Supreme Court",
            "Oregon State, Supreme Court",
            "Pennsylvania State, Supreme Court",
            "South Carolina State, Supreme Court",
            ...
        ],
        'success': true
    }
    

GET Request

If the court parameter is added, then a structure is returned documenting the required and optional search parameters, and also, allowed values for those parameters.

Below is an example call:

        searchdirect/?login_token=...&client_matter=...&court=Pennsylvania%20State,%20Commonwealth%20Court

And the response:

	200
	{
		"success": True,
		"required": ["court"],
		"optional": ["docketnum", "party_name", "county",
					 "court_office", "date_filed_start", "date_filed_end",
					 "max_pages"],
		"choices": {
			"max_pages": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
						  16, 17, 18, 19, 20, 21, 22, 23, 24, 25],
			"county": [null, "Adams", "Allegheny", "Armstrong", "Beaver",
					"Bedford", "Berks", "Blair", "Bradford", "Bucks",
					"Butler", "Cambria", "Cameron", "Carbon", "Centre",
					"Chester", "Clarion", "Clearfield", "Clinton",
					"Columbia", "Crawford", "Cumberland", "Dauphin",
					"Delaware", "Elk", "Erie", "Fayette", "Forest",
					"Franklin", "Fulton", "Greene", "Huntingdon",
					"Indiana", "Jefferson", "Juniata", "Lackawanna",
					"Lancaster", "Lawrence", "Lebanon", "Lehigh",
					"Luzerne", "Lycoming", "McKean", "Mercer", "Mifflin",
					"Monroe", "Montgomery", "Montour", "Northampton",
					"Northumberland", "Perry", "Philadelphia", "Pike",
					"Potter", "Schuylkill", "Snyder", "Somerset",
					"Sullivan", "Susquehanna", "Tioga", "Union",
					"Venango", "Warren", "Washington", "Wayne",
					"Westmoreland", "Wyoming", "York"]},
	}
    

POST Request

A POST request to this endpoint must specify all of the required search parameters to perform the search.

The result is returns a dictionary with an entry search_results, a list of dictionaries. Each dictionary in search_results has the following format:

Retrieving a Docket

Download a case's docket information using the getdocket/ endpoint.

GET Parameters

Return Values

info

docket_report

Each entry in a docket_report is a dictionary with the following key-value pairs:

{
	"number": "335",
	"date": "6/18/2021",
	"entry_date": "6/18/2021",
	"contents": "ORDER granting in part and denying in part 240 Defendant's Motion for Summary Judgment",
	"exhibits": [],
	"link_viewer": "https://www.docketalarm.com/.../",
	"link": "https://www.docketalarm.com/...pdf",
	"analyze": {
		"parser_types": [{
			"type": "order"
			"identifier": "summaryjudgment",
			"confidence": "very_high",
			"outcome": [
				"granted",
				"denied"
			],
			"related": [{
				"index": 350,
				"number": "240"
			}],
			"days_sequence": 141,
			"days_briefing": 35,
			"days_decision": 106,
			"snippet": "ORDER granting in part and denying in part 240 Defendant's Motion for Summary Judgment",
		}]
	}
}

{
	"success": true,
	"type": ["motion", "order", "pleading", "reply", "response"],
	"identifier": {
		...
		"summaryjudgment": {
			"sali_identifier": "http://lmss.sali.org/RGcqiLEe0IK8lPRt5mFC0D",
			"name": "Motion for Summary Judgment",
			"ambiguous": false,
			"sali_link": "https://webprotege.stanford.edu/#projects/762dd7d4-2b61-4c9f-bb27-9b5e8fa056ea/edit/Classes?selection=Class(<http://lmss.sali.org/RGcqiLEe0IK8lPRt5mFC0D>)",
			"name_display": "Summary Judgment",
			"types": ["motion", "order", "response", "reply"],
			"can": {
				"analytics": true,
				"sequence": true,
				"search": true
			},
			"parent": null,
			"priority": 10,
			"category": ["Dispositive", "Judgment"]
		},
	...
	}
}

parties

counsel

The counsel data structure contains information on the attorney representing the party. It includes the attorney’s name, law firm, role in the case, and contact information. The fields are as follows:

related

A list of cases related to this docket sheet. Each related case is a dictionary with the following fields:

Note: You can search and filter cases based on the relationship field as well. For example, searching
related:(type:(Original Case) court:(New York)) will find cases that are appealed from a New York court.

claims

A list of claims made by the plaintiff/entity bringing the action. Each claim is a dictionary with the fields below.

Most courts do not support the claims field, to see a list of supported cases, run a search for claim:"".

Example

Here is a case in the Southern District of New York:

	GET https://www.docketalarm.com/api/v1/getdocket/?docket=1%3A11-cv-06909&login_token=...&court=New+York+Southern+District+Court&client_matter=

If successful, the result will be (abbreviated):

200
{
	"info": {
		"title": "Kickstarter, Inc. v. Fan Funded, LLC et al", 
		"date_filed": "09/30/2011", 
		"magistrate": null, 
		"nature_of_suit": "830 Patent", 
		"judge": "Judge Katherine Polk Failla"
	},
	"parties" : [
		{
			"type": "Defendant", 
			"name": "Fan Funded, LLC",
			"counsel": [
				{
				  "firm": "Steptoe & Johnson, LLP (DC)", 
				  "name": "Michael Jarrett Allan", 
				  "phone": "202-555-3000", 
				  "email": "mallan@foo.com"
				}, 
				{
				  "firm": "Steptoe & Johnson, LLP (NYC)", 
				  "name": "Evan Glassman", 
				  "phone": "212-555-3900", 
				  "email": "eglassman@bar.com"
				}
			]
		},
		{
			"type": "Plaintiff", 
			"name": "Kickstarter, Inc."
		},
		...
	],
	
	"docket_report": [
		{
			"link": "https://www.docketalarm.com/cases/New_York_Southern_District_Court/1--11-cv-06909/Kickstarter_Inc._v._Fan_Funded_LLC_et_al/docs/107.pdf", 
			"entry_date": "9/11/2014", 
			"date": "9/11/2014", 
			"contents": "	DECLARATION of Matthew Ambros & William Seymour in ... ",
			"exhibits" : [
				{
				"link": "https://www.docketalarm.com/cases/New_York_Southern_District_Court/1--11-cv-06909/Kickstarter_Inc._v._Fan_Funded_LLC_et_al/docs/107/1.pdf",
				 "exhibit" : "1"
				},
				{
				"link": "https://www.docketalarm.com/cases/New_York_Southern_District_Court/1--11-cv-06909/Kickstarter_Inc._v._Fan_Funded_LLC_et_al/docs/107/2.pdf",
				 "exhibit" : "2"
				}
			]
		},
		...
		{
			"link": "https://www.docketalarm.com/cases/New_York_Southern_District_Court/1--11-cv-06909/Kickstarter_Inc._v._Fan_Funded_LLC_et_al/docs/78.pdf", 
			"entry_date": "9/6/2013", 
			"date": "9/6/2013", 
			"contents": "JOINT STIPULATION AND MODIFIED ... ",
			"exhibits" : []
		}, 
		{
			"link": null, 
			"entry_date": "9/6/2013", 
			"date": "9/6/2013", 
			"contents": "***NOTE TO ATTORNEY TO RE-FILE DOCUMENT - NON-ECF DOCUMENT ERROR. Note to ... ",
			"exhibits" : []
		}, 
		{
			"link": null, 
			"entry_date": "8/16/2013", 
			"date": "8/16/2013", 
			"contents": "Minute Entry for proceedings held before Judge Katherine Polk Failla: ...",
			"exhibits" : []
		},
		...
	],
	"success": true
}

Retrieving a Document

Retrieving documents with a GET request. The URL for the request is the value link (see the getdocket/ section) in a docket entry. The URLs are relative to Docket Alarm’s hostname.

Rather than returning JSON, the call returns the binary PDF document.

Additional GET parameters include:

Example

If the link in the docket entry is as follows:

	cases/Arkansas_Eastern_District_Court/4--2010-cr-00188/USA_v_Vargas_et_al/docs/425.pdf

Then the document may be downloaded with the following call:

	GET https://www.docketalarm.com/cases/Arkansas_Eastern_District_Court/4--2010-cr-00188/USA_v_Vargas_et_al/docs/425.pdf?login_token=...

To download the document only if it was previously downloaded:

	GET https://www.docketalarm.com/cases/Arkansas_Eastern_District_Court/4--2010-cr-00188/USA_v_Vargas_et_al/docs/425.pdf?cached&login_token=...

If there are no errors, the result should be a binary PDF document.

Errors and Sealed Documents

If there is an error downloading the document, then the API will return a status code other than 200 and a JSON response in the body. The JSON body will a dictionary with success set to false and error set to a corresponding error message.

Below is a table of HTTP response codes and their meaning. Check the error field for more information:

Tracking Cases

You may configure the API to send notifications of new case activity on a court docket. By default, these notifications are emailed, but you may also configure the API to send them to a server of your choosing (see Push Notifications below).

There are two types of requests you can make to the track/ endpoint, a GET request (to get the tracking status) or a POST request (to change tracking status).

		GET https://www.docketalarm.com/api/v1/track/?login_token=...
	

	200
	{
	  "dockets": [{
		  "court": "California Northern District Court", 
		  "docket": "3:14-cv-03985"
		  "title": "Telesocial Inc. v. Orange S.A. et al", 
		  "enabled": false, 
		  "frequency": "twice_daily", 
		  "datetime_updated": null,
		},{
		  "court": "Patent Trial and Appeal Board", 
		  "docket": "IPR2016-00291", 
		  "title": "Inter Partes Review of U.S. Pat. 5,732,375", 
		  "enabled": false
		  "frequency": "weekly", 
		  "datetime_updated": "2020-01-17T20:57:14.648000",
	  }], 
	  "success": true
	}
	

		GET https://www.docketalarm.com/api/v1/track/?docket=4%3A2010-cr-00188&login_token=...&court=Arkansas+Eastern+District+Court
	

	200
	{
		'enabled': 	true,
		'frequency':'twice_daily',
		'success':	true,
	}
	

POST Request

Use a POST request to the track/ endpoint to (1) create a new tracker, (2) modify an existing tracker, or (3) simulate a push notification for testing.

POST Request Result

There are no special return values for this HTTP request. As with all calls to the Docket Alarm API, if the request was successful, the success parameter will be true. Otherwise, success will be false and error will return an error message.

POST Example

	POST https://www.docketalarm.com/api/v1/track/
		docket=4%3A2010-cr-00188&
		login_token=...&
		court=Arkansas+Eastern+District+Court&
		client_matter=&
		frequency=twice_daily

The result will be:

200
{
	'success': true,
}

Receiving Push Notifications

Docket Alarm can send push notifications when it detects a new court event. There are several types of events:

• New Docket Item: Sent when a new case docket event is detected on an existing case. These alerts can be created via the API. See POST track.
• New Search Result: Sent when a new search result is detected. Used to detect new lawsuits, or new documents across many cases. These alerts are customizable, and can be created via the API. See POST track.
• New PACER Case: This is a specialized alert for PACER nature of suit codes. These alerts are setup via the UI, under "New Case Alerts --> Federal District". These alerts cannot be created via the API.

Whenever any of the events above is triggered, Docket Alarm sends a HTTP POST request to a URL endpoint. To setup a notification endpoint, email us and we'll set it up for you. Alternatively, you may use the subaccount/ endpoint to setup notification URLs via the API.

The JSON payload of the push notifications depends on the notification type, and is described in the sections below.

Retry Handling

When we send a push notification, we expect a 200 valid response. If there is a problem sending the push notification (we receive a non 200 status message), we retry up to 10 times with an exponentially longer delay: the minimum retry time being 10 minutes and the longest 4 hours.

Debugging / Testing Push Notifications

To simulate an API push, use the test_track or test parameters in part of a POST to the track/ endpoint. See track/ for further documentation.

To see the status of recent notifications, use the track/ endpoint, and read the value of _api_push_debug_info. You can test push notifications to make sure they are properly setup.

{
	'push_type': 'new_case',
	'client_matter': 'Best Client',
	'party_name': 'Sony',
	'search_results': [
		{
			'docket': '1:13-cv-22843',
			'nature_of_suit': '840',
			'court': 'Florida Southern District Court',
			'date_filed': '8/8/2013',
			'title': 'Effs v. Sony Pictures Home Entertainment Inc. et al'
		},
		{
			'docket': '2:13-cv-05682',
			'nature_of_suit': '190',
			'court': 'California Central District Court',
			'date_filed': '8/6/2013',
			'title': 'Richard Arons v. Sony Music Entertainment Inc et al'
		},
}

Sub Accounts

Docket Alarm supports creating sub accounts to your master account with the subaccount/ endpoint. This is helpful if you are developing an application and your users need isolated Docket Alarm accounts. Each sub account has their own email/password login, shows up separately on the monthly receipt, can maintain their own isolated set of case trackers, and can have separate push notification URLs.

Once a sub account is created and linked to a master account, you can log into it like any other Docket Alarm account. When making API calls with a sub account, you must first request the login/ endpoint to retrieve a login_token for that account. Sub accounts cannot have their own sub accounts.

For security reasons, by default, this endpoint is turned off. To have it turned on, email us and request access for your account.

Sub account features are made by GET and POST requests to the subaccount/ endpoint.

GET Request

A GET request to subaccount/ returns information about the currently active sub accounts. The only required parameter is the login_token. The return values are:

Sub account Dictionary

Each dictionary in the subaccounts list above has the following fields:

POST Request

A POST to subaccount/ can be used to create new accounts or modify existing accounts, and link and unlink them from the master account. The request parameters are:

Sub-Account Login - SSO

Docket Alarm supports Single-Sign-On via its API via the subaccount/login endpoint. To login as a user, you must first create the user (using the API or the website), then generate an encrypted login link that you can use as a redirect for the user.

Follow the steps below:

• Log in to the Docket Alarm API with your master account with the login/ endpoint.
• Make sure the user you want to login as exists (either with the subaccount/ endpoint described above or using the website interface).
• Make a GET to subaccount/login with the master account's login_token and the sub account's email address for the username (see below).
• The subaccount/login endpoint returns a JSON object with a url field.
• Redirect the user to the url.

Getting the User's Login URL

The subaccount/login endpoint can be made with the following parameters.

If the user exists, the response of the call will contain a json object with the items:

Example

A successful sub account login request:

	https://www.docketalarm.com/api/v1/subaccount/login/?username=foo%40example.com&login_token=8123...ac

Response:

200
{
  "url": "https://www.docketalarm.com/api/v1/subaccount/login/?encrypted_sso_token=ABCD...YwEtRpqZDOkKndm2mGcdAm2KeKTnH3n9&redirect=/dockets",
  "login_token" : "ABCD123...",
  "success": true
}

The URL in the response can be passed to the user so they can login to their account.

Note: Expiring Login Tokens

The login_token and url are time-sensitive (they expire in 90 minutes). We recommend you use server-side redirection rather than provide the url for the user to click. This avoids the scenario where your site serves the url to the user but they wait several hours before clicking on it, and by this time the link has expired. Server-side redirection will ensure the url is always fresh.

Embedding and Auto-Authentication

You can embed pages in Docket Alarm, allowing users without a Docket Alarm account to view the page. To see examples, and use our embedding UI see our embed page. To create a new embedded link with the API, make a POST request to endpoint: embed/create

POST Parameters

Return Values

If the embedded link was submitted properly, you shuold recieve a dictionary with the following:

Example

To embed the following link:
   https://www.docketalarm.com/analytics/Profile/?profile_type=party_profile-Pfizer#[...]&embed
Use the following curl command:

curl -XPOST https://www.docketalarm.com/api/v1/embed/create \
  -d "url=https%3A%2F%2Fwww.docketalarm.com%2Fanalytics%2FProfile%2F%3Fprofile_type%3Dparty_profile-Pfizer%23date_filed_start%3D1320206400%26date_filed_end%3D1635825600%26f%3Dq_entity-party%253A(name%253A(Pfizer))%26fname_q_entity%3DParty%2520Pfizer%26q%3D%26v%3Dparty_profile%26viewargs%3Dparty-Pfizer%26viewargs%3Dmax_entities-20%26embed&login_token=your_token&title=Pfizer+Embedded+Pag"

.

BETA Judgment Extraction

The BETA VIDA/judgment_extractor/ endpoint takes a docket alarm case and returns the judgment information for that case.

GET Parameters

Return Values

result

Example

Here is an example for a docket on Connecticut Supreme Court

        GET https://www.docketalarm.com/api/v1/VIDA/judgment_extractor/?login_token=...&court=Connecticut%20State,%20Superior%20Court&docket=AAN-CV21-6043315-S&client_matter=testing&openai_key=...
    

If successful the result will be:

        200
        {
            "price": 0.002802, 
            "result": {
                "judgment_amount": 12319.24, 
                "judgment_winner": "Plaintiff", 
                "winner_type": "plaintiff", 
                "judgment_type": "default"
            }, 
            "success": true
        }
        
    

BETA Ask a Docket

Our database of hundreds of millions of dockets contains a wealth of information. We could not, however, possibly extract and normalize every single feature that our clients may want from dockets. Our AI powered “Ask a Docket” endpoint is a fast, cheap and easy way to extract structured values from our docket database.
The BETA VIDA/ask_docket/ endpoint takes a docket alarm case, a question, and the desired output format and returns an answer to that question and the AI costs incurred.

GET Parameters

Return Values

from_dockets

from_documents

Example

Here is an example for a docket on Connecticut Supreme Court, where we ask if the case is pre or post discovery stages.

        GET https://www.docketalarm.com/api/v1/VIDA/ask_docket/?login_token=...&court=Connecticut%20State,%20Superior%20Court&docket=AAN-CV21-6043315-S&client_matter=testing&target=both&openai_key=...&question=is%20this%20case%20pre%20or%20post%20discovery%20stages?&output_format=pre/post/case%20closed&show_relevant=True
    

If successful the result will be (abbreviated):

        200
        {
            "success": true, 
            "question": "is this case pre or post discovery stages?", 
            "price": 0.046110000000000005, 
            "from_dockets": {
                "openai_answer": "case closed", 
                "relevant_docket_data": {
                    "date_disposition": "08/08/2022", 
                    "case_entries": [
                    {
                        "date": "12/08/2022", 
                        "contents": "EXECUTION RETURNED UNSATISFIED"
                    }, 
                    ...
                    ]
                }
            }, 
            "from_documents": {
                "openai_answer": "\"case closed\"", 
                "relevant_document_data": {
                    "selected_document": {
                        "date": "07/27/2022", 
                        "id": "106.00", 
                        "title": "MOTION FOR JUDGMENT ON DEFAULT"
                    }, 
                    "relevant_entries": [
                    {
                        "documents": [
                        {
                            "date": "12/08/2022", 
                            "id": "111.00", 
                            "title": "EXECUTION RETURNED UNSATISFIED"
                        }
                        ], 
                        "contents": "EXECUTION RETURNED UNSATISFIED"
                    }, 
                    ...
                    ]
                }
            }, 
            "date_cached": "03/20/2024"
        }
        
    

BETA Case Matcher

Sometimes we might not know the exact docket number and court for a case, but we do know other relevant information like the state, part of the case title and/or parties involved.
The BETA VIDA/case_matcher/ endpoint takes any input the user can provide and returns a case matching the inputs provided with the AI costs incurred.

GET Parameters

Return Values

result

Example

Here is an example for params state=Connecticut, filing_date=March 7, 2024. and parties=ANASTASIA AMELIO

        GET https://www.docketalarm.com/api/v1/VIDA/case_matcher/?login_token=...&openai_key=...&openai_model=gpt-4-1106-preview&filing_date=March%207,%202024&parties=ANASTASIA%20AMELIO
    

If successful the result will be:

        200
        {
            "price": 0.01685, 
            "result": {
                "Case Number": "230203", 
                "Link": "https://www.docketalarm.com/cases/Connecticut_State_Supreme_Court/230203/DEUTSCHE_BANK_NATIONAL_TRUST_COMPANY_AS_TRUSTEE_v._ANASTASIA_AMELIO_ET_AL/", 
                "Court": "Connecticut State, Supreme Court"
            }, 
            "success": true
        }
        
    

BETA Smart Search

In our effort to facilitate user interaction with DocketAlarm query system, we're now adding a new possibility.
The BETA VIDA/smart_search/ endpoint takes any set of instructions the user can provide and returns a DocketAlarm query to target said instructions with the AI costs incurred.

GET Parameters

Return Values

Example

Here is an example using the following instructions: Find all documents involving Ford Motor company but not Ford Motor Credit, that may contain judgment amounts and fees, and span from June 2014 to December 2019

        GET https://www.docketalarm.com/api/v1/VIDA/smart_search/?login_token=...&openai_key=...&openai_model=gpt-4-1106-preview&instructions=Find%20all%20documents%20involving%20Ford%20Motor%20company%20but%20not%20Ford%20Motor%20Credit,%20that%20may%20contain%20%20judgment%20amounts%20and%20fees,%20and%20span%20from%20June%202014%20to%20December%202019
    

If successful the result will be:

        200
        {
            "query": "party:(Ford AND \"Motor Company\" NOT \"Motor Credit\") documenttitle:(judgment OR judgement OR \"damages awarded\" OR fee OR fees OR \"amount due\" OR \"awarded amount\") from:6/1/2014 to:12/31/2019 is:document", 
            "price": 0.028730000000000002, 
            "success": true
        }
    

BETA Attorney Billing Rates

The BETA VIDA/attorney_billing_rates/ endpoint takes an attorney name and state, and returns a json with documents information and billing rates extracted from said documents.

GET Parameters

Return Values

result

attorney_information

Example

Here is an example for attorney Ashley Marshall from connecticut.

        GET https://www.docketalarm.com/api/v1/VIDA/attorney_billing_rates/?login_token=...&openai_key=...&state=connecticut&attorney_name=ashley%20marshall
    

If successful the result will be:

        200
        {
            "price": 0.000786, 
            "result": [
                {
                    "court": "Connecticut State, Superior Court", 
                    "link_viewer": "https://www.docketalarm.com/cases/Connecticut_State_Superior_Court/HHD-CV15-6064139-S/EAST_HARTFORD_BOARD_OF_EDUCATION_v._ROBINSON_KRISTINA/105.00/", 
                    "doc_filename": "EAST HARTFORD BOARD OF EDUCATION v. ROBINSON, KRISTINA, HHD-CV15-6064139-S, 105.00 (Conn. Super. Ct. Jun. 30, 2016).pdf", 
                    "doc_file_date": "06/30/2016", 
                    "case_name": "EAST HARTFORD BOARD OF EDUCATION v. ROBINSON, KRISTINA", 
                    "doc_name": "105.00", 
                    "case_type": "M90 - Misc - All other", 
                    "attorney_information": {
                        "law_school": "University of Connecticut School of Law", 
                        "law_firm": "Shipman & Goodwin", 
                        "billing_rate_per_hour": "225", 
                        "job_title": "in the employment and school law practice groups"
                    }, 
                    "docket_number": "HHD-CV15-6064139-S"
                }, 
                {
                    "court": "Connecticut State, Superior Court", 
                    "link_viewer": "https://www.docketalarm.com/cases/Connecticut_State_Superior_Court/HHD-CV15-6064139-S/EAST_HARTFORD_BOARD_OF_EDUCATION_v._ROBINSON_KRISTINA/102.00/", 
                    "doc_filename": "EAST HARTFORD BOARD OF EDUCATION v. ROBINSON, KRISTINA, HHD-CV15-6064139-S, 102.00 (Conn. Super. Ct. Feb. 18, 2016).pdf", 
                    "doc_file_date": "02/18/2016", 
                    "case_name": "EAST HARTFORD BOARD OF EDUCATION v. ROBINSON, KRISTINA", 
                    "doc_name": "102.00", 
                    "case_type": "M90 - Misc - All other", 
                    "attorney_information": {
                        "law_school": "University of Connecticut School of Law", 
                        "law_firm": "Shipman & Goodwin", 
                        "billing_rate_per_hour": "225", 
                        "job_title": "in the employment and school law practice groups"
                    }, 
                    "docket_number": "HHD-CV15-6064139-S"
                }
            ], 
            "success": true
        }
        
    

BETA Get Complaint Summary

The BETA VIDA/get_complaint_summary/ endpoint takes a docket number and court, and returns a summary of the legal complaint present in the case.

GET Parameters

Return Values

Example

Here is an example of a short complaint summary for docket=2:23-cv-10910 court=California Central District Court

        GET https://www.docketalarm.com/api/v1/VIDA/get_complaint_summary/?login_token=...&openai_key=...&openai_model=gpt-4-1106-preview&cached=True&short&docket=2:23-cv-10910&court=California%20Central%20District%20Court
    

If successful the result will be (abbreviated):

        200
        {
            "openai_answer": "- Cloud Systems HoldCo IP LLC (Plaintiff) is suing Ring LLC (Defendant) for patent infringement, (...) or, alternatively, an award for future infringement.", 
            "price": 0.07636000000000001, 
            "success": true
        }
    

BETA Get Cause of Action

The BETA VIDA/get_cause_of_action/ endpoint takes a docket number and court, and returns a summary of the legal complaint present in the case.

GET Parameters

Return Values

Example

Here is an example for docket=2:23-cv-10910 court=California Central District Court

        GET https://www.docketalarm.com/api/v1/VIDA/get_cause_of_action/?login_token=...&openai_key=...&openai_model=gpt-4-1106-preview&cached=True&docket=2:23-cv-10910&court=California%20Central%20District%20Court
    

If successful the result will be (abbreviated):

        200
        {
            "openai_answer": "- Infringement of the '051 Patent under 35 U.S.C. § 271 for Defendants' alleged actions in (...) will be willful as a matter of law.", 
            "price": 0.08069000000000001, 
            "success": true
        }
    

BETA Entity Normalizer

The BETA VIDA/entity_normalizer/ endpoint takes an entity, and returns a DocketAlarm query to match the best results for said entity without too many false positives.

GET Parameters

Return Values

Example

Here is an example using Apple as entity

        GET https://www.docketalarm.com/api/v1/VIDA/entity_normalizer/?login_token=...&openai_key=...&openai_model=gpt-4-1106-preview&entity=Apple&include_corporate_group&search_limit=50
    

If successful the result will be:

        200
        {
            "query": "party:(Apple NOT \"GEICO INSURANCE COMPANY\" NOT \"APPLE AUTO WHOLESALERS OF WATERBURY, LLC\" NOT \"APPLE REIT SIX, INC.\" NOT \"APPLE OIL\" NOT \"GREEN APPLE\" NOT \"APPLE GROVE CONDOMINIUM ASSOCIATION, INC.\" NOT \"APPLE JANE ABES CELADES\" NOT \"APPLE SPA & TAN LLC A/K/A ANGEL TIPS NAIL CORP.\" NOT \"THE APPLE VALLEY BANK & TRUST CO.\") is:docket", 
            "price": 0.08432, 
            "success": true
        }
    
    

BETA Area Of Law

The BETA VIDA/area_of_law/ endpoint takes a case_type/NOS code, and returns a tag indicating the area of law to which the docket corresponds to.

GET Parameters

Return Values

Example

Here is an example using case_type: Design - D23/262000

        GET https://www.docketalarm.com/api/v1/VIDA/area_of_law/?login_token=...&openai_key=...&case_type=Design%20-%20D23/262000
    

If successful the result will be:

        200
        {
            "price": 0.00046199999999999995, 
            "tag": "Patent Law",
            "iri": "http://lmss.sali.org/R2e3mdhrPrjPbiYOMYQU0g"
            "success": true
        }
    
    

BETA Forum and Venues

The BETA VIDA/forum_and_venues/ endpoint takes a court, and returns a tag indicating the forum or venue to which it corresponds to.

GET Parameters

Return Values

Example

Here is an example using court: U.S. Patent Application

        GET https://www.docketalarm.com/api/v1/VIDA/forum_and_venues/?login_token=...&openai_key=...&court=U.S.%20Patent%20Application
    

If successful the result will be:

        200
        {
            "price": 0.00408, 
            "tag": "Administrative Proceeding Forum",
            "iri": "http://lmss.sali.org/R85BLSakJPEy7c7KvxZyOe",
            "success": true
        }

    

Appendices

Appendix A: Court Regions

Below following is a list of valid values to use for regions, which can also be accessed at the endpoint: /api/v1/searchpacer/?login_token=&client_matter=.

• Alabama
• Alabama Middle
• Alabama Northern
• Alabama Southern
• Alaska
• All Regions
• Arizona
• Arkansas
• Arkansas Eastern
• Arkansas Western
• California
• California Central
• California Eastern
• California Northern
• California Southern
• Colorado
• Connecticut
• Delaware
• District of Columbia
• Eighth Circuit
• Eleventh Circuit
• Federal Circuit
• Fifth Circuit
• First Circuit
• Florida
• Florida Middle
• Florida Northern
• Florida Southern
• Fourth Circuit
• Georgia
• Georgia Middle
• Georgia Northern
• Georgia Southern
• Guam
• Hawaii
• Idaho
• Illinois
• Illinois Central
• Illinois Northern
• Illinois Southern
• Indiana
• Indiana Northern
• Indiana Southern
• Iowa
• Iowa Northern
• Iowa Southern
• Kansas
• Kentucky
• Kentucky Eastern
• Kentucky Western
• Louisiana
• Louisiana Eastern
• Louisiana Middle
• Louisiana Western
• Maine
• Maryland
• Massachusetts
• Michigan
• Michigan Eastern
• Michigan Western
• Minnesota
• Mississippi
• Mississippi Northern
• Mississippi Southern
• Missouri
• Missouri Eastern
• Missouri Western
• Montana
• Nebraska
• Nevada
• New Hampshire
• New Jersey
• New Mexico
• New York
• New York Eastern
• New York Northern
• New York Southern
• New York Western
• Ninth Circuit
• North Carolina
• North Carolina Eastern
• North Carolina Middle
• North Carolina Western
• North Dakota
• Northern Mariana Islands
• Ohio
• Ohio Northern
• Ohio Southern
• Oklahoma
• Oklahoma Eastern
• Oklahoma Northern
• Oklahoma Western
• Oregon
• Pennsylvania
• Pennsylvania Eastern
• Pennsylvania Middle
• Pennsylvania Western
• Puerto Rico
• Rhode Island
• Second Circuit
• Seventh Circuit
• Sixth Circuit
• South Carolina
• South Dakota
• Tennessee
• Tennessee Eastern
• Tennessee Middle
• Tennessee Western
• Tenth Circuit
• Texas
• Texas Eastern
• Texas Northern
• Texas Southern
• Texas Western
• Third Circuit
• United States Court of International Trade
• United States Federal Claims Court
• Utah
• Vermont
• Virgin Islands
• Virginia
• Virginia Eastern
• Virginia Western
• Washington
• Washington Eastern
• Washington Western
• West Virginia
• West Virginia Northern
• West Virginia Southern
• Wisconsin
• Wisconsin Eastern
• Wisconsin Western
• Wyoming

Appendix B: Nature of Suit

The meaning of each nature of suit code is listed below, which can also be accessed at the endpoint: /api/v1/searchpacer/?login_token=&client_matter=.

Appendix C: Party Types

The following are types of parties that may appear in civil and criminal District Court cases.

• Amicus
• Appellant
• Appellee
• Arbitrator
• Claimant
• Co-Debtor
• Conflict Party
• Consol Claimant
• Consol Counter Claimant
• Consol Counter Defendant
• Consol Cross Claimant
• Consol Cross Defendant
• Consol Defendant
• Consol Plaintiff
• Consol Third Party Defendant
• Consol Third Party Plaintiff
• Counter Claimant
• Counter Defendant
• Counter Plaintiff
• Creditor
• Cross Claimant
• Cross Defendant
• Custodian
• Debtor-in-Possess
• Defendant
• Garnishee
• In Re
• Interested Party
• Interested Party
• Interpleader
• Intervenor
• Intervenor Defendant
• Intervenor Plaintiff
• Lead Plaintiff
• Material Witness
• Mediator
• Movant
• Notice Only
• Notice of Appearance
• Objector
• Official Defendant
• Petitioner
• Plaintiff
• Receiver
• Respondent
• Special Master
• Special Request
• Taxpayer
• Third Party Custodian
• ThirdParty Defendant
• ThirdParty Plaintiff
• Trustee

The following are the types of parties that may appear in a Bankruptcy case.

• 3rd Party Plaintiff
• 3rd Pty Defendant
• Accountant
• Appraiser
• Assistant U.S. Trustee
• Attorney
• Auctioneer
• Auditor
• Broker
• Consultant
• Consumer Privacy Ombudsman
• Counter-Claimant
• Counter-Defendant
• Creditor
• Creditor Committee
• Creditor Committee Chair
• Cross Defendant
• Cross-Claimant
• Debtor
• Debtor In Possession
• Defendant
• Examiner
• Executor plaintiff
• Financial Advisor
• Foreign Representative
• Health Care Ombudsman
• Interested Party
• Interim Trustee
• Interpleader
• Intervenor
• Intervenor-Defendant
• Intervenor-Plaintiff
• Joint Debtor
• Judge
• Liquidator
• Mediator
• Non-Filing Spouse
• Other Professional
• Partner
• Petitioning Creditor
• Plaintiff
• Realtor
• Respondent
• Special Counsel
• Stockholder
• Successor Trustee
• Surveyor
• Trustee
• U.S. Trustee
• Witness