# FDIC Bank Data - Every US Bank, Assets & Financials (`j0401/fdic-banks`) Actor

Every FDIC-insured US bank from BankFind (public, no key, 27,835 institutions): location, charter and regulator, assets, deposits, net income, equity, return ratios, offices and holding company. Search by name, state, class or size; or total assets by state or bank class.

- **URL**: https://apify.com/j0401/fdic-banks.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 fdic institution records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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 Data - Every US Bank, Assets & Financials

Every FDIC-insured institution in the United States, straight from the FDIC's
own BankFind API. **27,835 institutions** (4,223 still operating) - where each
bank is, who regulates it, and its balance sheet.

### Low cost

**From $0.00005 per record, down to $0.00003 at Gold.** Pay only for the
records you actually receive - the whole register stays queryable, you are
never billed for the scan behind it.

### What you get

One row per institution:

- **Identity** - name, FDIC certificate number, active status
- **Where** - headquarters street, city, state, ZIP, county, and coordinates
- **Who regulates it** - chartering agent (OCC / STATE), bank class, primary
  regulator, FDIC region, and the FDIC's specialisation and MDI status
- **Financials** - total assets, domestic and total deposits, net income (annual
  and quarterly), equity, and return on assets / equity
- **Structure** - office counts (domestic and foreign), holding company and its
  ID, website, establishment date, insurance dates, and the LEI

Assets and the other money figures are in **US dollars**.

### Filter it

- **Name** - `name="First"`, `name="Trust"`.
- **Place** - `state="TX"`, `city="Austin"`.
- **Regulator** - `charterAgent="OCC"` (national) or `"STATE"`.
- **Class** - `bankClass="NM"`, `"N"`, `"SB"`.
- **Active** - `active=true` for banks still operating.
- **One bank** - `cert="628"` for JPMorgan Chase.
- **Size** - `assetMin=50000000000` for $50B and up.

### Example inputs

**Banks by name** - `name` is a substring match.

```json
{ "name": "First", "maxResults": 50 }
```

**The large banks** - $50 billion in assets and up.

```json
{ "assetMin": 50000000000, "active": true, "maxResults": 50 }
```

**One state's active banks**

```json
{ "state": "TX", "active": true, "maxResults": 100 }
```

**Where the money is** - `mode=aggregate` counts banks and sums assets per state.

```json
{ "mode": "aggregate", "groupBy": "state" }
```

### Or roll it up

Set `mode=aggregate` and get a count **and** the summed assets by **state**,
**bank class**, **active** status or **insured** status. Every group comes back,
largest first.

### Then use it

- **Market mapping** - how many banks and how much in assets, by state or class.
- **Vendor / counterparty check** - a bank's size, regulator and holding company.
- **Screen the field** - every bank above a size threshold in a state.

### Example output

**One institution** - `cert=628`:

```json
{
 "platform": "fdic-banks",
 "source": "fdic-bankfind",
 "mode": "rows",
 "groupKey": "",
 "groupCount": "",
 "groupBy": "",
 "groupAmount": "",
 "cert": "628",
 "name": "JPMorgan Chase Bank, National Association",
 "active": "1",
 "address": "1111 Polaris Pkwy",
 "city": "Columbus",
 "state": "OH",
 "stateName": "Ohio",
 "zip": "43240",
 "county": "Delaware",
 "asset": "4091315000000",
 "deposits": "2820284000000",
 "depositsDomestic": "2226790000000",
 "netIncome": "31335000000",
 "netIncomeQuarter": "17361000000",
 "roa": "1.5851712753913223",
 "roe": "18.55",
 "equity": "341580000000",
 "offices": "5402",
 "officesForeign": "5176",
 "establishedDate": "01/01/1824",
 "insuredDate": "01/01/1934",
 "updatedDate": "03/06/2025",
 "charterAgent": "OCC",
 "bankClass": "N",
 "specialization": "International Specialization",
 "holdingCompany": "JPMORGAN CHASE&CO",
 "holdingCompanyId": "1039502",
 "website": "www.jpmorganchase.com",
 "latitude": "40.142089249632",
 "longitude": "-82.996085855642",
 "insured": "1",
 "regulator": "OCC",
 "fdicRegion": "Chicago",
 "mdiStatus": "NONE",
 "trustPower": "10",
 "fedRssd": "852218",
 "lei": "7H6GLXDRUGQFU57RNE97",
 "sourceUpdatedAt": "2026-10-02"
}
```

**`mode=aggregate`, `groupBy=state`** - banks and summed assets per state:

```
TX            2,815   $1,759.6B
IL            1,925   $1,637.9B
FL            1,589   $1,001.6B
CA            1,286   $2,585.5B
OH            1,009   $6,296.5B
```

### Notes on the data, from the source

- **This is every FDIC-insured bank ever recorded**, not just today's. Only
  4,223 of the 27,835 are currently active; pass `active=true` for the operating
  set.
- **Money figures are in US dollars.** The FDIC's own API stores them in
  thousands of dollars; this actor converts to whole dollars on both the filter
  and the output, so `assetMin=50000000000` means $50 billion.
- **The register is rebuilt on the FDIC's own cycle** (roughly weekly);
  `sourceUpdatedAt` carries the index build date. It is not a real-time feed.
- **Aggregate dimensions are limited to what the source can sum on its side** -
  state, bank class, active and insured status. Other fields are available as
  filters.

# Actor input Schema

## `name` (type: `string`):

Substring match on the institution name, e.g. 'First', 'Chase', 'Trust'. Blank = any.

## `city` (type: `string`):

Substring match on the headquarters city, e.g. 'Austin', 'Columbus'. Blank = any.

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

Two-letter state code for the headquarters, e.g. 'TX', 'CA', 'NY'. Blank = any.

## `charterAgent` (type: `string`):

Chartering agent: STATE (state-chartered, 17,541), OCC (nationally chartered, 7,223) or OTS (thrift, 3,070). Blank = any.

## `bankClass` (type: `string`):

FDIC bank class: N=national member, NC=national nonmember, NM=state nonmember, NS=noninsured national, OI=other insured, SB=savings bank, SI=savings & loan, SL=savings & loan (state), SM=state savings. Blank = any.

## `active` (type: `boolean`):

true = currently operating institutions only (4,223); false = the closed/historical ones. Leave unset for both.

## `cert` (type: `string`):

Look up one institution by its FDIC certificate number, e.g. '628' (JPMorgan Chase). Exact match. Blank = any.

## `assetMin` (type: `number`):

Smallest total assets in US dollars, e.g. 50000000000 for $50 billion. Note the source stores thousands of dollars; this filter takes dollars. Blank = no lower bound.

## `assetMax` (type: `number`):

Largest total assets in US dollars. Blank = no upper bound.

## `depMin` (type: `number`):

Smallest total deposits in US dollars. Blank = no lower bound.

## `depMax` (type: `number`):

Largest total deposits in US dollars. Blank = no upper bound.

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

rows = individual institutions matching your filters (default). aggregate = count and summed assets per group (see groupBy).

## `groupBy` (type: `string`):

Which dimension to count and sum assets over (mode=aggregate). Blank = state. These four are the dimensions the source can aggregate on server-side. Every group is returned.

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

Cap the number of records pushed in rows mode (0 = default 50; up to 5,000 per run). Each record is metered individually, so there is no per-run charge cap. Aggregate mode returns every group.

## Actor input object example

```json
{
  "name": "",
  "city": "",
  "state": "",
  "charterAgent": "",
  "bankClass": "",
  "cert": "",
  "mode": "rows",
  "groupBy": "",
  "maxResults": 50
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

FDIC institution records - as JSON

## `datasetUrl` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/fdic-banks").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("j0401/fdic-banks").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 '{}' |
apify call j0401/fdic-banks --silent --output-dataset

```

## MCP server setup

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

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/CgL0DZ2VW9hrfXNLG/builds/dbncISvA6ltmZ1fk1/openapi.json