# CourtListener Legal Data Scraper (`alwaysprimedev/courtlistener-scraper`) Actor

Scrape U.S. federal & state case law, RECAP dockets, oral arguments, and judges from CourtListener (Free Law Project). Powered by the official REST API — no scraping, no proxies, no captchas.

- **URL**: https://apify.com/alwaysprimedev/courtlistener-scraper.md
- **Developed by:** [Always Prime](https://apify.com/alwaysprimedev) (community)
- **Categories:** Automation, Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ⚖️ CourtListener Legal Data Scraper

> **Search 10 million U.S. court records — federal & state case law, RECAP dockets, oral arguments, and judges — in one click. No PACER fees. No accounts. No captchas.**

![Apify](https://img.shields.io/badge/Apify-Actor-blue?logo=apify) ![Python 3.11](https://img.shields.io/badge/python-3.11-blue?logo=python) ![Output: JSON · CSV · Excel](https://img.shields.io/badge/output-JSON%20%C2%B7%20CSV%20%C2%B7%20Excel-brightgreen) ![License: compliant](https://img.shields.io/badge/license-CourtListener%20API-orange)

---

### 🚀 What you get

- 🏛️ **Case law** — every published opinion from SCOTUS, the U.S. Courts of Appeals, every federal district court, and most state courts of last resort.
- 📁 **RECAP dockets** — federal court filings sourced directly from PACER, free.
- 📝 **Filings** — individual docket entries, attachments, and document metadata.
- 🎙️ **Oral arguments** — argument-audio metadata and download URLs.
- 👨‍⚖️ **Judges** — biographies, ABA ratings, education, political affiliations, positions held.
- ⚡ **Fast** — typically 100 records in under 30 seconds.
- 📊 **Clean output** — flat, normalised, deduplicated, with stable field names. Export to JSON, CSV, or Excel in one click.

This actor wraps the **official [CourtListener REST API](https://www.courtlistener.com/help/api/rest/)** — operated by [Free Law Project](https://free.law/), a 501(c)(3) non-profit. Data is public domain by virtue of being U.S. court records. ✅

---

### 🤖 Quick start

1. Click **Try for free** at the top of this page.
2. Pick a **search type** (opinions, dockets, oral arguments, or judges).
3. Type a **search query** (or leave blank to browse), pick courts and dates.
4. Click **Start** — your dataset will be ready as JSON, CSV, or Excel in under a minute. 📦

---

### ⚙️ Input

| Field | Description |
|---|---|
| `searchType` | `opinions` (case law), `recap` (federal dockets), `recap_documents` (filings), `oral_arguments` (audio), or `people` (judges). |
| `query` | Free-text search. Supports phrases, AND/OR/NOT, and field prefixes like `caseName:"Roe v. Wade"`. |
| `courtIds` | Restrict to specific courts (e.g. `scotus`, `ca9`, `nyed`). Leave blank for all. |
| `dateFiledAfter` / `dateFiledBefore` | Date range (YYYY-MM-DD). |
| `orderBy` | `score desc` (relevance), `dateFiled desc/asc`, `citeCount desc`, etc. |
| `maxItems` | Stop after N records. `0` = no limit. |
| `since` | Incremental mode — skip records older than this date. Combine with a [scheduled run](https://docs.apify.com/platform/schedules) to keep a dataset fresh. |
| `apiToken` | Optional — paste your CourtListener API token for higher throughput. |

> 💡 **Tip:** runs without a token use anonymous access (5 requests/min). For larger jobs, [grab a free token](https://www.courtlistener.com/profile/api-token/) — it takes 30 seconds and gives you your own private rate-limit pool. A [CourtListener Membership](https://donate.free.law/np/clients/freelawproject/membership.jsp) unlocks high-throughput access.

---

### 📤 Sample output

```json
{
  "id": "cluster-10307218",
  "type": "opinion",
  "url": "https://www.courtlistener.com/opinion/10307218/miranda-v-kennedy/",
  "case_name": "Miranda v. Kennedy",
  "court": "Court of Appeals for the First Circuit",
  "court_id": "ca1",
  "court_citation_string": "1st Cir.",
  "date_filed": "2025-01-03",
  "date_argued": "2023-02-06",
  "docket_number": "22-1652",
  "docket_id": 66790134,
  "cluster_id": 10307218,
  "citations": ["125 F.4th 23"],
  "cite_count": 2,
  "status": "Published",
  "snippet": "United States Court of Appeals For the First Circuit ...",
  "scraped_at": "2026-05-10T17:23:00+00:00"
}
````

Other record types (`docket`, `recap_document`, `oral_argument`, `person`) have their own field set — see the **Dataset → Overview** view in the Apify Console for the full schema.

***

### 💼 Who uses this?

| You are... | You use this for... |
|---|---|
| 🏛️ A **lawyer / paralegal** | Building cite-checked memos, finding precedent in your jurisdiction, monitoring opposing counsel. |
| 📊 A **legal analytics team** | Bulk-pulling opinions for ML pipelines (citation graphs, judge-prediction models, NLP corpora). |
| 📰 A **legal journalist / researcher** | Tracking high-profile dockets, finding all opinions citing a landmark case, mapping a judge's record. |
| 💼 A **PropTech / FinTech / RegTech firm** | Monitoring bankruptcy filings, regulatory enforcement, class-action discovery. |
| 🎓 An **academic researcher** | Building the next CAP, AustLII, or empirical-legal-studies dataset without scraping headaches. |

***

### 🎯 Use-case recipes

**📚 All SCOTUS opinions citing *Miranda v. Arizona* (1966):**

```
searchType = opinions
query      = "miranda v arizona"
courtIds   = scotus
orderBy    = dateFiled desc
```

**📂 Every climate-related federal docket filed since 2020:**

```
searchType    = recap
query         = climate change
dateFiledAfter = 2020-01-01
orderBy       = dateFiled desc
```

**🎙️ Recent Ninth Circuit oral arguments:**

```
searchType = oral_arguments
courtIds   = ca9
orderBy    = dateArgued desc
maxItems   = 200
```

**👨‍⚖️ All federal judges with ABA "Well Qualified" rating:**

```
searchType = people
query      = "Well Qualified"
```

***

### 💰 Pricing

**$4 per 1,000 records** (pay only for what you keep — failed and deduplicated records are free). The Apify Free plan includes $5/month in platform credits, enough for ~1,200 records per month before any out-of-pocket spend.

***

### 🛟 FAQ

**Do I need a CourtListener account?** No — the actor works anonymously for small runs. For high-volume jobs, get a free token (30 seconds, no credit card) at [courtlistener.com/profile/api-token/](https://www.courtlistener.com/profile/api-token/).

**Why is my run slow?** The default rate limit (anonymous *and* default-token) is 5 requests/minute. Each request returns up to 100 records. A [CourtListener Membership](https://donate.free.law/np/clients/freelawproject/membership.jsp) supports the project and unlocks higher rate limits.

**Can I use this commercially?** Yes — U.S. court records are public domain. CourtListener asks for attribution where reasonable; please credit [Free Law Project](https://free.law/).

**Does this scrape PACER directly?** No — RECAP data comes from CourtListener's open PACER mirror, populated by the [RECAP browser extension](https://free.law/recap/) and archive donations. No PACER fees, no PACER login.

**How fresh is the data?** Opinions land in CourtListener within hours of publication; RECAP filings are added as users contribute them. Use the `since` input for incremental updates.

**My export is missing some fields.** Different `searchType`s expose different fields (e.g. `cite_count` is opinion-only). Switch to the **Overview** dataset view for type-aware columns, or download JSON for the full schema.

***

### ❤️ Credits

Data: [CourtListener](https://www.courtlistener.com/) · A project of [Free Law Project](https://free.law/), a 501(c)(3) non-profit advancing open access to legal information. **If you use this actor for a paid product, consider [donating](https://donate.free.law/) — it's how the data stays free.** 🙏

# Actor input Schema

## `searchType` (type: `string`):

What kind of records to return. 'opinions' for case law, 'recap' for federal dockets sourced from PACER, 'recap\_documents' for individual filings, 'oral\_arguments' for argument audio, 'people' for federal & state judges.

## `query` (type: `string`):

Free-text search applied across the selected record type. Supports quoted phrases ('miranda warning'), boolean operators (AND/OR/NOT), and field-prefix queries (e.g. caseName:'Roe v. Wade'). Leave empty to return all records matching the other filters.

## `courtIds` (type: `array`):

Restrict results to one or more courts by their CourtListener short ID (e.g. 'scotus' for the U.S. Supreme Court, 'ca9' for the Ninth Circuit, 'nyed' for E.D.N.Y.). Leave empty to search all courts.

## `dateFiledAfter` (type: `string`):

Lower bound on the document's filing date. ISO format (YYYY-MM-DD). Leave empty for no lower bound.

## `dateFiledBefore` (type: `string`):

Upper bound on the document's filing date. ISO format (YYYY-MM-DD). Leave empty for no upper bound.

## `orderBy` (type: `string`):

How to sort results before paginating. Use 'score desc' for relevance to the query, 'dateFiled desc/asc' for chronological listings, or 'citeCount desc' to find frequently-cited opinions.

## `maxItems` (type: `integer`):

Stop after pushing this many records to the dataset. Set 0 to fetch every match (capped only by your API rate limit).

## `pageSize` (type: `integer`):

Number of records requested per HTTP call to the CourtListener search endpoint. Larger pages are more efficient but each one counts as one API call against your rate limit. The API allows up to 100.

## `concurrency` (type: `integer`):

Maximum number of parallel HTTP calls. The CourtListener API throttles per token at 5 requests per minute by default, so increasing this past 1–2 only helps if you have a higher-tier API token.

## `since` (type: `string`):

Optional incremental mode. When set, results whose filing date is older than this are skipped. Combine with a scheduled run to keep a dataset up to date without refetching everything. ISO YYYY-MM-DD.

## `apiToken` (type: `string`):

Your personal CourtListener API token, found at courtlistener.com/profile/api-token/. Anonymous use is allowed and works for small runs, but a token gives you a private rate-limit pool and access to authenticated endpoints. CourtListener Membership unlocks higher throughput.

## `startUrls` (type: `array`):

Advanced override. Provide one or more fully-formed CourtListener API search URLs (https://www.courtlistener.com/api/rest/v4/search/?…) to bypass the filters above and use the URLs as-is. Leave empty for normal use.

## Actor input object example

```json
{
  "searchType": "opinions",
  "query": "climate change",
  "courtIds": [],
  "dateFiledAfter": "2020-01-01",
  "dateFiledBefore": "2024-12-31",
  "orderBy": "score desc",
  "maxItems": 50,
  "pageSize": 20,
  "concurrency": 1,
  "since": "2025-01-01",
  "startUrls": []
}
```

# Actor output Schema

## `results` (type: `string`):

Full result set as a JSON array.

## `resultsCsv` (type: `string`):

Spreadsheet-friendly CSV export.

## `resultsXlsx` (type: `string`):

Excel-compatible workbook export.

## `consoleView` (type: `string`):

Browse and filter results in the Apify dataset viewer.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "courtIds": [],
    "maxItems": 50,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("alwaysprimedev/courtlistener-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "courtIds": [],
    "maxItems": 50,
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("alwaysprimedev/courtlistener-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "courtIds": [],
  "maxItems": 50,
  "startUrls": []
}' |
apify call alwaysprimedev/courtlistener-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=alwaysprimedev/courtlistener-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CourtListener Legal Data Scraper",
        "description": "Scrape U.S. federal & state case law, RECAP dockets, oral arguments, and judges from CourtListener (Free Law Project). Powered by the official REST API — no scraping, no proxies, no captchas.",
        "version": "0.1",
        "x-build-id": "UHGDD7JAghe7WumP2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alwaysprimedev~courtlistener-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alwaysprimedev-courtlistener-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/alwaysprimedev~courtlistener-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alwaysprimedev-courtlistener-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/alwaysprimedev~courtlistener-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alwaysprimedev-courtlistener-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "opinions",
                            "recap",
                            "recap_documents",
                            "oral_arguments",
                            "people"
                        ],
                        "type": "string",
                        "description": "What kind of records to return. 'opinions' for case law, 'recap' for federal dockets sourced from PACER, 'recap_documents' for individual filings, 'oral_arguments' for argument audio, 'people' for federal & state judges.",
                        "default": "opinions"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search applied across the selected record type. Supports quoted phrases ('miranda warning'), boolean operators (AND/OR/NOT), and field-prefix queries (e.g. caseName:'Roe v. Wade'). Leave empty to return all records matching the other filters."
                    },
                    "courtIds": {
                        "title": "Courts (optional)",
                        "type": "array",
                        "description": "Restrict results to one or more courts by their CourtListener short ID (e.g. 'scotus' for the U.S. Supreme Court, 'ca9' for the Ninth Circuit, 'nyed' for E.D.N.Y.). Leave empty to search all courts.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFiledAfter": {
                        "title": "Filed after",
                        "type": "string",
                        "description": "Lower bound on the document's filing date. ISO format (YYYY-MM-DD). Leave empty for no lower bound."
                    },
                    "dateFiledBefore": {
                        "title": "Filed before",
                        "type": "string",
                        "description": "Upper bound on the document's filing date. ISO format (YYYY-MM-DD). Leave empty for no upper bound."
                    },
                    "orderBy": {
                        "title": "Sort order",
                        "enum": [
                            "score desc",
                            "dateFiled desc",
                            "dateFiled asc",
                            "dateArgued desc",
                            "dateArgued asc",
                            "citeCount desc"
                        ],
                        "type": "string",
                        "description": "How to sort results before paginating. Use 'score desc' for relevance to the query, 'dateFiled desc/asc' for chronological listings, or 'citeCount desc' to find frequently-cited opinions.",
                        "default": "score desc"
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Stop after pushing this many records to the dataset. Set 0 to fetch every match (capped only by your API rate limit).",
                        "default": 50
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of records requested per HTTP call to the CourtListener search endpoint. Larger pages are more efficient but each one counts as one API call against your rate limit. The API allows up to 100.",
                        "default": 20
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum number of parallel HTTP calls. The CourtListener API throttles per token at 5 requests per minute by default, so increasing this past 1–2 only helps if you have a higher-tier API token.",
                        "default": 1
                    },
                    "since": {
                        "title": "Incremental: only fetch records newer than this date",
                        "type": "string",
                        "description": "Optional incremental mode. When set, results whose filing date is older than this are skipped. Combine with a scheduled run to keep a dataset up to date without refetching everything. ISO YYYY-MM-DD."
                    },
                    "apiToken": {
                        "title": "CourtListener API token (optional)",
                        "type": "string",
                        "description": "Your personal CourtListener API token, found at courtlistener.com/profile/api-token/. Anonymous use is allowed and works for small runs, but a token gives you a private rate-limit pool and access to authenticated endpoints. CourtListener Membership unlocks higher throughput."
                    },
                    "startUrls": {
                        "title": "Custom start URLs (advanced)",
                        "type": "array",
                        "description": "Advanced override. Provide one or more fully-formed CourtListener API search URLs (https://www.courtlistener.com/api/rest/v4/search/?…) to bypass the filters above and use the URLs as-is. Leave empty for normal use.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
