### GET Request for Single Docket Tracking Status (Example)

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

This snippet shows an example of a GET request to retrieve the tracking status for a specific docket. It includes the necessary parameters like docket number, login token, and court name, along with a sample successful JSON response.

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

HTTP/1.1 200 OK
{
  'enabled': true,
  'frequency': 'twice_daily',
  'success': true
}
```

--------------------------------

### GET Request Example for DocketAlarm API v1

Source: https://www.docketalarm.com/api/v1/index

This snippet demonstrates a GET request to the DocketAlarm API v1 to query a specific docket. It includes essential parameters like login token, court, docket identifier, client matter, AI keys, the question being asked, target sources, output format, and relevance flags. The example showcases how to construct a URL for retrieving information from both docket entries and documents.

```http
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
```

--------------------------------

### Get Complaint Summary API Request

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Example GET request to the get_complaint_summary endpoint. It includes authentication, AI model selection, caching options, and docket details. The response provides an AI-generated summary and interaction price.

```HTTP
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
```

--------------------------------

### DocketAlarm Scroll API Setup (Conceptual)

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

This section describes the setup for using the DocketAlarm Scroll API, which is designed for retrieving large datasets efficiently. It explains the concept of `scroll_parallel` for parallel requests and `scroll_index` for identifying individual parallel requests.

```text
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.
```

--------------------------------

### GET Response: Court Search Parameters Structure

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

This is an example JSON response for a GET request to the searchdirect/ endpoint with a specified court. It outlines the 'required' and 'optional' search parameters, and provides 'choices' for certain parameters like 'max_pages' and 'county'.

```JSON
{
  "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"
    ]
  }
}
```

--------------------------------

### GET Request for Docket Tracking Status (Example)

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

This snippet demonstrates a GET request to the DocketAlarm API to check the tracking status of dockets. It shows the expected URL format and a sample JSON response for a successful request, including details about each docket's tracking status.

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

HTTP/1.1 200 OK
{
  "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 Request: Documenting Search Parameters for DocketAlarm API

Source: https://www.docketalarm.com/api/v1/index

This GET request, when the 'court' parameter is included, returns a JSON structure detailing required and optional search parameters, along with their allowed values. It's useful for understanding the API's search capabilities before making a POST request. Dependencies include a valid login token and client matter.

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

--------------------------------

### Example New PACER Case Notification

Source: https://www.docketalarm.com/api/v1/index

A concrete example of a 'new_case' push notification, demonstrating the expected JSON structure and data for a PACER case alert.

```json
{
  "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"
    }
  ]
}
```

--------------------------------

### Search DocketAlarm API using Java

Source: https://www.docketalarm.com/api/v1/index

This Java code snippet shows how to perform a search on the DocketAlarm API v1. It uses `java.net` classes to build the URL with encoded parameters and `HttpURLConnection` to make the GET request. The response is read using a `BufferedReader`. This example requires a valid login token.

```java
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
    }
}
```

--------------------------------

### Retrieve Document using GET Request

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Fetches a binary PDF document from Docket Alarm using a GET request. The URL is derived from the 'link' field of a docket entry. Optional parameters include 'login_token' for authentication, 'client_matter' for billing, and 'cached' to only download if previously cached. Returns the PDF directly or a JSON error object.

```http
GET https://www.docketalarm.com/cases/Arkansas_Eastern_District_Court/4--2010-cr-00188/USA_v_Vargas_et_al/docs/425.pdf?login_token=...
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=...
```

--------------------------------

### Get Cause of Action API Request

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Example GET request to the get_cause_of_action endpoint. This endpoint requires docket and court information, and optionally accepts AI model and caching parameters. The response includes an AI-generated summary of the cause of action.

```HTTP
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
```

--------------------------------

### Generate DocketAlarm Query from Instructions using DocketAlarm API

Source: https://www.docketalarm.com/api/v1/index

The VIDA/smart_search/ endpoint converts natural language instructions into a DocketAlarm query. This feature is useful for users who want to search for specific documents or case information without knowing the exact query syntax. It requires a login token and an 'instructions' parameter. API keys and model selections for AI processing are optional.

```HTTP
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
```

```JSON
{
    "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
}
```

--------------------------------

### API Scrolling with Parallel Threads

Source: https://www.docketalarm.com/api/v1/index

Demonstrates how to initiate and continue scrolling through API search results using parallel threads. The initial requests set up parallel scrolling by specifying scroll_parallel and scroll_index, returning a scroll token. Subsequent requests use this token to fetch more results without needing to respecify parallel parameters.

```HTTP
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
```

```HTTP
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...=
```

--------------------------------

### Example SSO Login Response

Source: https://www.docketalarm.com/api/v1/index

A successful response from the `subaccount/login/` endpoint provides a JSON object containing the `url` for SSO redirection, a `login_token` for API use, and a `success` status.

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

--------------------------------

### Get Complaint Summary API Response

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Example successful JSON response from the get_complaint_summary endpoint. It contains the 'openai_answer' with the summarized complaint and the 'price' of the AI interaction. The 'success' field indicates the request status.

```JSON
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
}
```

--------------------------------

### Get Cause of Action API Response

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Example successful JSON response from the get_cause_of_action endpoint. It includes the 'openai_answer' detailing the cause of action and the 'price' of the AI service. The 'success' field indicates the operation's outcome.

```JSON
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
}
```

--------------------------------

### Create or Modify Docket Tracker (POST)

Source: https://www.docketalarm.com/api/v1/index

Use a POST request to the track/ endpoint to create a new tracker, modify an existing one, or simulate a push notification for testing. This endpoint requires authentication and specifies court, docket, and tracking frequency. Optional parameters include client_matter for billing and test flags for debugging.

```http
POST https://www.docketalarm.com/api/v1/track/

Parameters:
login_token: The authentication token.
court: Court name.
docket: Docket number.
enable: Set to true to enable tracking, false to disable.
q: (Optional) Used for search trackers.
client_matter: (Optional) Client or matter code for billing.
frequency: Tracking frequency (daily, twice_daily, continuous, weekly, monthly, 40x, realtime).
test: (Optional) Test an API push with fake data.
test_track: (Optional) Synchronously test an API push for a specific case or search tracker.
```

```http
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
```

--------------------------------

### POST /track/

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Allows testing push notifications by adding the `test` parameter to a POST call.

```APIDOC
## POST /track/ (Testing Push Notifications)

### Description
This endpoint can be used to test push notifications. By adding the `test` parameter, fake data will be used, and push notifications will be triggered without actual docket updates.

### Method
POST

### Endpoint
`/track/`

### Query Parameters
- **test** (boolean) - Required for testing push notifications - If present, uses the test system for fake data and triggers push notifications.

### Request Example
```
POST /api/v1/track/?test
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **error** (string) - Description of the error if `success` is false.

#### Response Example
```json
{
  "success": true
}
```
```

--------------------------------

### Get Tracking Status using GET Request

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

Retrieves the tracking status for one or more dockets via a GET request to the 'track/' endpoint. Requires a 'login_token' for authentication. Optional parameters 'offset' and 'limit' control pagination of the returned trackers. The response indicates whether each docket is being tracked.

```http
GET https://www.docketalarm.com/track/?login_token=...
GET https://www.docketalarm.com/track/?login_token=...&offset=10&limit=50
```

--------------------------------

### Get Docket API

Source: https://www.docketalarm.com/api/v1/index

Retrieves detailed information for a specific docket. This endpoint uses GET request with query parameters including court and docket number.

```APIDOC
## GET /api/v1/getdocket/

### Description
Retrieves detailed information for a specific docket. This endpoint uses GET request with query parameters including court and docket number.

### Method
GET

### Endpoint
https://www.docketalarm.com/api/v1/getdocket/

### Parameters
#### Query Parameters
- **login_token** (string) - Required - The authentication token obtained from the login endpoint.
- **client_matter** (string) - Optional - A reference identifier for tracking purposes.
- **court** (string) - Required - The name of the court where the docket is filed.
- **docket** (string) - Required - The docket number.
- **cached** (boolean) - Optional - If true, returns Docket Alarm's cached copy. If false or omitted, attempts to retrieve an updated docket from the court (may incur PACER fees for federal cases).

### Request Example
```json
{
  "login_token": "your_generated_login_token",
  "client_matter": "first-api-getdocket-test",
  "court": "District Court, Central District of California",
  "docket": "2:23-cv-01234",
  "cached": true
}
```

### Response
#### Success Response (200)
- **docket_details** (object) - An object containing the detailed docket information.
  - (Fields vary depending on the docket data available)

#### Response Example
```json
{
  "docket_details": {
    "case_name": "John Doe v. DoorDash, Inc.",
    "docket_number": "2:23-cv-01234",
    "court": "District Court, Central District of California",
    "filing_date": "2023-01-15",
    "events": [
      {
        "date": "2023-01-15",
        "description": "Complaint Filed"
      },
      {
        "date": "2023-01-16",
        "description": "Summons Issued"
      }
    ]
  }
}
```
```

--------------------------------

### POST /embed/create

Source: https://www.docketalarm.com/api/v1/index

Create an embeddable link for sharing docket pages with users who do not have a Docket Alarm account.

```APIDOC
## POST /embed/create

### Description
This endpoint allows the creation of embeddable links for Docket Alarm pages. These links can be shared with users who do not have a Docket Alarm account, facilitating broader access to docket information.

### Method
POST

### Endpoint
`/embed/create/`

### Parameters
#### Query Parameters
- **test** (boolean) - Optional - Use to enable test mode.

#### Request Body
(Form data or JSON, depending on Content-Type header)
- **docket_id** (string) - Required - The ID of the docket to create an embed link for.
- **page_type** (string) - Optional - Specifies the type of page to embed (e.g., 'docket_report', 'filings'). Defaults to 'docket_report'.

### Request Example
```
docket_id=1:19-cv-00001&page_type=docket_report
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **error** (string) - Description of the error if `success` is false.
- **embed_url** (string) - The URL that can be used to embed the docket page.

#### Response Example
```json
{
  "success": true,
  "error": null,
  "embed_url": "https://www.docketalarm.com/embed/docket/1:19-cv-00001/"
}
```
```

--------------------------------

### BETA Smart Search API

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

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.

```APIDOC
## GET /api/v1/VIDA/smart_search/

### Description
This endpoint generates a DocketAlarm query based on natural language instructions using AI. It allows users to search for specific documents or cases by providing detailed criteria.

### Method
GET

### Endpoint
`/api/v1/VIDA/smart_search/`

### Parameters
#### Query Parameters
- **login_token** (string) - Required - The authentication token.
- **openai_key** (string) - Required - An API key for OpenAI.
- **anthropic_key** (string) - Required - A key for the Anthropic API.
- **openai_model** (string) - Optional - A model to be used for OpenAI API calls. Defaults to "gpt-4o".
- **claude_model** (string) - Optional - A model to be used for Anthropic API calls. Defaults to "claude-3-5-sonnet-20240620".
- **instructions** (string) - Required - A set of instructions for a query to be generated using natural language.

### Request Example
`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`

### Response
#### Success Response (200)
- **query** (string) - The DocketAlarm query matching the user instructions.
- **price** (float) - The amount of AI costs incurred in making the request.
- **success** (boolean) - Indicates if the request was successful.

#### Response Example
```json
{
    "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
}
```
```

--------------------------------

### Example Judgment Extraction Response

Source: https://www.docketalarm.com/api/v1/index

This is an example of a successful JSON response when extracting judgment information using the VIDA/judgment_extractor/ endpoint. It includes the price of AI costs and the extracted judgment details.

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

--------------------------------

### Docket Entry Analysis Example

Source: https://www.docketalarm.com/api/v1/index_6_Recent-API-Changes

This snippet shows an example of a single docket entry within a docket report, including the 'analyze' field which provides parsed information about the entry's type, confidence, and outcome.

```APIDOC
## GET /api/v1/dockets/{docket_id}/entries

### Description
Retrieves a list of docket entries for a specific docket, with an option to include analysis of each entry.

### Method
GET

### Endpoint
`/api/v1/dockets/{docket_id}/entries`

### Parameters
#### Query Parameters
- **analyze** (boolean) - Optional - If true, includes the 'analyze' field in the response for each docket entry.

### Request Example
```
GET /api/v1/dockets/12345/entries?analyze=true
```

### Response
#### Success Response (200)
- **number** (string) - The docket entry number.
- **date** (string) - The date of the docket entry.
- **entry_date** (string) - The date the entry was recorded.
- **contents** (string) - The content of the docket entry.
- **exhibits** (array) - A list of exhibits associated with the entry.
- **link_viewer** (string) - A link to view the entry on Docket Alarm.
- **link** (string) - A direct link to the PDF of the entry.
- **analyze** (object) - An object containing parsed information about the entry (if `analyze` query parameter is true).
  - **parser_types** (array) - A list of parsed types for the entry.
    - **type** (string) - The type of parser (e.g., 'order', 'motion').
    - **identifier** (string) - A specific identifier for the parsed type (e.g., 'summaryjudgment').
    - **confidence** (string) - The confidence level of the parsing (e.g., 'very_high').
    - **outcome** (array) - The outcome of the parsed event (e.g., ['granted', 'denied']).
    - **related** (array) - Information about related entries or documents.
    - **snippet** (string) - A snippet of the text related to the analysis.

#### Response Example
```json
{
  "number": "335",
  "date": "6/18/2021",
  "entry_date": "6/18/2021",
  "contents": "<span>ORDER granting in part and denying in part 240 Defendant's Motion for Summary Judgment</span>",
  "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"
          }
        ],
        "snippet": "ORDER granting in part and denying in part 240 Defendant's Motion for Summary Judgment"
      }
    ]
  }
}
```
```

--------------------------------

### BETA Case Matching and Smart Search Endpoints

Source: https://www.docketalarm.com/api/v1/index

Endpoints for finding cases using partial information and querying DocketAlarm with natural language instructions.

```APIDOC
## BETA Case Matching and Smart Search Endpoints

### Description
These BETA endpoints, powered by OpenAI, facilitate finding cases within DocketAlarm. `case_matcher/` helps locate cases using partial information, while `smart_search/` allows users to query DocketAlarm by providing instructions in natural language, which are then translated into a query.

### Method
POST

### Endpoint
- `/case_matcher/`
- `/smart_search/`

### Parameters
#### Request Body
- **query_params** (object) - Required for `case_matcher/` - An object containing partial case information (e.g., party names, case numbers).
- **instructions** (string) - Required for `smart_search/` - Natural language instructions for the search query.

### Request Example (smart_search)
```json
{
  "instructions": "Find all cases related to intellectual property filed in the last 5 years."
}
```

### Response
#### Success Response (200)
- **cases** (array) - For `case_matcher/`, a list of matching cases.
- **search_results** (array) - For `smart_search/`, the results of the generated query.

#### Response Example (case_matcher)
```json
{
  "cases": [
    {
      "case_id": "example_case_id_1",
      "case_name": "Plaintiff v. Defendant"
    },
    {
      "case_id": "example_case_id_2",
      "case_name": "Another Plaintiff v. Another Defendant"
    }
  ]
}
```
```

--------------------------------

### POST /track/

Source: https://www.docketalarm.com/api/v1/index

Add or manage docket tracking. Supports `test_track` for push notification testing.

```APIDOC
## POST /track/

### Description
This endpoint allows users to track specific dockets. When new items are posted to a tracked docket, push notifications can be triggered. A `test_track` feature is available for testing push notifications.

### Method
POST

### Endpoint
`/track/`

### Parameters
#### Query Parameters
- **test** (boolean) - Optional - Use to enable test mode.
- **test_track** (boolean) - Optional - Use to test push notifications with fake data.

#### Request Body
(Form data or JSON, depending on Content-Type header)
- **docket_id** (string) - Required - The ID of the docket to track.
- **client_matter** (string) - Optional - The client matter number to associate with the tracked docket.

### Request Example
`POST /track/?test_track=true` with body `docket_id=1:19-cv-00001&client_matter=CLIENT123`

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **error** (string) - Description of the error if `success` is false.
- **datetime_updated** (string) - The date and time the tracking was last updated.

#### Response Example
```json
{
  "success": true,
  "error": null,
  "datetime_updated": "02/15/2023 11:30:00"
}
```
```

--------------------------------

### GET /track/

Source: https://www.docketalarm.com/api/v1/index

Retrieves the tracking status for one or more dockets.

```APIDOC
## Tracking Cases - Get Status

### Description
A GET request to the `track/` endpoint returns the tracking status of one or more dockets.

### Method
GET

### Endpoint
`/track/`

### Parameters
#### Query Parameters
- **login_token** (string) - Required - The authentication token.
- **offset** (integer) - Optional - The offset into the user's trackers (default 0).
- **limit** (integer) - Optional - The maximum number of trackers to return (default 25, max 50).

### Request Example
`GET https://www.docketalarm.com/track/?login_token=...&limit=10`

### Response
#### Success Response (200)
- **(structure not detailed in source)** - Returns the tracking status of dockets.
```

--------------------------------

### Python: Log in and Search Docket Alarm API

Source: https://www.docketalarm.com/api/v1/index

This Python snippet demonstrates how to authenticate with the Docket Alarm API using email and password, and then perform a search for specific cases. It utilizes the `urllib` and `json` libraries for making requests and parsing responses. The search query targets cases where 'DoorDash' or 'Uber' are defendants and retrieves the three most recent dockets.

```python
# 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!")

```

--------------------------------

### GET Request: Retrieving a Specific Case Docket from DocketAlarm API

Source: https://www.docketalarm.com/api/v1/index

This GET request is used to download the docket information for a specific case using the 'getdocket/' endpoint. It requires the case identifier as a parameter. The response will contain the detailed docket information for the requested case.

```HTTP
GET getdocket/ endpoint with case identifier
```

--------------------------------

### Get Supported Courts for SearchDirect Endpoint

Source: https://www.docketalarm.com/api/v1/index

This GET request retrieves a list of courts that support the searchdirect/ endpoint. It requires a login token and client matter ID. The response is a dictionary containing a 'courts' parameter, which is a list of strings representing the names of the supported courts.

```HTTP
GET https://www.docketalarm.com/api/v1/searchdirect/
```