# NMLS Scraper — Mortgage Loan Originators, Lenders & Branches (`ws_tony/nmls-consumer-access`) Actor

Pull MLO, lender, and branch records from NMLS Consumer Access. Auditable open-source actor with no survey-form gate. Returns one normalized row per entity with state licenses, disclosures, sponsor links, and computed risk-rollup flags.

- **URL**: https://apify.com/ws\_tony/nmls-consumer-access.md
- **Developed by:** [Tony](https://apify.com/ws_tony) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 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

## NMLS Scraper — Mortgage Loan Originators, Lenders & Branches

> The only NMLS Consumer Access scraper on the Apify Store that actually returns data. Pull mortgage loan originator (MLO), lender, and branch records — state licenses, federal registrations, regulator disclosures, sponsor relationships, contact info, and computed risk-rollup flags — by NMLS ID or by name. Open source, agent-ready, no required survey form.

Use it to verify mortgage license status, build licensee lists for recruiting and sales, run compliance checks against the NMLS database, and enrich your mortgage CRM with structured Nationwide Multistate Licensing System data.

### Why this exists

The other NMLS scraper on the Apify Store ships with a mandatory three-field intake survey, hides its source, and (as of 2026-05) doesn't actually return data on its own prefilled examples — `mode=by_name` for "Rocket Mortgage" returns 0 records and `mode=by_nmls_id` for `3030` (Rocket Mortgage's actual NMLS ID) returns `lookup_status: "not_found"`. This actor is the response. It actually works on those exact inputs, it's open source, and it returns 25+ fields per entity.

### Who this is for

- **Mortgage recruiters** building outreach lists of MLOs by state, sponsoring company, or license status
- **Wholesale lender BD teams** mapping broker territories and identifying licensed counterparties in target states
- **Compliance and risk onboarding teams** screening MLO and lender counterparties for active regulatory actions, license status, and disclosure history before approval
- **Mortgage CRMs and fintech integrators** enriching contact records with verified NMLS IDs, multi-state license coverage, sponsor relationships, and regulator disclosures
- **Market researchers** sizing the mortgage origination market by state, license type, sponsor, or branch footprint

### What you get

One structured JSON record per NMLS entity (MLO, mortgage company, or branch), written to the default Apify Dataset. Re-runs deduplicate cleanly on the `id` field (which equals `nmls_id`), so you can upsert into your warehouse without extra work.

#### Example input

```json
{
  "mode": "by_nmls_id",
  "nmlsIds": ["3030"],
  "includeDisclosures": true,
  "maxItems": 100,
  "capsolverApiKey": "<your-capsolver-key>",
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Example output (one row)

```json
{
  "id": "3030",
  "nmls_id": "3030",
  "entity_type": "COMPANY",
  "legal_name": "Rocket Mortgage, LLC",
  "other_trade_names": [
    "Champion Mortgage", "Champion Mortgage Company", "Rocket",
    "Rocket HQ", "Rocket Mortgage", "Rocket Pro", "Rocket Professional",
    "Rushmore Servicing", "Rushmore Servicing Group"
  ],
  "primary_address": {
    "street": "1050 Woodward Avenue",
    "city": "Detroit",
    "state": "MI",
    "zip": "48226",
    "country": "US"
  },
  "mailing_address": {
    "street": "1050 Woodward Avenue",
    "city": "Detroit",
    "state": "MI",
    "zip": "48226",
    "country": "US"
  },
  "state_licenses": [
    {
      "state": "Alabama",
      "regulator": "Alabama",
      "license_name": "Consumer Credit License",
      "license_number": "20979",
      "status": "Approved",
      "issue_date": "2009-11-10",
      "original_issue_date": "2009-11-10"
    }
  ],
  "federal_registrations": [],
  "sponsorships": null,
  "sponsored_individuals_count": 3705,
  "branch_count": 83,
  "employment_history": null,
  "disclosures": [
    {
      "date": "2021-09-22",
      "regulator": "Alabama",
      "action_type": "Order - Settlement Agreement and Order",
      "description": "Docket MC-2018-04; Multi-state ID M104096",
      "length_in_days": null,
      "settled": true
    }
  ],
  "has_active_regulatory_action": true,
  "total_state_licenses_active": 165,
  "contact_email": "CompanyLicensing@rocketmortgage.com",
  "source_url": "https://www.nmlsconsumeraccess.org/EntityDetails.aspx/COMPANY/3030",
  "scraped_at": "2026-05-03T03:44:31.340Z"
}
```

#### Field notes

- `id` is always equal to `nmls_id`. Use it as your upsert key.
- `entity_type` is one of `INDIVIDUAL`, `COMPANY`, or `BRANCH`. The actor auto-detects when not pinned.
- `state_licenses` is one row per state-regulator pairing. An entity licensed in 51 jurisdictions returns 51 rows here.
- `sponsorships` is populated for `INDIVIDUAL` records (current sponsoring company); `null` otherwise.
- `sponsored_individuals_count` and `branch_count` are populated for `COMPANY` records; `null` otherwise.
- `has_active_regulatory_action` and `total_state_licenses_active` are computed rollups — visible at-a-glance in the dataset preview without an ETL step on your side.
- `contact_email` is decoded from Cloudflare's `data-cfemail` obfuscation.
- All timestamps are ISO-8601 UTC.

### Inputs

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | enum | `by_nmls_id` | `by_nmls_id` or `by_name` |
| `nmlsIds` | string\[] | `["3030"]` | Used when `mode=by_nmls_id` |
| `names` | string\[] | `["Rocket Mortgage"]` | Used when `mode=by_name` |
| `entityType` | enum | `""` | `""` (all), `INDIVIDUAL`, `COMPANY`, `BRANCH` |
| `includeDisclosures` | boolean | `true` | Parse regulator action history |
| `maxItems` | int | `100` | Hard cap, max 10,000 |
| `proxyConfiguration` | object | Apify default | Switch to RESIDENTIAL if you see Cloudflare blocks |
| `capsolverApiKey` | secret string | none | Required to actually fetch data — see below |
| `maxConcurrency` | int | `4` | Polite default |

### CAPTCHA setup

NMLS Consumer Access uses BotDetect CAPTCHA at the session-warmup step. The actor solves it once per run, then reuses the session for every subsequent record — so the CAPTCHA cost amortizes to fractions of a cent per record.

The default integration is [CapSolver](https://capsolver.com), pay-as-you-go (~$0.0005/solve, ~$5 minimum top-up). Set your key as `capsolverApiKey` in the input or as the `CAPSOLVER_API_KEY` environment variable.

Without a key, the actor exits cleanly with a clear error rather than burning your account on a half-broken run.

Alternatives the actor's solver interface supports (one-line swap in `src/solver/index.ts`):

- 2Captcha or Anti-Captcha (equivalent pricing, different vendor)
- Self-hosted OCR (free, more work — write a `CaptchaSolver` implementation)
- Manual session caching (warm once, save cookies to KV store, reuse)

### Pricing

Pay-per-event:

- `Actor Start` → **$0.05** per run (covers session warmup, including the BotDetect CAPTCHA solve)
- `Record scraped` → **$0.001** per entity record saved to the dataset

A few worked examples so you can budget:

| Records returned | You pay |
|---|---|
| 1 (single MLO lookup) | $0.051 |
| 100 (recruit / sales list) | $0.15 |
| 1,000 (territory map) | $1.05 |
| 10,000 (quarterly compliance sweep) | $10.05 |

Per-record charges only fire when records actually save to the dataset — so a search that legitimately matches nothing only incurs the small start fee for the warmup work, not per-record fees.

**v1.1 roadmap (additive — no breaking changes):** a `Compliance` event ($0.005/record) for parsed disclosures + cross-state risk score; a `Bulk` discount tier above 10K records in a single run; a `Standby` event ($0.01/call) for synchronous single-record lookups via the Apify Standby endpoint.

### Limitations

- v1 supports `by_nmls_id` and `by_name`. `by_state`, `by_company_employees`, and `by_license_status` ship in v1.1.
- All three entity types are supported (COMPANY, INDIVIDUAL, BRANCH). For INDIVIDUAL records, `sponsorships` and `federal_registrations` are populated when present; `employment_history` is reconstructed from per-license sponsorship history and aggregated to one entry per unique employer.
- Disclosures are parsed from the public regulator-actions table. Length-in-days and full action descriptions live behind a "View Details" expansion not currently scraped (v1.1).
- The portal updates nightly on business days — fresher data than that requires hitting NMLS directly.

### FAQ

**Is there a public NMLS API?** No — NMLS does not publish a free public API for company, branch, or MLO records. NMLS Consumer Access (the public web portal at nmlsconsumeraccess.org) is the only public source, and it's CAPTCHA-protected behind a Cloudflare-fronted Turing Test page. This actor wraps the portal as a stable, structured pay-per-record data feed.

**What data does NMLS Consumer Access include?** Mortgage Loan Originators (~500K active), mortgage companies (~40K), and branches (~125K). Per entity: identity, current and historical legal names, state licenses (regulator, license number, status, dates), federal registrations for depository-institution MLOs, regulator disclosures, sponsor relationships, employment history reconstructed from per-license sponsorships, branch counts, sponsored-MLO counts, and contact info.

**How do I verify a mortgage loan originator's license?** Pass the MLO's NMLS ID with `mode=by_nmls_id`. The returned record includes every state license they hold (state, license number, status, issue date), any federal registration, current sponsoring company, and the count and details of any regulator disclosures.

**Can I bulk-verify mortgage lender licenses?** Yes — pass an array of NMLS IDs in `nmlsIds` (up to 10,000 per run) and the actor returns one normalized record per ID. Compliance teams use this for quarterly renewal sweeps and pre-onboarding screens.

**How do I find an MLO if I don't know their NMLS ID?** Use `mode=by_name`. The actor calls the same JSON search API the NMLS frontend uses and auto-iterates COMPANY and INDIVIDUAL entity types if you don't pin one. For very common names, narrow with `entityType` to avoid the portal's "too many results" cap.

**Why is the source open?** Compliance and risk teams audit their data sources. An auditable scraper sells better — and lets you fork it if you ever need a custom field added.

**Can I run on a schedule?** Yes — Apify Schedules. Recommended cadence: weekly for license-renewal monitoring, monthly for full portfolio refreshes, on-demand for fraud / pre-onboarding lookups.

**How does this handle the Cloudflare block and BotDetect CAPTCHA?** One CAPTCHA solve at session warmup, then session cookies carry the rest of the run. CapSolver is the default solver (~$0.0004/solve, amortized to fractions of a cent per record at typical run sizes). Two-Captcha and Anti-Captcha are one-line drop-in alternatives.

**MCP / agentic support?** Planned for v1.2. The actor's input shape is already designed to be MCP-packaged with no breaking changes — AI agents will be able to call it as a tool for live MLO verification.

### Running locally

```bash
npm install
npm run typecheck
npm run start:dev
```

Set `capsolverApiKey` in `storage/key_value_stores/default/INPUT.json` for the dev loop. Run `apify push` to deploy.

### License

MIT.

# Actor input Schema

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

How to find entities. 'by\_nmls\_id' is a direct lookup of one or more NMLS IDs (cheapest, fastest). 'by\_name' runs a full-text search and pulls every matching detail page.

## `nmlsIds` (type: `array`):

List of NMLS IDs to fetch directly. Used when mode = by\_nmls\_id. Example: 3030 = Rocket Mortgage.

## `names` (type: `array`):

Names to search. Used when mode = by\_name. Each name is searched separately; matches are followed to the detail page and parsed.

## `entityType` (type: `string`):

Restrict results to a single entity type. Leave blank to include all.

## `includeDisclosures` (type: `boolean`):

Parse regulator action history on each entity detail page. Slightly slower but compliance-grade.

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

Hard cap on records pushed to the dataset. Protects you from unbounded runs.

## `proxyConfiguration` (type: `object`):

Apify Proxy is recommended. Default group works for most runs; switch to RESIDENTIAL for high-volume or if you see Cloudflare blocks.

## `capsolverApiKey` (type: `string`):

If provided, used to solve the BotDetect CAPTCHA during session warmup. Without it, the actor logs a clear error and exits — you cannot reach detail pages without solving the warmup CAPTCHA at least once. Get a key at https://capsolver.com (pay-as-you-go, ~$0.0005/solve).

## `maxConcurrency` (type: `integer`):

Parallel detail-page fetches. Keep low to be polite to NMLS.

## Actor input object example

```json
{
  "mode": "by_nmls_id",
  "nmlsIds": [
    "3030"
  ],
  "names": [
    "Rocket Mortgage"
  ],
  "entityType": "",
  "includeDisclosures": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "maxConcurrency": 4
}
```

# 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": "by_nmls_id",
    "nmlsIds": [
        "3030"
    ],
    "names": [
        "Rocket Mortgage"
    ],
    "entityType": "",
    "includeDisclosures": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ws_tony/nmls-consumer-access").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": "by_nmls_id",
    "nmlsIds": ["3030"],
    "names": ["Rocket Mortgage"],
    "entityType": "",
    "includeDisclosures": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ws_tony/nmls-consumer-access").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": "by_nmls_id",
  "nmlsIds": [
    "3030"
  ],
  "names": [
    "Rocket Mortgage"
  ],
  "entityType": "",
  "includeDisclosures": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call ws_tony/nmls-consumer-access --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NMLS Scraper — Mortgage Loan Originators, Lenders & Branches",
        "description": "Pull MLO, lender, and branch records from NMLS Consumer Access. Auditable open-source actor with no survey-form gate. Returns one normalized row per entity with state licenses, disclosures, sponsor links, and computed risk-rollup flags.",
        "version": "0.1",
        "x-build-id": "iMu0b3UpgsenJOOzF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ws_tony~nmls-consumer-access/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ws_tony-nmls-consumer-access",
                "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/ws_tony~nmls-consumer-access/runs": {
            "post": {
                "operationId": "runs-sync-ws_tony-nmls-consumer-access",
                "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/ws_tony~nmls-consumer-access/run-sync": {
            "post": {
                "operationId": "run-sync-ws_tony-nmls-consumer-access",
                "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": "Query mode",
                        "enum": [
                            "by_nmls_id",
                            "by_name"
                        ],
                        "type": "string",
                        "description": "How to find entities. 'by_nmls_id' is a direct lookup of one or more NMLS IDs (cheapest, fastest). 'by_name' runs a full-text search and pulls every matching detail page.",
                        "default": "by_nmls_id"
                    },
                    "nmlsIds": {
                        "title": "NMLS IDs",
                        "type": "array",
                        "description": "List of NMLS IDs to fetch directly. Used when mode = by_nmls_id. Example: 3030 = Rocket Mortgage.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "names": {
                        "title": "Names",
                        "type": "array",
                        "description": "Names to search. Used when mode = by_name. Each name is searched separately; matches are followed to the detail page and parsed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "entityType": {
                        "title": "Entity type filter",
                        "enum": [
                            "",
                            "INDIVIDUAL",
                            "COMPANY",
                            "BRANCH"
                        ],
                        "type": "string",
                        "description": "Restrict results to a single entity type. Leave blank to include all.",
                        "default": ""
                    },
                    "includeDisclosures": {
                        "title": "Include regulator disclosures",
                        "type": "boolean",
                        "description": "Parse regulator action history on each entity detail page. Slightly slower but compliance-grade.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on records pushed to the dataset. Protects you from unbounded runs.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is recommended. Default group works for most runs; switch to RESIDENTIAL for high-volume or if you see Cloudflare blocks."
                    },
                    "capsolverApiKey": {
                        "title": "CapSolver API key (optional)",
                        "type": "string",
                        "description": "If provided, used to solve the BotDetect CAPTCHA during session warmup. Without it, the actor logs a clear error and exits — you cannot reach detail pages without solving the warmup CAPTCHA at least once. Get a key at https://capsolver.com (pay-as-you-go, ~$0.0005/solve)."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel detail-page fetches. Keep low to be polite to NMLS.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
