# FDIC Bank Intelligence (`skootle/fdic-bank-intelligence`) Actor

Official FDIC institution data for bank due diligence, fintech enrichment, market research, API integrations, schedules, and monitoring.

- **URL**: https://apify.com/skootle/fdic-bank-intelligence.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** Lead generation, Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<!-- skootle:growth-loop-hook -->
## FDIC Bank Intelligence

Turn the official FDIC institution feed into a small, documented dataset for bank due diligence, counterparty enrichment, market mapping, and agent workflows. Run it from the Apify Console, the Apify API, or a scheduled automation. It returns a clear `summary` first, followed by normalized `bank` records that retain the official source URL.

### What does FDIC Bank Intelligence return?

The actor queries the public FDIC institutions API and produces one dataset row per matched institution. It is useful when a spreadsheet, CRM, risk workflow, or AI agent needs stable identifiers and numeric financial fields instead of an unstructured search result.

Each run writes these two record types:

* A `summary` row first, with the query, state, active-status filter, count, `totalAvailable`, aggregates for returned assets and deposits, `activeCount`, pagination values, warnings, and an `agentMarkdown` briefing.
* A `bank` row for every returned institution, with the certificate, name, operating status, city, state, address, county, coordinates, assets, deposits, domestic branch count, regulator, FDIC supervisor, charter agent, dates, website, completeness score, source URL, retrieval time, and agent-ready markdown.

The live E2E run used the official source with a Maine state filter and a limit of three. It confirmed that rows include `schemaVersion`, `recordType`, `id`, `sourceUrl`, `retrievedAt`, `fieldCompletenessScore`, `name`, `certificate`, `activeStatus`, `assetsUsd`, `depositsUsd`, `regulator`, and `agentMarkdown`. The FDIC response is parsed from its `meta` object plus `data` entries that contain a nested `data` object.

<!-- skootle:review-cta -->
If this actor saved research time, please leave a short review after the run: [FDIC Bank Intelligence reviews](https://apify.com/skootle/fdic-bank-intelligence/reviews).

### Why use this instead of a manual FDIC search?

Manual lookups work for one bank. They become repetitive when you need a bounded result set, a repeatable source URL, numeric fields suitable for filtering, and a record a downstream process can identify later. This actor applies an optional name fragment, a two-letter state, an active-only flag, limit, and offset to the official source. It preserves missing source values as `null` rather than inventing a value.

The output is deliberately narrow. It is an institution-intelligence feed, not a credit opinion, a branch-hours directory, or a substitute for reviewing current official filings. The `sourceUrl` on every row makes verification practical.

### Input reference

| Field | Type | Default | What it controls |
| --- | --- | --- | --- |
| `query` | string, up to 120 characters | `""` | Optional bank-name fragment sent to the FDIC name filter. |
| `state` | two letters | omitted | Optional institution state, for example `"ME"` or `"TX"`. Case is normalized. |
| `activeOnly` | boolean | `true` | Requests institutions marked active by the FDIC source. |
| `limit` | integer, 1 to 100 | `25` | Maximum number of institution records returned in this run. |
| `offset` | integer, 0 or higher | `0` | Offset for deterministic page-style traversal of a larger result set. |

Concrete input for a first pass over active Maine institutions:

```json
{
  "query": "",
  "state": "ME",
  "activeOnly": true,
  "limit": 25,
  "offset": 0
}
````

Use a small `limit` while designing an automation. Once the fields and filters are correct, move `offset` forward by the same page size. The actor enforces the maximum of 100 records per request to keep each result set manageable.

### Output reference

Every row has a schema version, a record type, a stable actor ID, source URL, retrieval timestamp, completeness score, and `agentMarkdown`. Dataset ordering matters: row one is always the `summary`, then come the `bank` rows.

```json
{
  "schemaVersion": "1.0",
  "recordType": "bank",
  "id": "fdic-bank-10",
  "sourceUrl": "https://api.fdic.gov/banks/institutions?format=json&limit=25&offset=0&filters=STALP%3AME+AND+ACTIVE%3A1",
  "retrievedAt": "2026-07-18T15:00:00.000Z",
  "fieldCompletenessScore": 89,
  "name": "Example Institution",
  "certificate": 10,
  "activeStatus": "active",
  "city": "Example City",
  "state": "me",
  "assetsUsd": 125000000,
  "depositsUsd": 99000000,
  "domesticBranches": 3,
  "regulator": "OCC",
  "website": null
}
```

The values above demonstrate the verified output shape, not a claim about a current institution. Monetary values remain numbers when the FDIC returns them. A field such as `assetsUsd`, `website`, coordinates, or a date can be `null` when it is absent or unusable in the source response.

The accompanying summary is designed for a workflow to inspect before it processes individual records:

```json
{
  "recordType": "summary",
  "id": "fdic-summary-0-25-all-ME",
  "query": "",
  "state": "me",
  "activeOnly": true,
  "count": 25,
  "totalAvailable": 0,
  "offset": 0,
  "limit": 25,
  "sourceStatus": "ok",
  "assetsUsdTotal": 0,
  "depositsUsdTotal": 0,
  "activeCount": 25,
  "warnings": []
}
```

`totalAvailable`, `assetsUsdTotal`, and `depositsUsdTotal` are examples of fields, not promised values. Read the actual row, especially when a run has a narrow query or an expected no-match.

### Tutorial: build a repeatable bank research list

1. Start with a state-only search, `activeOnly: true`, `limit: 25`, and `offset: 0`.
2. Open the first dataset row. Confirm `sourceStatus` is `ok`, note `count` and `totalAvailable`, and keep the `sourceUrl` for your audit trail.
3. Filter the following `bank` records by `certificate`, `regulator`, `assetsUsd`, `depositsUsd`, or `domesticBranches` in your data tool.
4. For a name-specific review, add a short `query`. Treat it as a name search aid, then validate the certificate and source record before making a decision.
5. If more records exist, run the next page with `offset` increased by the prior `limit`. Deduplicate downstream on `id` or `certificate`.
6. Store `retrievedAt` with your own decision record. Institution data can change, and a future run should be understood as a new observation.

The actor also creates `AGENT_BRIEFING.md` in the key-value store. It gives an automation a compact handoff with the query, number returned, active filter, aggregate assets, and source status.

### Worked examples from the verified output contract

#### 1. Find active banks in a state

Input:

```json
{"state":"ME","activeOnly":true,"limit":3,"offset":0}
```

The live E2E shape for this source path returned three `bank` records and a `summary`. Use `summary.count` to confirm the page size, then use `name`, `certificate`, `city`, `state`, and `activeStatus` for a compact market list. Every returned record points to the FDIC API URL that produced it.

#### 2. Build a regulator-enrichment table

Input:

```json
{"state":"TX","activeOnly":true,"limit":50,"offset":0}
```

Send `certificate`, `name`, `regulator`, `fdicSupervisor`, `charterAgent`, `assetsUsd`, and `depositsUsd` to your table. Keep `fieldCompletenessScore` beside optional fields so a null is not mistaken for a failed enrichment. This is useful for prioritizing a later review, not for assigning regulatory status beyond what the source reports.

#### 3. Research a name fragment without losing provenance

Input:

```json
{"query":"community","state":"ME","activeOnly":false,"limit":25,"offset":0}
```

The actor combines the state, active-status, and safely encoded name filters in the official request URL. It returns `activeStatus` as either `active` or `inactive`, allowing an analyst to keep historical institution results distinct from active ones. Use the `certificate` rather than the displayed name as your preferred institution identifier.

#### 4. Page through a bounded list

First run:

```json
{"state":"CA","activeOnly":true,"limit":100,"offset":0}
```

Next run:

```json
{"state":"CA","activeOnly":true,"limit":100,"offset":100}
```

Compare each summary's `offset`, `count`, and `totalAvailable`. Append only `bank` rows to your destination, keyed by `id`. This prevents the summary rows from being treated as institutions and lets a workflow stop when `count` is lower than the requested page size.

#### 5. Send a compact record to an AI research agent

Use the `agentMarkdown` field from a `bank` record. It includes the institution name, certificate, status, location, assets, deposits, and source URL. The agent can draft a follow-up checklist, but it should preserve the source link and label any conclusion as a review task.

#### 6. Detect an expected no-match safely

Input:

```json
{"query":"unlikely exact bank phrase","state":"ME","activeOnly":true,"limit":25,"offset":0}
```

An ordinary no-match is successful and returns a zero-count `summary`. That is different from a source failure: non-OK HTTP responses, malformed responses, and a non-empty source payload that cannot be normalized fail the run instead of being presented as a clean zero.

### Agent workflows and monitoring

For counterparty monitoring, schedule a state or name-fragment query on a cadence that matches your risk process. On each run, first inspect the `summary` row. Alert on `sourceStatus` not equal to `ok`, unexpected zero results for a normally populated query, or a sharp change in `count`. Use `id` and `certificate` to compare runs, and retain `sourceUrl` and `retrievedAt` for a reproducible record.

A sensible workflow is:

1. Run the actor nightly or weekly with a fixed input.
2. Store only `bank` rows in a history table, preserving `retrievedAt`.
3. Compare current and prior records by `certificate` or `id`.
4. Route changes in `activeStatus`, reported assets, deposits, regulator, or website to a human review queue.
5. Use `agentMarkdown` and the official link in the queue item, not a generated narrative alone.

Do not use a delta as proof of a corporate event. Recheck the linked FDIC source and, where necessary, the institution's own disclosures.

### Limitations and data handling

- The actor reflects fields available from the public FDIC institutions API at retrieval time. It does not calculate credit quality, ownership, branch operating hours, or insurance coverage for a specific account.
- Name matching is not entity resolution. Similar names can represent different institutions, and legal-name changes can occur. Validate with the certificate and official source.
- `activeOnly` uses the FDIC institution status field. It does not guarantee that every physical branch is open, that a product is offered, or that an account is insured in a particular situation.
- A null field means the source did not provide a usable value to this actor. It is not a zero, an estimate, or a negative answer.
- `offset` is suitable for page-style collection, but source data can change between runs. Keep run timestamps and deduplicate by stable IDs.
- This output supports research and workflow triage. It is not legal, financial, regulatory, or investment advice.

### Buyer FAQ

#### Is this affiliated with the FDIC?

No. This independent actor reads a public FDIC API. It is not affiliated with, endorsed by, sponsored by, or operated by the Federal Deposit Insurance Corporation.

#### Can I get every matching bank?

Yes, use bounded pages. Set a `limit` from 1 through 100 and increase `offset` for later pages. Use the summary's `totalAvailable` and `count` to control the loop.

#### Why are assets or deposits sometimes null?

The actor preserves the official source's availability. It does not infer missing financial values. Keep the completeness score and source URL in downstream reporting so missingness stays visible.

#### Does active status tell me a branch is open today?

No. It reflects the institution status returned by the FDIC source. Confirm physical locations, services, account coverage, and any transaction-specific fact through the relevant official channel.

#### What does a zero-result run mean?

For a legitimate no-match, it means the filter returned no records and the summary reports `count: 0`. A source HTTP error, malformed payload, or parser-drift condition fails the run rather than pretending to be a zero-result success.

#### Can my CRM use the output directly?

Yes. Use `id` or `certificate` as the deduplication key, map numeric assets and deposits without string parsing, and keep `sourceUrl` and `retrievedAt` as provenance fields.

#### Can an AI agent consume this without another aggregation step?

Yes. The first row is an explicit summary and each institution includes `agentMarkdown`. An agent should still open the supplied official source before taking an external action or making a material recommendation.

#### Is there a rate or result-size limit?

Each run accepts at most 100 records through `limit`. For broader coverage, paginate responsibly and avoid issuing redundant requests from parallel automations.

### Pricing

Live Store pricing is $0.01 per Actor start plus $0.003 per dataset result, displayed as $3.00 per 1,000 results. Apify platform usage is included rather than billed separately. Use `limit`, pagination, and your Apify run-charge controls to keep institution research within budget.

### Legal and non-affiliation

FDIC Bank Intelligence is an independent data-processing tool. FDIC names, data, and links belong to their respective owners. Use the public source according to its applicable terms and policies. You are responsible for validating information for your use case and for meeting any legal, regulatory, privacy, retention, and internal-control requirements that apply to your organization.

### Related actors

- **CPSC Product Recall Intelligence**: monitor public product recalls, hazards, remedies, manufacturers, and official recall links for supplier or marketplace workflows.
- **NHTSA Vehicle Safety Intelligence**: research vehicle recalls and complaint signals when a counterparty or product workflow touches automotive risk.

### Support and feedback

For a reproducible data or source-shape issue, open the actor's Issues tab with the input, `sourceUrl`, timestamp, actor run ID, and error text. Do not include confidential customer, account, or credential data. For a workflow request or a successful outcome, use the feedback section or leave a review. Clear examples of the expected fields and the linked public source help prioritize improvements.

# Actor input Schema

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

Optional bank or institution name search sent to the official FDIC API.

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

Optional two-letter US state abbreviation used to filter institutions.

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

Return only active FDIC-insured institutions when enabled.

## `limit` (type: `integer`):

Maximum institution records returned in this run.

## `offset` (type: `integer`):

Zero-based FDIC result offset for bounded pagination.

## Actor input object example

```json
{
  "query": "community bank",
  "state": "ME",
  "activeOnly": true,
  "limit": 25,
  "offset": 0
}
```

# Actor output Schema

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

Default dataset. The first row is a summary, followed by normalized institution records.

## `agentBriefing` (type: `string`):

Markdown briefing derived from the summary row.

# 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("skootle/fdic-bank-intelligence").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("skootle/fdic-bank-intelligence").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 skootle/fdic-bank-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDIC Bank Intelligence",
        "description": "Official FDIC institution data for bank due diligence, fintech enrichment, market research, API integrations, schedules, and monitoring.",
        "version": "0.0",
        "x-build-id": "lRYswTEc1IMklSVNr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skootle~fdic-bank-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skootle-fdic-bank-intelligence",
                "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/skootle~fdic-bank-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-skootle-fdic-bank-intelligence",
                "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/skootle~fdic-bank-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-skootle-fdic-bank-intelligence",
                "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": {
                    "query": {
                        "title": "Bank name search",
                        "type": "string",
                        "description": "Optional bank or institution name search sent to the official FDIC API.",
                        "default": "community bank"
                    },
                    "state": {
                        "title": "State abbreviation",
                        "type": "string",
                        "description": "Optional two-letter US state abbreviation used to filter institutions.",
                        "default": "ME"
                    },
                    "activeOnly": {
                        "title": "Active institutions only",
                        "type": "boolean",
                        "description": "Return only active FDIC-insured institutions when enabled.",
                        "default": true
                    },
                    "limit": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum institution records returned in this run.",
                        "default": 25
                    },
                    "offset": {
                        "title": "FDIC result offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Zero-based FDIC result offset for bounded pagination.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
