# FDIC Bank Financials: Certificate Quarter Windows (`thatmike1/us-fdic-bank-financials`) Actor

Get the latest bounded FDIC report-date rows for certificate watchlists, preserving raw ASSET, DEP and NETINC values with coverage and source evidence.

- **URL**: https://apify.com/thatmike1/us-fdic-bank-financials.md
- **Developed by:** [Michal Pšenčík](https://apify.com/thatmike1) (community)
- **Categories:** Business, Other
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## FDIC Bank Financials: Certificate Quarter Windows

Get the newest report dates the FDIC BankFind financials API currently returns for a watchlist of FDIC certificate numbers, one dataset row per bank. Each row holds the raw `ASSET`, `DEP` and `NETINC` values for up to 20 report dates, how many report dates the FDIC holds for that bank, and the exact source URL with the SHA-256 of its response. It is meant for weekly refreshes of a bank portfolio after quarterly reporting, without maintaining FDIC API code yourself.

This is a raw-field extraction. It is not branch history, an authorization or insurance check, investment advice, a credit view or a safety score, and it computes no ratios, growth rates or single-quarter profit. This actor is independent of the FDIC and not endorsed by it.

### Input

```json
{
    "certificates": ["3510", "628"],
    "periods": 4,
    "maxItems": 100
}
```

- `certificates`: 1 to 20 FDIC certificate numbers (`CERT`) as digit strings. Surrounding spaces and leading zeros are removed; the result must be a nonzero number of at most 9 digits. Duplicates collapse to the first occurrence and are fetched and billed once. Default `["3510"]`. Find a bank's certificate on [FDIC BankFind](https://banks.data.fdic.gov/bankfind-suite/).
- `periods`: how many of the newest report dates to return per bank, 1 to 20. Default 4. "Newest" means the newest the API returns right now, not a promise about the current calendar quarter.
- `maxItems`: stop after this many rows are stored, 1 to 100. Default 100. With at most 20 unique certificates, 20 rows is the real maximum per run.

Unknown fields, wrong types and out-of-range values fail the run before any source request, with the reason in `SUMMARY`.

### Output

One row per found certificate, in input order:

```json
{
    "schemaVersion": 1,
    "recordId": "fdic-financial-window:3510:4",
    "deliveryId": "43535bd425710bbf62151371fb25c554dae5c38259d56e9e5747da8e6493d9fe",
    "observedAt": "2026-10-22T21:37:29.561Z",
    "contentHash": "2c44203b396dc0cfa9974b40ee3e2b4089fe3b76587f240f70d7a0d3f6feac83",
    "provenance": [
        {
            "url": "https://api.fdic.gov/banks/financials?filters=CERT%3A3510&fields=CERT%2CREPDTE%2CASSET%2CDEP%2CNETINC&sort_by=REPDTE&sort_order=DESC&limit=4&offset=0&format=json",
            "sha256": "d50267665b365b27000f4b14c1f29868da8e37f766b03ae18942622dbcc7f304"
        }
    ],
    "certificate": "3510",
    "requestedPeriods": 4,
    "sourceTotalAvailable": 170,
    "completeHistory": false,
    "amountEncoding": "raw_FDIC_numeric_no_conversion",
    "financials": [
        {
            "sourceId": "3510_20260630",
            "reportDate": "2026-06-30",
            "ASSET": 2654645000,
            "DEP": 2121804000,
            "NETINC": 14947000
        },
        {
            "sourceId": "3510_20260331",
            "reportDate": "2026-03-31",
            "ASSET": 2672192000,
            "DEP": 2128004000,
            "NETINC": 7417000
        },
        {
            "sourceId": "3510_20251231",
            "reportDate": "2025-12-31",
            "ASSET": 2636823000,
            "DEP": 2101968000,
            "NETINC": 30380000
        },
        {
            "sourceId": "3510_20250930",
            "reportDate": "2025-09-30",
            "ASSET": 2651090000,
            "DEP": 2094732000,
            "NETINC": 22536000
        }
    ]
}
```

- `financials` is sorted newest first. `reportDate` is the FDIC `REPDTE` written as `YYYY-MM-DD`, with no time zone. `sourceId` is the FDIC record ID.
- `ASSET`, `DEP` and `NETINC` are the exact numbers the API returned, or `null` when the source omits them. Nothing is multiplied, rounded, converted or annualized. The FDIC field dictionary does not state one unit for these three fields, so the row says `raw_FDIC_numeric_no_conversion` instead of claiming dollars. `NETINC` is kept as reported; it is not asserted to be a single quarter's income, so do not subtract periods from it.
- `sourceTotalAvailable` is the number of report dates the FDIC holds for the bank. `completeHistory` is true only when that number is at most `periods`.
- `recordId` is stable across runs for the same certificate and window size. `contentHash` is the SHA-256 of the bank payload (keys sorted, compact JSON), so a corrected value changes it and an unchanged repeat keeps it. `deliveryId` identifies this run's delivery of the row. `observedAt` is when the source response finished.

A row is all or nothing: if any report date in a bank's window fails validation (wrong certificate or ID, a date that is not a quarter end, out-of-order or conflicting duplicate dates, a number sent as text, an integer too large to keep exactly, or a report date with all three amounts missing), that bank gets no row and the reason goes to `SUMMARY`. A bank with fewer rows than the FDIC says it holds is reported as incomplete, not delivered short.

Export the dataset as JSON, CSV or Excel from the run's Storage tab or the API.

### Run summary (free)

Every run writes a `SUMMARY` record to its key-value store, also on failure: run status (`complete`, `partial`, `failed` or `capped`), the resolved input, request, byte and row counts, and one outcome per certificate (`delivered`, `empty`, `missing`, `error` or `not_attempted`) with an error code, HTTP status and warnings. A certificate the FDIC has no record for is `empty`; that says nothing about whether the bank is open, closed, insured or deleted. The FDIC dataset name and creation time are kept in the warnings as freshness context; they are not bank filing dates. When a cap stops the run, `firstUndeliveredKey` names the first certificate left undelivered, so you can rerun from there.

### Pricing

Pay per event, with platform usage included:

- **$0.00005** per Actor start (one start unit at the default 256 MB).
- **$0.002** per bank row stored in the dataset, including unchanged repeats.

Ten banks cost $0.02005 in events per run; twenty banks, the maximum, $0.04005. Not-found banks, errors, incomplete windows and the `SUMMARY` record are free; a run that delivers no rows costs only the start fee. Every run fetches fresh data and bills its rows again, even when nothing changed.

### Limits and behaviour

- One anonymous HTTPS GET per certificate to `https://api.fdic.gov/banks/financials` with a fixed query; no key, login, cookies, browser or proxy. Requests are sequential with at least 1.2 seconds between them.
- Timeouts, connection resets and 5xx responses are retried twice (2 s, then 5 s, or longer if the source asks with `Retry-After`, up to 60 s). A 403, 429, challenge page or HTML instead of JSON stops all further requests for the run without retry. Two banks in a row failing after retries also stop the run.
- Per run: 100 HTTP attempts, 4 MiB per response, 16 MiB of responses in total, 300 seconds of work.
- No paging, history backfill, company-name search or saved state between runs. Rows already stored stay valid when a later bank fails; the summary then says `partial`.
- The FDIC labels this API beta and publishes no service level or publication schedule.

### Support

Open an issue on the Actor's Issues tab. Source documentation: [FDIC BankFind API](https://api.fdic.gov/banks/docs) and its [field dictionary](https://api.fdic.gov/banks/docs/risview_properties.yaml).

# Actor input Schema

## `certificates` (type: `array`):

1 to 20 FDIC certificate numbers (CERT), as digit strings. Leading zeros and surrounding spaces are removed; duplicates are fetched and billed once. Find a bank's certificate number on FDIC BankFind.

## `periods` (type: `integer`):

How many of the newest report dates (quarters) the FDIC API currently returns to include for each bank, 1 to 20.

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

Stop after this many bank windows are stored (each one is a billed dataset item). At most one window per unique certificate is possible, so 20 is the practical maximum.

## Actor input object example

```json
{
  "certificates": [
    "3510",
    "628"
  ],
  "periods": 4,
  "maxItems": 100
}
```

# Actor output Schema

## `windows` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "certificates": [
        "3510",
        "628"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thatmike1/us-fdic-bank-financials").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 = { "certificates": [
        "3510",
        "628",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("thatmike1/us-fdic-bank-financials").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "certificates": [
    "3510",
    "628"
  ]
}' |
apify call thatmike1/us-fdic-bank-financials --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thatmike1/us-fdic-bank-financials"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/J6u2zTCbTb963VqYg/builds/6bQlS8btbTLgTxpvv/openapi.json