# FDIC BankFind Institutions Scraper (`knotty_mistveil/fdic-bankfind-institutions`) Actor

Every FDIC-insured US bank and savings institution from the official FDIC BankFind API: charter, address, assets, deposits, regulator, status.

- **URL**: https://apify.com/knotty_mistveil/fdic-bankfind-institutions.md
- **Developed by:** [Jason](https://apify.com/knotty_mistveil) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 institution record returneds

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 BankFind Institutions Scraper

Pulls FDIC-insured bank and savings institution records from the **FDIC BankFind Suite**, the official registry of every bank the Federal Deposit Insurance Corporation has ever chartered or insured, through the public **BankFind Suite institutions API** (`api.fdic.gov`). No API key, no account, no browser automation. You get one flat JSON record per institution with the FDIC certificate number, legal name, full address and coordinates, charter type and primary federal regulator, the most recent reported total assets, deposits, equity and net income, the ROA/ROE ratios, ownership type, trust powers, the holding company, the LEI, and the open/closed status with its established and closed dates — filtered by state, city, active status, an asset range or a name search. This is a registry snapshot, not a chronological feed: banks don't file on a date the way tenders or incorporations do, so the filters are the ones a registry search actually needs (who, where, how big, still open) rather than a date window that doesn't fit the data.

### What you get

Every record contains:

| Field | Description |
| --- | --- |
| `id` | The FDIC certificate number as a string, e.g. `"1225"` — same value as `cert`, present because every Actor in this series has an `id` |
| `source` | `fdic`, constant |
| `url` | `https://banks.data.fdic.gov/bankfind-suite/bankfind/details/{cert}` — the public institution page on FDIC's own BankFind Suite |
| `cert` | The FDIC certificate number as a number — the stable id FDIC has assigned institutions since 1934 |
| `name` | The institution's legal title |
| `address` | Street address, joining `ADDRESS` and `ADDRESS2` when a suite/floor line exists |
| `city` / `county` / `state` / `stateName` / `zip` | Location of the main office. `state` is the 2-letter USPS code |
| `established` | Date the institution began operations, ISO `YYYY-MM-DD` |
| `active` | `true` if currently open and FDIC-insured, `false` if closed |
| `closedDate` | Date the institution closed, or `null` for an active institution (FDIC's own "still open" sentinel is converted to `null`, not kept as a fake date — see *Limits and freshness*) |
| `fdicInsuredSince` | Date the institution obtained federal deposit insurance |
| `website` | The primary web address FDIC has on file from the most recent Call Report, or `null` |
| `bankClassCode` / `bankClass` | FDIC's institution-class code (`N`, `NM`, `SM`, `SB`, `SI`, `SL`, `OI`, `NC`, `NS`, `CU`) and its full label, e.g. `"Commercial bank, state charter, Fed member, supervised by the Federal Reserve"` |
| `occCharterNumber` | The OCC charter number for a nationally chartered institution, `null` for a state-chartered one |
| `fedCharter` / `stateCharter` | Whether the charter is federal or state |
| `primaryRegulatorCode` / `primaryRegulator` | `OCC`, `FDIC`, `OTS`, `STATE` or `FED`, and its full name |
| `specializationGroup` | FDIC's asset-concentration specialization, e.g. `"Commercial Lending Specialization"`, `"Mortgage Lending Specialization"` |
| `domesticOffices` / `foreignOffices` | Number of domestic and foreign offices operated |
| `totalAssetsThousands` / `totalDepositsThousands` / `equityCapitalThousands` / `netIncomeThousands` | Most recent reported financials, in **thousands of dollars** (FDIC's own unit) |
| `returnOnAssets` / `returnOnEquity` | ROA and ROE, annualized percent |
| `mutual` | `true` for a mutual (depositor-owned) institution, `false` for a stock institution |
| `trustPowersCode` / `trustPowers` | FDIC's trust-powers code and its label, e.g. `"Full trust powers granted"` |
| `deNovo` | Whether the institution was a new charter (not a recharter) as of its most recent reporting quarter |
| `latitude` / `longitude` | Coordinates of the main office |
| `lei` | The institution's Legal Entity Identifier when FDIC has one on file, `null` otherwise — cross-references this repo's own `gleif-lei-records` Actor |
| `fdicRegion` | The FDIC supervisory region assigned to the institution, e.g. `"San Francisco"` |
| `holdingCompanyRssdId` / `holdingCompanyName` | The Federal Reserve RSSD id and name of the regulatory top holding company, when one is on file |
| `metroAreaCode` | The Census/OMB Metropolitan Statistical Area code, or `"0"` when the institution is not in one |
| `financialsAsOf` | The report date the financial fields above are as of |
| `fetchedAt` | ISO timestamp of the run that produced the record |

The dataset has four views: **Overview** (name, city, state, class, active, assets, established, link), **Address and contact** (full address, coordinates, website), **Financials** (assets, deposits, equity, net income, ROA/ROE, as-of date) and **Charter and regulation** (class, charter numbers, regulator, ownership, trust powers, holding company, LEI).

### Input

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `states` | string\[] | all | Two-letter USPS codes for the institution's **main office** state, e.g. `["CA"]`, `["NY","TX"]`, or a territory (`PR`, `GU`, `VI`, `AS`, `MP`). Several codes are ORed. |
| `cities` | string\[] | all | City names, matched **exactly** as FDIC stores them — normally Title Case (`"San Francisco"`, not `"SAN FRANCISCO"` or `"san francisco"` — see *Limits and freshness*). Several cities are ORed. |
| `activeOnly` | boolean | `true` | On: only institutions currently open and insured. Off: every institution FDIC has ever chartered, including banks closed decades ago. |
| `minAssets` / `maxAssets` | integer | none | Keep only institutions whose most recent reported total assets (thousands of dollars) fall in this range, e.g. `minAssets: 1000000` for $1 billion or more. |
| `search` | string | none | Full-text, **case-insensitive** search on the institution's legal name and its prior names, e.g. `"Wells Fargo"`. |
| `maxItems` | integer | `500` | Stop after this many institutions. You are charged per record delivered, so this is also the cost cap. Results are ordered by ascending FDIC certificate number — the stable id FDIC has assigned since 1934 — so a value below the match count keeps the longest-chartered institutions and drops the newest ones. |

Bad input fails fast: an unknown state code, a negative asset value, or `minAssets` greater than `maxAssets` stops the run with the validation message as its status, before any request is made.

Example — every active bank in San Francisco with at least $100 million in assets:

```json
{ "states": ["CA"], "cities": ["San Francisco"], "activeOnly": true, "minAssets": 100000, "maxItems": 500 }
```

Example — a nationwide census of large active banks, biggest exposure first is not supported (results are CERT-ordered, not asset-ordered), but a full asset-tier pull is:

```json
{ "minAssets": 10000000, "activeOnly": true, "maxItems": 2000 }
```

Example — every bank with "Wells Fargo" anywhere in its current or former legal name:

```json
{ "search": "Wells Fargo", "activeOnly": false, "maxItems": 100 }
```

Example — the full historical register of Wyoming institutions, open and closed:

```json
{ "states": ["WY"], "activeOnly": false, "maxItems": 5000 }
```

### Output example

A real record from a live run on 28 September 2026 (`{"states": ["CA"], "activeOnly": true, "maxItems": 1}`), unedited:

```json
{
  "id": "1225",
  "source": "fdic",
  "url": "https://banks.data.fdic.gov/bankfind-suite/bankfind/details/1225",
  "cert": 1225,
  "name": "Farmers and Merchants Bank of Long Beach",
  "address": "302 Pine Ave",
  "city": "Long Beach",
  "county": "Los Angeles",
  "state": "CA",
  "stateName": "California",
  "zip": "90802",
  "established": "1907-11-20",
  "active": true,
  "closedDate": null,
  "fdicInsuredSince": "1934-01-01",
  "website": "www.fmb.com",
  "bankClassCode": "SM",
  "bankClass": "Commercial bank, state charter, Fed member, supervised by the Federal Reserve",
  "occCharterNumber": null,
  "fedCharter": false,
  "stateCharter": true,
  "primaryRegulatorCode": "FED",
  "primaryRegulator": "Federal Reserve",
  "specializationGroup": "Commercial Lending Specialization",
  "domesticOffices": 27,
  "foreignOffices": 0,
  "totalAssetsThousands": 11770092,
  "totalDepositsThousands": 8762647,
  "equityCapitalThousands": 1636093,
  "netIncomeThousands": 57419,
  "returnOnAssets": 0.9725509015843891,
  "returnOnEquity": 7.1,
  "mutual": false,
  "trustPowersCode": "10",
  "trustPowers": "Full trust powers granted",
  "deNovo": false,
  "latitude": 33.770751009588,
  "longitude": -118.192102973439,
  "lei": "25490049RRVB8S6CG210",
  "fdicRegion": "San Francisco",
  "holdingCompanyRssdId": "3649950",
  "holdingCompanyName": "PALOMAR ENTERPRISES LLC",
  "metroAreaCode": "31080",
  "financialsAsOf": "2026-06-30",
  "fetchedAt": "2026-09-28T03:01:52.221Z"
}
```

A closed institution from the same source looks the same but carries `"active": false` and a real `closedDate` (for example The Hibernia Bank, CERT 10783, `"closedDate": "1988-08-21"`, `"website": null`, `"lei": null`). A mutual savings bank carries `"mutual": true` and typically `"holdingCompanyName": null` (mutuals rarely have one). A federally chartered thrift such as Axos Bank (CERT 35546) carries `"fedCharter": true`, `"occCharterNumber": "716456"` and `"primaryRegulatorCode": "OCC"`.

Every run also writes a `SUMMARY` record to the key-value store with the filters used, how many institutions FDIC matched, the number of API requests and pages, and the `windowExhausted` completeness flag described below.

### Pricing

Pay per result: **US$0.0015 per institution record delivered** (US$1.50 per 1,000 records). You are charged only for records pushed to the dataset; a run that returns nothing, or that fails validation before its first request, costs nothing. Runs on the Apify free plan are limited by the platform's free-tier usage allowance.

### Data source and licence

- **Source.** `GET https://api.fdic.gov/banks/institutions`, the FDIC BankFind Suite API operated by the Federal Deposit Insurance Corporation. Documentation: <https://api.fdic.gov/banks/docs> (Swagger UI; read 28 September 2026) and the API's own field catalogue at <https://api.fdic.gov/banks/docs/institutions_definitions.csv>, which this Actor's field labels and code lookups (`bankClass`, `trustPowers`, `primaryRegulator`) are transcribed from verbatim. `banks.data.fdic.gov`, the older host, now 301-redirects to `api.fdic.gov`; this Actor calls `api.fdic.gov` directly. No key or account is required: the docs state "Users are currently not required to register and obtain a unique 'key' to use with every query submitted to our API" (read 28 September 2026), and every request in this Actor's testing and its smoke test succeeded unauthenticated.
- **Licence.** FDIC is an independent US federal agency; data it produces in the course of official duties is a US Government work and is not subject to domestic copyright (17 U.S.C. § 105) — the same basis this repository already uses for `nppes-npi-registry`, `federal-register-documents` and `usaspending-federal-awards`. FDIC's own **Content and Copyright** notice states this in plain language: "Information that is created by or for the US government on this site is within the public domain" and "Public domain information ... may be freely distributed and copied", asking only that "FDIC be given appropriate acknowledgment" (<https://archive.fdic.gov/Content%20and%20Copyright>, read 28 September 2026). FDIC's **Open Data** page separately states the agency is "committed to promoting transparency, public engagement, and evidence-based decision-making by offering free public access to high-value datasets in machine-readable formats" (<https://www.fdic.gov/about/open-data-fdic>, read 28 September 2026). Neither page is a page written specifically for the BankFind API, and FDIC's general **Website Policies** page (<https://www.fdic.gov/about/website-policies>) does not itself restate the public-domain language — so this Actor relies on the statutory basis (17 U.S.C. § 105) as the primary authority, with the archive.fdic.gov notice and the Open Data page as FDIC's own corroborating statements. Confidence is high but not a verbatim BankFind-specific licence grant; flag this to a human before publishing if a stricter citation is required.
- **Attribution.** No specific wording is mandated; FDIC only asks for "appropriate acknowledgment". Cite it as "Source: FDIC BankFind Suite" and link to the institution page.
- **Not investment or safety-and-soundness advice.** `totalAssetsThousands`, `returnOnAssets`, `returnOnEquity` and the other financial fields are self-reported Call Report figures as of `financialsAsOf`; they are not a current, audited or forward-looking assessment of an institution's health.
- **Personal data.** This dataset is about institutions, not individuals — there are no officer, employee or customer names in the `institutions` endpoint. `holdingCompanyName` is a corporate entity, not a person, in every record sampled while building this Actor.

### Limits and freshness

- **Volumes, measured 28 September 2026** against the live API: **27,834** institutions in the table overall (every bank FDIC has ever chartered or insured), of which **4,231** are currently active. By state: California 1,286 total / 116 active; Wyoming 24 active; the territories: Puerto Rico 40, Guam 5, US Virgin Islands 7, American Samoa 1, Northern Mariana Islands 0.
- **No deep-pagination wall, unlike this repo's other registry Actors.** GLEIF refuses paging past 10,000 records per query and NPPES caps a single query at 1,200; FDIC's `offset` parameter has no such ceiling. `offset=100000` on the full ~27,800-row table — far past the end — still answered HTTP 200 with an empty `data` array (verified 28 September 2026), so this Actor pages by plain ascending-`offset`/500-row pages with no re-anchoring or query-splitting logic, and `SUMMARY.windowExhausted` is `true` whenever FDIC's own matched count was fully read.
- **`limit` is capped at 10,000 per request** — `limit=10001` answers HTTP 400 "Number must be less than or equal to 10000" (verified 28 September 2026). This Actor requests 500 rows a page, well under that ceiling.
- **Rate limits: none documented.** The docs page only discusses the optional API key, not a request rate. **Measured 28 September 2026:** 15 consecutive unpaced requests all returned HTTP 200 in about 7.5 seconds (roughly 2 requests/second). This Actor still paces itself to no faster than one request per 300 ms, and `fetchWithRetry` retries 429 and 5xx responses with exponential back-off.
- **Speed, measured 28 September 2026** on this machine: the default run (500 active institutions nationwide) completed in **1.3 s in a single API request**; 2,000 institutions took **2.9 s across 4 requests** (roughly 700 records/second, dominated by the ~0.7 s per 500-row page rather than the 300 ms pacing floor).
- **`filters=` is exact-match on `CITY`; `search=` is full-text.** `filters=CITY:"San Francisco"` matched 80 institutions; the identically-typed but lower-cased `filters=CITY:"san francisco"` matched **zero** (verified 28 September 2026) — `CITY` is a keyword field there, not analyzed text. The `search=CITY:"..."` and `search=NAME:"..."` parameters, by contrast, are case-insensitive and tokenized (`search=NAME:wells` matched `"Wells Fargo Bank, National Association"`). This Actor's `cities` input therefore needs FDIC's own casing (normally Title Case); its `search` input does not, because it is routed through `search=NAME:"..."` instead. `states`/`STALP` and the `ASSET` range are unaffected by this distinction — FDIC uppercases state codes internally and `ASSET` is numeric.
- **FDIC's `search=` parameter does not support `OR`, even between two different fields** — `search=NAME:Wells OR NAME:Chase` and even `search=CITY:"x" OR NAME:"y"` both answered zero matches in testing on 28 September 2026, while the equivalent `AND` worked correctly and `filters=STALP:(CA OR NY)` (a different parameter) ORs cleanly. Because of this, `search` here is a single free-text term, not a list — for multiple states or cities, use `states`/`cities`, which go through `filters=` and OR correctly.
- **`ENDEFYMD`'s `12/31/9999` sentinel.** FDIC marks an institution that has not closed with the literal date `12/31/9999` rather than a null value; this Actor converts that sentinel to `closedDate: null` rather than publishing a fictitious year-9999 date.
- **Freshness.** `financialsAsOf` reflects each institution's most recent Call Report on file — `"2026-06-30"` for an active bank in this Actor's live testing on 28 September 2026, meaning about a one-quarter lag, which is normal for Call Report data. A closed institution's `financialsAsOf` is frozen at its last report before closing (for example The Hibernia Bank, closed 1988, reports `"1988-06-30"`). The institution roster itself (openings, closings, name and address changes) is FDIC's operational system of record and reflects structural changes as FDIC processes them, not on a fixed daily/weekly cadence that could be measured from outside.
- **Every filter is applied by FDIC, not after the fact.** States, cities, active status and the asset range are sent as `filters=` query-string clauses and the name search as `search=`, so `SUMMARY.matched` is FDIC's own count of the full result set and you are never charged for a record the Actor fetched and discarded. `SUMMARY.windowExhausted` is `true` only when every matched record was actually delivered; `maxItems`, the request safety limit, or the Apify spend limit each set it to `false` and the run log names which one.

### Use cases

- **Bank and thrift lead lists for financial-services vendors.** Filter by state, city and an asset floor to build a call list of banks in a target market, each already carrying its charter type, primary regulator, holding company and website.
- **Market-structure and competition research.** A full state or nationwide pull with `activeOnly: false` reconstructs the historical roster of who chartered, merged or failed, with `established` and `closedDate` on every record; cross-reference `lei` against this repo's `gleif-lei-records` Actor for the wider corporate-family picture.
- **Counterparty and vendor due diligence.** Confirm an institution's FDIC-insured status, charter type, primary federal regulator and current asset size before onboarding it as a banking partner or reviewing a lending relationship.

### Support

Open an issue on the Actor's Issues tab on Apify Store. Replies within 14 days. Bug reports that name the run id and the input used are fixed fastest.

# Actor input Schema

## `states` (type: `array`):

Two-letter USPS codes for the institution's MAIN OFFICE state, e.g. CA, NY, TX, or a territory (PR, GU, VI, AS, MP). Several codes are ORed. Empty = every state.

## `cities` (type: `array`):

City names, matched EXACTLY as FDIC stores them - normally Title Case, e.g. "San Francisco", "New York" ("SAN FRANCISCO" or "san francisco" will match nothing; verified 28 September 2026). Several cities are ORed. Empty = every city.

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

On: only institutions currently open and FDIC-insured (ACTIVE=1). Off: every institution FDIC has ever chartered or insured, including banks closed decades ago. Of the roughly 27,800 institutions in the table, about 4,200 are currently active (measured 28 September 2026).

## `minAssets` (type: `integer`):

Keep only institutions whose most recent reported total assets (ASSET, in thousands of dollars) are at least this much, e.g. 1000000 for $1 billion or more. Empty = no minimum.

## `maxAssets` (type: `integer`):

Keep only institutions whose most recent reported total assets (ASSET, in thousands of dollars) are at most this much. Empty = no maximum.

## `search` (type: `string`):

Full-text search on the institution's legal name and its prior names, case-insensitive, e.g. "Wells Fargo" or "Community Bank". Unlike Cities, this IS case-insensitive because FDIC serves it through a different, analyzed search field. Empty = no name filter.

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

Stop after this many institutions. You are charged per record delivered, so this is also the cost cap. Results are ordered by ascending FDIC certificate number (CERT), the stable id FDIC has assigned institutions since 1934, so a value below the match count keeps the longest-chartered institutions and drops the newest ones.

## Actor input object example

```json
{
  "states": [],
  "cities": [],
  "activeOnly": true,
  "maxItems": 500
}
```

# Actor output Schema

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

All institution records returned by the run, one JSON object each. Append ?format=csv or ?format=xlsx to download a spreadsheet.

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

Counts, the filters used, how many institutions FDIC matched, the API requests spent and the completeness flag, written at the end of the run.

# 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 = {
    "states": [],
    "cities": [],
    "activeOnly": true,
    "search": "",
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("knotty_mistveil/fdic-bankfind-institutions").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 = {
    "states": [],
    "cities": [],
    "activeOnly": True,
    "search": "",
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("knotty_mistveil/fdic-bankfind-institutions").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 '{
  "states": [],
  "cities": [],
  "activeOnly": true,
  "search": "",
  "maxItems": 500
}' |
apify call knotty_mistveil/fdic-bankfind-institutions --silent --output-dataset

```

## MCP server setup

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

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/0wHbAshRBmZoqFHgf/builds/YbxGKFB0eqSptNDkD/openapi.json