# California State Bar Attorney Scraper (`automation-lab/california-state-bar-attorney-scraper`) Actor

Verify California attorneys with official public State Bar license status, contact details, practice areas, law school, and history.

- **URL**: https://apify.com/automation-lab/california-state-bar-attorney-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## California State Bar Attorney Scraper

Scrape official public California State Bar attorney license search and profile pages.

### What does California State Bar Attorney Scraper do?

California State Bar Attorney Scraper collects public attorney license records from the official State Bar of California search and profile pages. It turns name searches, bar numbers, and profile URLs into a clean Apify dataset that is ready for compliance review, CRM enrichment, legal recruiting, and periodic license monitoring.

The actor can save basic search-result data or open each attorney profile for deeper public details such as contact information, law school, self-reported practice areas, language information, CLA sections, license status history, and discipline indicators.

### Who is it for?

- ⚖️ **Legal-tech teams** building attorney verification, intake, or due-diligence workflows.
- 🧾 **Compliance teams** checking whether California attorneys are active, inactive, suspended, or otherwise flagged in public records.
- 📈 **Legal marketing and business development teams** enriching attorney and firm lead lists with official license data.
- 👥 **Recruiters and staffing teams** verifying bar admission and public profile details before outreach.
- 🏢 **Law firms and operations teams** refreshing internal attorney rosters from an official source.
- 🔎 **Investigators and researchers** collecting public California attorney records for structured analysis.

### Why use official State Bar data?

Generic lawyer directories may be useful for marketing context, but they are not the source of truth for license verification. This actor reads the public State Bar of California pages, so the records are tied to official bar numbers and official license-status pages.

Use it when you need a reproducible dataset that points back to the public profile URL for every saved attorney.

### What data can you extract?

Each saved record can include:

- Attorney name
- California bar number
- Official profile URL
- License status
- City from search results
- Admission date
- Public address
- Phone and fax when listed
- Public email when visible on the source page
- Website when listed
- CLA sections
- Self-reported practice areas
- Languages spoken by attorney or staff
- Law school
- Status history rows
- Public discipline flag
- Scrape timestamp

### Data fields table

| Field | Description |
|---|---|
| `searchQuery` | Name or keyword that produced the record, or `null` for direct inputs. |
| `barNumber` | California State Bar license number. |
| `name` | Attorney name from search/profile page. |
| `profileUrl` | Official State Bar public profile URL. |
| `licenseStatus` | Current license status shown by the State Bar. |
| `city` | City shown in search results when available. |
| `admissionDate` | Admission date shown in search results/profile context. |
| `address` | Public mailing/business address when published. |
| `phone` | Public phone number when published. |
| `fax` | Public fax number when published. |
| `email` | Public visible email text when published. |
| `website` | Website URL or text when published. |
| `claSections` | California Lawyers Association sections listed on the profile. |
| `practiceAreas` | Self-reported practice areas. |
| `languagesByAttorney` | Languages self-reported for the attorney. |
| `languagesByStaff` | Languages self-reported for staff. |
| `lawSchool` | Law school field from the public profile. |
| `statusHistory` | Public status, discipline, administrative action, and admission rows. |
| `hasDiscipline` | Boolean flag derived from status-history discipline cells when available. |
| `scrapedAt` | ISO timestamp for the scrape. |

### How much does it cost to scrape California State Bar attorneys?

This actor uses pay-per-event pricing. There is a small run-start charge and then a per-result charge for each attorney record saved to the dataset.

For tests, start with `maxResults` between 5 and 20. Once you confirm the records match your workflow, increase `maxResults` for larger exports.

### How to scrape by attorney name

Use `searchQueries` when you have names or keywords.

Example:

```json
{
  "searchQueries": ["John Smith", "Maria Garcia"],
  "maxResults": 25,
  "includeDetails": true
}
````

The actor opens the official QuickSearch result page for each query, collects matching profile links, deduplicates by bar number, and stops when the global `maxResults` limit is reached.

### How to scrape by bar number

Use `barNumbers` when you already know exact California bar numbers. This is the best mode for compliance checks and individual verification because it avoids name-search ambiguity.

```json
{
  "barNumbers": ["72700"],
  "includeDetails": true
}
```

### How to scrape profile URLs

Use `profileUrls` when you already collected official State Bar profile links in another workflow.

```json
{
  "profileUrls": [
    { "url": "https://apps.calbar.ca.gov/attorney/Licensee/Detail/72700" }
  ],
  "includeDetails": true
}
```

### Input settings

| Input | Type | Use it for |
|---|---|---|
| `searchQueries` | Array of strings | Attorney names or free-text public search terms. |
| `barNumbers` | Array of strings | Exact direct lookup by California bar number. |
| `profileUrls` | Request list | Official State Bar profile URLs. |
| `maxResults` | Integer | Maximum records saved across all input modes. |
| `includeDetails` | Boolean | Whether to open each profile for full public detail fields. |

### Output example

```json
{
  "searchQuery": "John Smith",
  "barNumber": "72700",
  "name": "Charles John Smith",
  "profileUrl": "https://apps.calbar.ca.gov/attorney/Licensee/Detail/72700",
  "licenseStatus": "Active",
  "city": "San Francisco",
  "admissionDate": "December 1976",
  "address": "...",
  "phone": "...",
  "email": "...",
  "website": "...",
  "practiceAreas": ["..."],
  "lawSchool": "...",
  "statusHistory": [],
  "hasDiscipline": false,
  "scrapedAt": "2026-06-05T00:00:00.000Z"
}
```

### Tips for better results

- Use full names when possible.
- Prefer bar numbers for exact verification.
- Keep first runs small and inspect the dataset before scaling.
- Set `includeDetails` to `false` if you only need search-result fields and want faster runs.
- Use multiple specific searches instead of one broad keyword when you need cleaner matches.
- Review `statusHistory` rather than relying on a single field for compliance-sensitive workflows.

### Data quality notes

The source page controls which details are visible. Some profiles do not publish phone, email, website, language, practice-area, or law-school information. The actor preserves missing values as `null` or empty arrays instead of inventing data.

Email addresses on the State Bar site may be displayed through obfuscated markup. The actor extracts the visible public email span when present.

### Integrations

You can connect the output dataset to:

- 📊 **Google Sheets or Excel** for manual compliance review.
- 🧩 **CRM systems** for attorney lead enrichment.
- 🏛️ **Legal operations dashboards** for roster monitoring.
- 🧪 **Data pipelines** in BigQuery, Snowflake, or S3.
- 🔔 **Scheduled Apify tasks** that compare fresh exports against older datasets.
- 🤖 **MCP clients** that let Claude or another assistant verify an attorney on demand.

### Workflow patterns

#### License verification workflow

1. Upload a list of California bar numbers.
2. Run with `includeDetails=true`.
3. Export `barNumber`, `name`, `licenseStatus`, `profileUrl`, and `statusHistory`.
4. Store the official profile URL with your compliance record.

#### Lead enrichment workflow

1. Search by attorney names from your CRM.
2. Deduplicate on `barNumber`.
3. Export contact, website, city, and practice-area fields.
4. Route records with missing contact data to manual review.

#### Monitoring workflow

1. Schedule periodic runs for known bar numbers.
2. Compare current `licenseStatus` and `statusHistory` with prior datasets.
3. Alert your team when public status changes.

### API usage

Use actor ID `automation-lab/california-state-bar-attorney-scraper` in the Apify API, SDKs, CLI, or MCP tools.

### Node.js example

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("automation-lab/california-state-bar-attorney-scraper").call({
  searchQueries: ["John Smith"],
  maxResults: 10,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation-lab/california-state-bar-attorney-scraper").call(
    run_input={"searchQueries": ["John Smith"], "maxResults": 10, "includeDetails": True}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### cURL example

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~california-state-bar-attorney-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["John Smith"],"maxResults":10,"includeDetails":true}'
```

### MCP usage

Connect Apify MCP with this actor enabled:

```bash
claude mcp add apify-calbar-attorneys "https://mcp.apify.com/?tools=automation-lab/california-state-bar-attorney-scraper"
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-calbar-attorneys": {
      "url": "https://mcp.apify.com/?tools=automation-lab/california-state-bar-attorney-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

- "Use Apify MCP to run `automation-lab/california-state-bar-attorney-scraper` for bar number 72700 and summarize the license status."
- "Using the MCP tool, search the official California State Bar for John Smith and return 10 active attorneys with profile URLs."
- "Call the California State Bar Attorney Scraper through MCP for these bar numbers and flag records with discipline history."

### Legality

This actor reads public pages that are visible without logging in. It does not bypass access controls, solve CAPTCHAs, or collect private account-only data. You are responsible for using the data in a lawful way and respecting privacy, professional-responsibility, and downstream data-retention requirements.

### Limitations

- The actor is limited to public State Bar of California pages.
- Name search can return multiple attorneys with similar names.
- Public profile fields vary by attorney.
- The actor does not validate whether self-reported practice areas are current.
- The actor does not provide legal advice or determine attorney suitability.

### FAQ

#### Can I search multiple names in one run?

Yes. Add several entries to `searchQueries`. The actor deduplicates records by bar number and respects the global `maxResults` cap.

#### Can I fetch exact attorney records?

Yes. Use `barNumbers` or official `profileUrls` for exact lookup when you already know which California attorney profiles you need.

#### Why are some attorneys outside California?

California bar members can list public addresses outside California. The record is still a California State Bar profile because it has an official California bar number.

### Troubleshooting: why did I get fewer results than expected?

The public search page may have fewer matches than your `maxResults`, or a broad query may not match the names you expected. Try exact names, add middle initials, or use direct bar numbers when available.

### Troubleshooting: why are some fields empty?

Some attorneys do not publish every contact or practice field. Empty values usually mean the field was not visible on the public profile at scrape time.

### Troubleshooting: should I use includeDetails=false?

Use `includeDetails=false` when you only need fast search-result fields such as name, bar number, license status, city, admission date, and profile URL. Use `includeDetails=true` when you need contact fields, law school, languages, practice areas, and status history.

### Related scrapers

Related Automation Lab actors that can complement official attorney-license verification:

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) for business-location and contact enrichment.
- [Website Contact Scraper](https://apify.com/automation-lab/website-contact-scraper) for extracting emails and social links from firm websites.
- [Company Website Scraper](https://apify.com/automation-lab/company-website-scraper) for collecting structured website metadata.
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) for company-profile enrichment where appropriate.

### Example input

```json
{
  "searchQueries": ["John Smith"],
  "barNumbers": ["72700"],
  "maxResults": 10,
  "includeDetails": true
}
```

### Best practices

- Store `profileUrl` with every downstream record so reviewers can open the official source.
- Use `barNumber` as the strongest deduplication key.
- Keep raw Apify dataset exports for auditability.
- Schedule recurring runs only for records you have a legitimate need to monitor.
- Combine official license status with your own human review before making sensitive decisions.

### Support

If a run fails or returns unexpected data, include the run ID, input JSON, and one or two example records when requesting support. That makes it easier to reproduce the behavior against the public source pages.

# Actor input Schema

## `searchQueries` (type: `array`):

Attorney names or keywords to search in the California State Bar public licensee search.

## `barNumbers` (type: `array`):

Optional California State Bar numbers to fetch directly.

## `profileUrls` (type: `array`):

Optional official profile URLs such as https://apps.calbar.ca.gov/attorney/Licensee/Detail/72700.

## `maxResults` (type: `integer`):

Maximum number of attorney records to save across all searches and direct inputs.

## `includeDetails` (type: `boolean`):

Open each attorney profile to collect address, phone, email, website, practice areas, law school, and status history.

## Actor input object example

```json
{
  "searchQueries": [
    "John Smith"
  ],
  "barNumbers": [
    "72700"
  ],
  "profileUrls": [],
  "maxResults": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "searchQueries": [
        "John Smith"
    ],
    "barNumbers": [
        "72700"
    ],
    "profileUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/california-state-bar-attorney-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 = {
    "searchQueries": ["John Smith"],
    "barNumbers": ["72700"],
    "profileUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/california-state-bar-attorney-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 '{
  "searchQueries": [
    "John Smith"
  ],
  "barNumbers": [
    "72700"
  ],
  "profileUrls": []
}' |
apify call automation-lab/california-state-bar-attorney-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/california-state-bar-attorney-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "California State Bar Attorney Scraper",
        "description": "Verify California attorneys with official public State Bar license status, contact details, practice areas, law school, and history.",
        "version": "0.1",
        "x-build-id": "ox7h1L33fOCfAptaF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~california-state-bar-attorney-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-california-state-bar-attorney-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/automation-lab~california-state-bar-attorney-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-california-state-bar-attorney-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/automation-lab~california-state-bar-attorney-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-california-state-bar-attorney-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Attorney names or keywords to search in the California State Bar public licensee search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "barNumbers": {
                        "title": "Bar numbers",
                        "type": "array",
                        "description": "Optional California State Bar numbers to fetch directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "Optional official profile URLs such as https://apps.calbar.ca.gov/attorney/Licensee/Detail/72700.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum attorneys",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of attorney records to save across all searches and direct inputs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch profile details",
                        "type": "boolean",
                        "description": "Open each attorney profile to collect address, phone, email, website, practice areas, law school, and status history.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
