# Case Law Scraper (`crawlerbros/case-law-scraper`) Actor

Search and retrieve US court opinions and case law from CourtListener - the largest open legal database with 4M+ court opinions. Search by keyword, filter by court, date range, and jurisdiction.

- **URL**: https://apify.com/crawlerbros/case-law-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Case Law Scraper

Search and retrieve US court opinions from **CourtListener** — the largest open-access legal database with over 4 million court opinions from federal and state courts dating back to the founding era.

No API key required for basic use. A free CourtListener API token provides higher rate limits.

### What This Actor Does

- Search cases by **keyword** (boolean search supported: AND, OR, NOT)
- Filter by **court** (Supreme Court, Circuit Courts, District Courts, State Courts)
- Filter by **jurisdiction type** (Federal, State, Committee, Territory)
- Filter by **decision date range**
- Filter by **publication status** (Published, Unpublished, etc.)
- Fetch cases by **jurisdiction slug** (e.g., all California cases)
- Lookup specific cases by **cluster ID**
- Returns: case name, citations, court, judge, date, opinion snippets, download URLs, and more

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | select | `searchCases` (default), `getCasesByJurisdiction`, or `getCaseDetail` |
| `apiToken` | string | Optional CourtListener API token for higher rate limits |
| `searchQuery` | string | Keywords to search (supports AND/OR/NOT) |
| `court` | select | Filter by court ID (e.g., `scotus`, `ca9`, `ca2`) |
| `jurisdiction` | select | Filter by jurisdiction type: F=Federal, S=State |
| `decisionDateMin` | string | Filter cases decided on or after this date (YYYY-MM-DD) |
| `decisionDateMax` | string | Filter cases decided on or before this date (YYYY-MM-DD) |
| `status` | select | Publication status filter |
| `caseIds` | array | Cluster IDs for `getCaseDetail` mode |
| `jurisdictionSlug` | string | Jurisdiction slug for `getCasesByJurisdiction` (e.g., `cal`, `ny`) |
| `maxItems` | integer | Max records to return (1–1000, default 50) |

#### Example Inputs

**Search freedom of speech cases:**
```json
{
  "mode": "searchCases",
  "searchQuery": "freedom of speech",
  "maxItems": 50
}
````

**Search SCOTUS cases since 2010:**

```json
{
  "mode": "searchCases",
  "searchQuery": "first amendment",
  "court": "scotus",
  "decisionDateMin": "2010-01-01",
  "maxItems": 25
}
```

**Get all California Supreme Court cases:**

```json
{
  "mode": "getCasesByJurisdiction",
  "jurisdictionSlug": "cal",
  "maxItems": 100
}
```

**Fetch specific cases by cluster ID:**

```json
{
  "mode": "getCaseDetail",
  "caseIds": ["4637556", "9501490"],
  "maxItems": 10
}
```

### Output

Each record contains:

| Field | Description |
|-------|-------------|
| `clusterId` | CourtListener cluster ID |
| `caseName` | Short case name (e.g., "Roe v. Wade") |
| `caseNameFull` | Full formal case name |
| `caseUrl` | Link to case on CourtListener |
| `sourceUrl` | Same as caseUrl |
| `decisionDate` | Date decision was filed (YYYY-MM-DD) |
| `dateArgued` | Date case was argued (if available) |
| `docketNumber` | Court docket number |
| `docketId` | CourtListener docket ID |
| `citations` | Array of citation objects with `cite` field |
| `neutralCite` | Neutral citation (if available) |
| `court` | Court ID (e.g., `ca2`, `scotus`) |
| `courtName` | Full court name |
| `courtCitationString` | Citation abbreviation (e.g., `2d Cir.`) |
| `jurisdictionType` | F=Federal, S=State, C=Committee, T=Territory |
| `jurisdictionTypeName` | Human-readable jurisdiction type |
| `status` | Publication status (Published/Unpublished/etc.) |
| `judge` | Authoring/panel judges |
| `attorney` | Attorney names |
| `citeCount` | Number of times this case has been cited |
| `opinionSnippet` | Text excerpt from the opinion |
| `opinionDownloadUrls` | URLs to download full opinion PDFs |
| `opinionIds` | Related opinion IDs |
| `syllabus` | Case syllabus (if available) |
| `source` | Data source code |
| `scdbId` | Supreme Court Database ID (SCOTUS cases) |
| `recordType` | Always `"case"` |
| `scrapedAt` | ISO 8601 timestamp |

#### Sample Output Record

```json
{
  "clusterId": 4637556,
  "caseName": "Knight First Amendment Inst. at Columbia Univ. v. Trump",
  "caseNameFull": "KNIGHT FIRST AMENDMENT INSTITUTE AT COLUMBIA UNIVERSITY v. DONALD J. TRUMP",
  "caseUrl": "https://www.courtlistener.com/opinion/4637556/knight-first-amendment/",
  "sourceUrl": "https://www.courtlistener.com/opinion/4637556/knight-first-amendment/",
  "decisionDate": "2019-07-09",
  "docketNumber": "18-1691-cv",
  "citations": [{"cite": "928 F.3d 226"}],
  "court": "ca2",
  "courtName": "Court of Appeals for the Second Circuit",
  "courtCitationString": "2d Cir.",
  "jurisdictionType": "F",
  "jurisdictionTypeName": "Federal",
  "status": "Published",
  "judge": "Parker, Hall, Droney",
  "citeCount": 88,
  "opinionSnippet": "President Donald J. Trump appeals from a judgment concluding...",
  "opinionDownloadUrls": ["http://www.ca2.uscourts.gov/decisions/..."],
  "recordType": "case",
  "scrapedAt": "2026-05-30T10:00:00+00:00"
}
```

### Data Source

Data is sourced from **CourtListener** (courtlistener.com), operated by the Free Law Project. It is the largest free and open-source legal research platform, containing opinions from:

- US Supreme Court (SCOTUS) — opinions back to 1754
- All 13 US Circuit Courts of Appeals
- US District Courts
- State Supreme Courts and Appellate Courts
- Specialized federal courts (Tax Court, Bankruptcy, etc.)

### Court IDs Reference

| ID | Court |
|----|-------|
| `scotus` | US Supreme Court |
| `ca1`–`ca11` | Circuit Courts of Appeals (1st–11th) |
| `cadc` | D.C. Circuit Court of Appeals |
| `cafc` | Federal Circuit Court of Appeals |
| `dcd` | US District Court, D.C. |
| `ca2` | 2nd Circuit (NY, CT, VT) |
| `ca9` | 9th Circuit (CA, OR, WA, AK, HI, AZ, NV, ID, MT) |

### API Token

Register for a free CourtListener account at https://www.courtlistener.com/register/ to get an API token. The token provides:

- Higher rate limits (100+ requests/hour vs 100/day unauthenticated)
- Faster access to large result sets

### FAQs

**Q: Does this require an API key?**
No, the actor works without authentication. Providing a free API token increases rate limits.

**Q: How do I get full case text?**
Full opinion text requires an API token and the case must be in CourtListener's database with full text indexed. The `opinionSnippet` field provides a preview. Use `opinionDownloadUrls` to access the full PDF.

**Q: What date format should I use?**
Use YYYY-MM-DD format (e.g., 2000-01-15).

**Q: What is a cluster ID?**
CourtListener groups related opinions (e.g., majority, dissent) into a "cluster." The `clusterId` is the unique identifier for a case cluster.

**Q: Can I search using boolean operators?**
Yes. Use AND, OR, NOT in your search query. Example: `"free speech" AND "first amendment" NOT obscenity`

**Q: What states are available?**
All US federal and state jurisdictions with published opinions on CourtListener.

# Actor input Schema

## `mode` (type: `string`):

Operation mode. 'searchCases' searches by keyword. 'getCasesByJurisdiction' gets cases from a specific jurisdiction. 'getCaseDetail' fetches specific cases by cluster ID (requires apiToken).

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

Optional API token from courtlistener.com for higher rate limits. Required for getCaseDetail mode. Free to register at https://www.courtlistener.com/register/

## `searchQuery` (type: `string`):

Keyword(s) to search for in case opinions. Supports boolean operators: AND, OR, NOT. Example: 'freedom of speech', 'first amendment school'

## `court` (type: `string`):

Filter by specific court ID (e.g. 'scotus' for Supreme Court, 'ca9' for 9th Circuit, 'ca2' for 2nd Circuit). Leave blank for all courts.

## `jurisdiction` (type: `string`):

Filter by jurisdiction type: F=Federal, S=State, C=Committee, T=Territory. Leave blank for all.

## `decisionDateMin` (type: `string`):

Filter cases decided on or after this date (YYYY-MM-DD format). Example: 2000-01-01

## `decisionDateMax` (type: `string`):

Filter cases decided on or before this date (YYYY-MM-DD format). Example: 2024-12-31

## `status` (type: `string`):

Filter by publication status of the opinion.

## `caseIds` (type: `array`):

List of CourtListener cluster IDs to fetch details for (for getCaseDetail mode).

## `jurisdictionSlug` (type: `string`):

The jurisdiction slug for getCasesByJurisdiction mode (e.g. 'cal' for California, 'ny' for New York, 'tex' for Texas, 'us' for federal).

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

Maximum number of cases to return (1â€“1000).

## Actor input object example

```json
{
  "mode": "searchCases",
  "searchQuery": "freedom of speech",
  "court": "",
  "jurisdiction": "",
  "status": "",
  "maxItems": 50
}
```

# Actor output Schema

## `cases` (type: `string`):

Dataset containing all scraped court opinion records.

# 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 = {
    "mode": "searchCases",
    "searchQuery": "freedom of speech",
    "court": "",
    "jurisdiction": "",
    "status": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/case-law-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 = {
    "mode": "searchCases",
    "searchQuery": "freedom of speech",
    "court": "",
    "jurisdiction": "",
    "status": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/case-law-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 '{
  "mode": "searchCases",
  "searchQuery": "freedom of speech",
  "court": "",
  "jurisdiction": "",
  "status": "",
  "maxItems": 50
}' |
apify call crawlerbros/case-law-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Case Law Scraper",
        "description": "Search and retrieve US court opinions and case law from CourtListener - the largest open legal database with 4M+ court opinions. Search by keyword, filter by court, date range, and jurisdiction.",
        "version": "1.0",
        "x-build-id": "fqDG1brk0rUobiVmn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~case-law-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-case-law-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/crawlerbros~case-law-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-case-law-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/crawlerbros~case-law-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-case-law-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchCases",
                            "getCasesByJurisdiction",
                            "getCaseDetail"
                        ],
                        "type": "string",
                        "description": "Operation mode. 'searchCases' searches by keyword. 'getCasesByJurisdiction' gets cases from a specific jurisdiction. 'getCaseDetail' fetches specific cases by cluster ID (requires apiToken).",
                        "default": "searchCases"
                    },
                    "apiToken": {
                        "title": "CourtListener API Token",
                        "type": "string",
                        "description": "Optional API token from courtlistener.com for higher rate limits. Required for getCaseDetail mode. Free to register at https://www.courtlistener.com/register/"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword(s) to search for in case opinions. Supports boolean operators: AND, OR, NOT. Example: 'freedom of speech', 'first amendment school'"
                    },
                    "court": {
                        "title": "Court",
                        "enum": [
                            "",
                            "scotus",
                            "ca1",
                            "ca2",
                            "ca3",
                            "ca4",
                            "ca5",
                            "ca6",
                            "ca7",
                            "ca8",
                            "ca9",
                            "ca10",
                            "ca11",
                            "cadc",
                            "cafc",
                            "dcd",
                            "ohioctapp",
                            "nysupct",
                            "calctapp",
                            "texapp",
                            "armfor"
                        ],
                        "type": "string",
                        "description": "Filter by specific court ID (e.g. 'scotus' for Supreme Court, 'ca9' for 9th Circuit, 'ca2' for 2nd Circuit). Leave blank for all courts.",
                        "default": ""
                    },
                    "jurisdiction": {
                        "title": "Jurisdiction",
                        "enum": [
                            "",
                            "F",
                            "S",
                            "C",
                            "T"
                        ],
                        "type": "string",
                        "description": "Filter by jurisdiction type: F=Federal, S=State, C=Committee, T=Territory. Leave blank for all.",
                        "default": ""
                    },
                    "decisionDateMin": {
                        "title": "Decision Date (from)",
                        "type": "string",
                        "description": "Filter cases decided on or after this date (YYYY-MM-DD format). Example: 2000-01-01"
                    },
                    "decisionDateMax": {
                        "title": "Decision Date (to)",
                        "type": "string",
                        "description": "Filter cases decided on or before this date (YYYY-MM-DD format). Example: 2024-12-31"
                    },
                    "status": {
                        "title": "Publication Status",
                        "enum": [
                            "",
                            "Published",
                            "Unpublished",
                            "Errata",
                            "Separate",
                            "In-chambers",
                            "Relating-to",
                            "Unknown"
                        ],
                        "type": "string",
                        "description": "Filter by publication status of the opinion.",
                        "default": ""
                    },
                    "caseIds": {
                        "title": "Case Cluster IDs (for getCaseDetail mode)",
                        "type": "array",
                        "description": "List of CourtListener cluster IDs to fetch details for (for getCaseDetail mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jurisdictionSlug": {
                        "title": "Jurisdiction Slug (for getCasesByJurisdiction mode)",
                        "type": "string",
                        "description": "The jurisdiction slug for getCasesByJurisdiction mode (e.g. 'cal' for California, 'ny' for New York, 'tex' for Texas, 'us' for federal)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of cases to return (1â€“1000).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
