# 🏦 FDIC Bank Financials & Health Tracker (`nexgendata/fdic-bank-financials-health`) Actor

FDIC-insured bank financials & health: assets, deposits, net income, ROA, ROE, net interest margin, capital ratios by bank and quarter. For bank analysts, fintech, and risk teams.

- **URL**: https://apify.com/nexgendata/fdic-bank-financials-health.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 7 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.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

## 🏦 FDIC Bank Financials & Health Tracker

**Pay-per-result bank-financials data — $0.10 per institution record. Assets, deposits, net income, ROA, ROE, net interest margin and capital ratios for every FDIC-insured bank, by quarter, delivered as flat JSON with no Bloomberg seat and no FactSet contract.**

There are roughly 4,500 FDIC-insured commercial banks and savings institutions in the United States, and every one of them files a quarterly Call Report whose financials the FDIC republishes through its public Financial Data API. The FDIC Bank Financials & Health Tracker turns that feed into a clean, queryable dataset: pass a bank name, a state, an FDIC certificate number, or an asset-size threshold, and get back one record per institution with the headline balance-sheet and profitability metrics that bank analysts, fintech risk teams, and M&A scouts actually use — total assets, total deposits, return on assets, return on equity, and net interest margin — all tagged to the reporting quarter.

This is the dataset that sits behind deposit-competition analysis, de-novo-bank benchmarking, fintech partner due diligence, and regional-bank risk monitoring — without a terminal subscription and without parsing raw Call Report XBRL yourself.

### Why use this

The FDIC publishes this data for free, which is exactly why most teams underestimate how much work it is to use. The raw API paginates across thousands of institutions, uses cryptic Call Report field codes, mixes point-in-time and trailing metrics, and gives you no convenient way to slice by the things that matter — geography, asset band, active-vs-failed status. This actor does the assembly for you:

- **Query by the dimensions you think in.** Filter by bank name substring, two-letter state, exact FDIC certificate number, or a minimum total-assets threshold — instead of paging the entire universe and filtering client-side.
- **The health metrics pre-surfaced.** ROA, ROE, and net interest margin are the three ratios every bank analyst checks first. They come back on every record, already computed by the FDIC, so you don't reconstruct them from raw income and balance-sheet line items.
- **Active-only when you want it.** Set `activeOnly` to exclude failed, merged, or closed institutions and focus on the operating banking system.
- **Quarter-tagged.** Every record carries its `reportPeriod`, so a quarterly schedule builds a clean time series you can trend ROA or NIM across cycles.
- **No subscription, billed per row.** Pull one bank or two thousand; pay only for the records returned on Apify's pay-per-event model.

### What you get

Each record is one FDIC-insured institution for a reporting quarter, with the following real output fields:

- `name` — the institution's legal name
- `state` — the two-letter state code of the bank's headquarters
- `totalAssetsThousands` — total assets in thousands of USD (the standard FDIC reporting unit)
- `totalDepositsThousands` — total deposits in thousands of USD
- `roa` — return on assets (net income as a percentage of average assets), the core efficiency-of-balance-sheet metric
- `roe` — return on equity (net income as a percentage of average equity), the core shareholder-return metric
- `netInterestMargin` — net interest margin (net interest income as a percentage of average earning assets), the core spread-business profitability metric
- `reportPeriod` — the reporting quarter the figures belong to (e.g. a quarter-end date)

Every value comes straight from the FDIC's published Call Report data — no inference, no proprietary scoring, no synthetic ratings. If the FDIC reports it for that quarter, you get it.

### Use cases

- **Regional deposit-competition analysis.** Filter by `state`, sort by `totalDepositsThousands`, and rank every bank in a market to size the deposit base you're competing against or acquiring.
- **De-novo and challenger-bank benchmarking.** Pull peers in your asset band (`minAssetsThousands`) and compare your ROA, ROE, and NIM against the cohort to see whether your unit economics are in line.
- **Bank M&A target screening.** Combine a state filter with an asset-size floor to surface acquisition candidates in the size tier your buy-side mandate targets, then trend their profitability over recent quarters.
- **Fintech partner / sponsor-bank due diligence.** Before integrating with a sponsor bank (BaaS, card programs, lending), verify its asset base, deposit franchise, and profitability ratios as part of counterparty risk review.
- **Credit and counterparty risk monitoring.** Track a watchlist of banks by certificate number on a quarterly schedule and flag deterioration in ROA, ROE, or net interest margin.
- **Regional banking research and journalism.** Build a "healthiest / most-stressed banks in [state]" leaderboard from the same public data the regulators use.
- **Net-interest-margin sector research.** Aggregate NIM across the universe to track how the banking sector's spread business is responding to the rate environment.
- **Vendor TAM sizing.** Core-banking, treasury, and risk-software vendors can size their addressable market by asset band and geography directly from this feed.

### Sample output

A single record returned by the actor:

```json
{
  "name": "Pinnacle Bank",
  "state": "TN",
  "totalAssetsThousands": 48213907,
  "totalDepositsThousands": 39122044,
  "roa": 1.27,
  "roe": 10.84,
  "netInterestMargin": 3.41,
  "reportPeriod": "2026-03-31"
}
````

### Input parameters

| Parameter | Label | Description |
|-----------|-------|-------------|
| `bankName` | Bank name | Filter by bank name (substring/contains match). |
| `state` | State | Two-letter state code (e.g. `CA`, `NY`). |
| `certNumber` | FDIC CERT # | Exact FDIC certificate number for a single institution. |
| `minAssetsThousands` | Min total assets ($000) | Minimum total assets, in thousands of USD. |
| `activeOnly` | Active banks only | Return only currently-operating insured institutions. |
| `sortBy` | Sort by | FDIC field to sort by (default `ASSET`). |
| `maxResults` | Max results | Maximum number of banks to return. |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/fdic-bank-financials-health").call(run_input={
    "state": "TX",
    "minAssetsThousands": 1000000,
    "activeOnly": True,
    "sortBy": "ASSET",
    "maxResults": 100
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["state"], item["totalAssetsThousands"], item["roa"], item["roe"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~fdic-bank-financials-health/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "TX",
    "minAssetsThousands": 1000000,
    "activeOnly": true,
    "sortBy": "ASSET",
    "maxResults": 100
  }'
```

The FDIC publishes refreshed financials roughly 30–45 days after each quarter-end. Schedule this actor quarterly via Apify's built-in scheduler to capture every new Call Report cycle, and export results as JSON, JSONL, CSV, or Excel — or push them to Snowflake / BigQuery / Postgres for a stable, growing time series.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — you pay only for the institution records returned, never for run-time:

- **$0.10 per bank record** (the primary event — one charge per institution pushed to the dataset)
- A negligible actor-start cost per run (sub-cent at typical memory)

No subscription, no seat licence, no minimum. If a filtered run returns zero rows, you pay nothing for results.

#### Cost worked example

- Every active bank in one mid-size state (~200 institutions) → 200 × $0.10 = **$20.00** per run
- Top 100 banks nationwide by assets → 100 × $0.10 = **$10.00** per run
- A 25-bank counterparty watchlist on a quarterly schedule → 25 × $0.10 × 4/year = **$10.00/year**
- The full ~4,500-institution universe in one sweep → ~$450.00 — a one-time full-snapshot cost that would be a rounding error against a single terminal seat

You know your cost from the row count before the run starts. There are no compute, storage, or proxy add-ons.

### How this compares to Bloomberg / FactSet

| | Bloomberg Terminal | FactSet | FDIC Bank Financials & Health Tracker |
|---|---|---|---|
| FDIC bank financials & ratios | Yes | Yes | Yes (structured JSON) |
| Coverage | Global financials incl. US banks | Global financials | All ~4,500 FDIC-insured US banks |
| Annual cost | ~$24,000 / seat / year | ~$12,000 / seat / year | Pay-per-record, no subscription |
| Programmatic API | BLPAPI (seat-locked) | FactSet API | Apify REST + webhooks |
| Best for | Full cross-asset workstation | Institutional fundamentals | Pipelines, screens, watchlists, agents |

Bloomberg and FactSet are full-spectrum financial workstations — if you also need global equities, fixed income, and a research desk, you're paying for a terminal regardless. But if your workflow is specifically US bank financials — a quarterly peer screen, a deposit-competition map, an M\&A target list, or a counterparty watchlist — a $12k–$24k/seat/year terminal is wildly over-scoped. This actor delivers the same FDIC-sourced metrics as a per-row JSON feed at a 95%+ cost saving for the bank-data slice, with nothing to log into and a schema you can join in your own warehouse.

### FAQ

**Q: Where does the data come from?**

A: The FDIC's public Financial Data feed, which republishes the quarterly Call Report (Report of Condition and Income) that every FDIC-insured institution is legally required to file. The metrics (ROA, ROE, NIM) are computed and published by the FDIC.

**Q: How current is it?**

A: The FDIC typically publishes a quarter's financials about 30–45 days after quarter-end. Schedule the actor quarterly to pick up each fresh cycle as it posts.

**Q: What units are the dollar figures in?**

A: Assets and deposits are reported in **thousands of USD**, matching the FDIC's standard reporting unit. A `totalAssetsThousands` of `48213907` means ~$48.2 billion.

**Q: Can I look up one specific bank?**

A: Yes — pass its exact FDIC certificate number in `certNumber`, or a name substring in `bankName`, to isolate a single institution.

**Q: Does `activeOnly` exclude failed banks?**

A: Yes. With `activeOnly` set, the actor returns only currently-operating insured institutions, excluding banks that have failed, merged, or otherwise ceased operating.

**Q: Can I build a time series of a bank's health?**

A: Yes — schedule the actor quarterly and append each run's `reportPeriod`-tagged records to your warehouse. Over a few quarters you'll have a trended ROA / ROE / NIM history per institution.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract. New fields may be added over time — they appear as new keys, absent on older runs. The existing fields (`name`, `state`, `totalAssetsThousands`, `totalDepositsThousands`, `roa`, `roe`, `netInterestMargin`, `reportPeriod`) are never renamed or removed without a major-version bump and an advance changelog notice, and units and semantics (thousands of USD, percentage ratios, quarter-end periods) are never silently changed. Build production bank-risk pipelines on this actor without worrying about a breaking change landing unannounced.

### Compliance & legal

- The actor reads **public, official FDIC data** — the Call Report financials the FDIC is statutorily required to publish for every insured institution. No authentication, no anti-bot, no private endpoints.
- Bank financial data published by the FDIC is, by design, public regulatory disclosure intended for analysts, researchers, and market participants.
- Requests route through Apify's compliant infrastructure with polite pacing and an identifying User-Agent.
- You are responsible for ensuring your downstream use complies with the FDIC's terms, your jurisdiction's data-protection laws, and any sector-specific rules. Most read-only research, benchmarking, and risk-monitoring use of public bank financials is widely accepted; consult counsel before bulk commercial redistribution.

### Related NexGenData actors

Part of NexGenData's finance & markets regulatory cluster — pair this actor with:

- [Fed Bank Enforcement Actions](https://apify.com/nexgendata/fed-bank-enforcement-actions?fpr=2ayu9b) — Federal Reserve enforcement actions against banks and holding companies
- [US Treasury Auction Results](https://apify.com/nexgendata/us-treasury-auction-results?fpr=2ayu9b) — primary-market Treasury auction yields and bid-to-cover
- [Global Central Bank Policy Rates](https://apify.com/nexgendata/global-central-bank-policy-rates?fpr=2ayu9b) — policy-rate levels across major central banks
- [SEC XBRL Financial Frames — Peer Comparison](https://apify.com/nexgendata/sec-xbrl-financial-frames?fpr=2ayu9b) — cross-filer financial-concept benchmarking from SEC XBRL
- [Reg SHO Threshold Securities](https://apify.com/nexgendata/reg-sho-threshold-securities?fpr=2ayu9b) — daily threshold-list securities with persistent fails-to-deliver
- [Finviz Stock Screener](https://apify.com/nexgendata/finviz-stock-screener?fpr=2ayu9b) — US equities filtered by sector, fundamentals, and technicals

Explore the full catalog of 200+ buyer-intent actors at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

## `bankName` (type: `string`):

Filter by bank name (contains).

## `state` (type: `string`):

Two-letter state code (e.g. CA, NY).

## `certNumber` (type: `string`):

Exact FDIC certificate number.

## `minAssetsThousands` (type: `integer`):

Minimum total assets in thousands of USD.

## `activeOnly` (type: `boolean`):

Only currently-operating insured institutions.

## `sortBy` (type: `string`):

FDIC field to sort by (default ASSET).

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

Maximum banks to return.

## Actor input object example

```json
{
  "activeOnly": true,
  "sortBy": "ASSET",
  "maxResults": 500
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/fdic-bank-financials-health").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/fdic-bank-financials-health").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 '{}' |
apify call nexgendata/fdic-bank-financials-health --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nexgendata/fdic-bank-financials-health",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏦 FDIC Bank Financials & Health Tracker",
        "description": "FDIC-insured bank financials & health: assets, deposits, net income, ROA, ROE, net interest margin, capital ratios by bank and quarter. For bank analysts, fintech, and risk teams.",
        "version": "0.0",
        "x-build-id": "vFuJ57QR0Jd3eQCov"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~fdic-bank-financials-health/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-fdic-bank-financials-health",
                "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/nexgendata~fdic-bank-financials-health/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-fdic-bank-financials-health",
                "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/nexgendata~fdic-bank-financials-health/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-fdic-bank-financials-health",
                "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": {
                    "bankName": {
                        "title": "Bank name",
                        "type": "string",
                        "description": "Filter by bank name (contains)."
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Two-letter state code (e.g. CA, NY)."
                    },
                    "certNumber": {
                        "title": "FDIC CERT #",
                        "type": "string",
                        "description": "Exact FDIC certificate number."
                    },
                    "minAssetsThousands": {
                        "title": "Min total assets ($000)",
                        "type": "integer",
                        "description": "Minimum total assets in thousands of USD."
                    },
                    "activeOnly": {
                        "title": "Active banks only",
                        "type": "boolean",
                        "description": "Only currently-operating insured institutions.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "type": "string",
                        "description": "FDIC field to sort by (default ASSET).",
                        "default": "ASSET"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum banks to return.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
