# FDIC Failed Bank List Scraper (`automation-lab/fdic-failed-bank-list-scraper`) Actor

Extract FDIC failed-bank records, locations, certificates, acquirers, closing dates, funds, and detail URLs from the public FDIC list.

- **URL**: https://apify.com/automation-lab/fdic-failed-bank-list-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Failed Bank List Scraper

Extract structured failed-bank resolution records from the public FDIC Failed Bank List. This actor turns the official FDIC table into clean dataset rows with bank name, city, state, FDIC certificate, acquiring institution, closing date, fund number, source URL, and optional FDIC detail URL.

### What does FDIC Failed Bank List Scraper do?

FDIC Failed Bank List Scraper collects records from the FDIC public bank failures page and exports them as structured JSON, CSV, Excel, XML, or HTML through Apify datasets.

Use it to monitor or analyze U.S. bank failures without manually copying table rows from FDIC.gov.

### Who is it for?

- 🏦 Bank analysts tracking resolution history
- ⚖️ Compliance and risk teams checking failed-bank records
- 📰 Journalists researching bank failures and acquiring institutions
- 📊 Fintech data teams enriching regulatory datasets
- 🎓 Researchers studying banking-sector stress over time

### Why use this scraper?

The FDIC page is authoritative, but the website table is not ideal for recurring workflows. This actor provides repeatable extraction, filters, API access, and export formats.

### What data can you extract?

| Field | Description |
|---|---|
| `bankName` | Failed institution name |
| `city` | Bank city |
| `state` | Bank state or territory |
| `stateCode` | Two-letter state code when known |
| `cert` | FDIC certificate number |
| `fund` | FDIC fund number |
| `acquiringInstitution` | Institution that acquired deposits/assets |
| `closingDate` | ISO closing date |
| `closingDateText` | Date as displayed by FDIC |
| `detailUrl` | FDIC detail page URL |
| `sourceUrl` | FDIC list URL used by the actor |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to extract FDIC failed bank data?

This actor uses pay-per-event pricing: a small start fee plus a per-record fee for each saved failed-bank record. Apify shows the exact price before you run the actor.

### How to run it

1. Open the actor on Apify.
2. Set the maximum number of failed-bank records.
3. Optionally add state or date filters.
4. Click **Start**.
5. Download results from the dataset tab.

### Input options

#### Maximum failed-bank records

Set `maxItems` to control how many records are saved. The default is 100 so first runs stay inexpensive.

#### States to include

Use `states` to filter to state names or abbreviations, such as `Georgia`, `CA`, or `Texas`. Leave it empty for all states.

#### Closing-date range

Use `closedFrom` and `closedTo` in `YYYY-MM-DD` format to focus on a period, for example post-2008 failures or recent resolution activity.

#### Include detail URLs

Keep `includeDetailUrls` enabled if you want the FDIC detail page URL for each failed bank.

### Example input

```json
{
  "maxItems": 100,
  "states": ["Georgia", "California"],
  "closedFrom": "2008-01-01",
  "includeDetailUrls": true
}
````

### Example output

```json
{
  "bankName": "Community Bank and Trust - West Georgia",
  "city": "LaGrange",
  "state": "Georgia",
  "stateCode": "GA",
  "cert": "25796",
  "fund": "10551",
  "acquiringInstitution": "Anchor Bank",
  "closingDate": "2026-05-01",
  "closingDateText": "May 1, 2026",
  "detailUrl": "https://www.fdic.gov/bank-failures/failed-bank-list/community-bank-and-trust-west-georgia",
  "sourceUrl": "https://www.fdic.gov/bank-failures/failed-bank-list?items_per_page=All",
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
```

### Tips for best results

- Start with the default `maxItems` before running the full historical list.
- Use state filters when building state-level market or compliance reports.
- Use date filters when comparing crisis periods or recent bank-resolution trends.
- Keep detail URLs enabled when analysts need source traceability.

### Integrations

Use the dataset export in BI tools, notebooks, compliance dashboards, or internal enrichment pipelines. Apify integrations can send the dataset to Google Sheets, webhooks, cloud storage, or downstream automation.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fdic-failed-bank-list-scraper').call({
  maxItems: 100,
  states: ['Texas'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/fdic-failed-bank-list-scraper').call(run_input={
    'maxItems': 100,
    'states': ['Texas'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~fdic-failed-bank-list-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"states":["Texas"]}'
```

### MCP usage

Connect this actor to Claude or other MCP clients through Apify MCP Server:

`https://mcp.apify.com/?tools=automation-lab/fdic-failed-bank-list-scraper`

Claude Code setup:

```bash
claude mcp add apify-fdic-failed-banks https://mcp.apify.com/?tools=automation-lab/fdic-failed-bank-list-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-fdic-failed-banks": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fdic-failed-bank-list-scraper"
    }
  }
}
```

Example prompts:

- "Extract FDIC failed banks in Georgia since 2008."
- "Get the latest 100 FDIC failed-bank records and summarize acquiring institutions."
- "Create a CSV of California failed banks with certificate numbers."

### Monitoring workflow

Schedule the actor weekly or monthly to capture newly added FDIC failures. Because the source is public and small, scheduled runs are lightweight.

### Compliance workflow

Risk teams can join the dataset against internal counterparty, branch, or institution datasets using FDIC certificate numbers and institution names.

### Journalism workflow

Reporters can filter by state and date range, then use detail URLs for source attribution in stories about bank failures and acquisitions.

### Data source

The source is the official FDIC failed bank list at FDIC.gov. The actor does not require a login and does not bypass access controls.

### Limitations

The actor extracts fields visible in the FDIC failed bank list table. It does not scrape every detail page field in this version.

### Legality

The actor collects publicly available government information from FDIC.gov. You are responsible for using the data lawfully and following applicable policies for your organization.

### Troubleshooting

#### Why did I get fewer records than expected?

Check `maxItems`, `states`, `closedFrom`, and `closedTo`. Filters are applied after the FDIC table is fetched.

#### Why is `detailUrl` missing?

Set `includeDetailUrls` to `true`. A detail URL is included when the FDIC table row provides a link.

### FAQ

#### Does this require proxies?

No. The actor uses direct HTTP requests to a public government page.

#### Can I export to CSV or Excel?

Yes. Use Apify dataset export formats after the run finishes.

#### Does it include active banks?

No. This actor focuses on failed-bank records. For active institution data, use related BankFind actors.

### Related scrapers

- https://apify.com/automation-lab/fdic-bankfind-scraper
- https://apify.com/automation-lab/cfpb-complaints-scraper

### Version

Initial version focused on the public FDIC failed bank list table.

### Support

If you need more FDIC detail-page fields, open an Apify issue with an example record and the fields you need.

# Actor input Schema

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

Maximum number of FDIC failed-bank records to save. The default is low for an inexpensive first run.

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

Optional list of state names or abbreviations, for example Georgia, CA, Texas. Leave empty to include all states.

## `closedFrom` (type: `string`):

Optional earliest closing date in YYYY-MM-DD format.

## `closedTo` (type: `string`):

Optional latest closing date in YYYY-MM-DD format.

## `includeDetailUrls` (type: `boolean`):

Add the FDIC detail page URL for each failed bank when the table provides one.

## Actor input object example

```json
{
  "maxItems": 20,
  "states": [],
  "includeDetailUrls": true
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 20,
    "states": [],
    "includeDetailUrls": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fdic-failed-bank-list-scraper").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 = {
    "maxItems": 20,
    "states": [],
    "includeDetailUrls": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fdic-failed-bank-list-scraper").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 '{
  "maxItems": 20,
  "states": [],
  "includeDetailUrls": true
}' |
apify call automation-lab/fdic-failed-bank-list-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FDIC Failed Bank List Scraper",
        "description": "Extract FDIC failed-bank records, locations, certificates, acquirers, closing dates, funds, and detail URLs from the public FDIC list.",
        "version": "0.1",
        "x-build-id": "slwQroMQV094m8MnN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fdic-failed-bank-list-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fdic-failed-bank-list-scraper",
                "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/automation-lab~fdic-failed-bank-list-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fdic-failed-bank-list-scraper",
                "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/automation-lab~fdic-failed-bank-list-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fdic-failed-bank-list-scraper",
                "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": {
                    "maxItems": {
                        "title": "Maximum failed-bank records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of FDIC failed-bank records to save. The default is low for an inexpensive first run.",
                        "default": 20
                    },
                    "states": {
                        "title": "States to include",
                        "type": "array",
                        "description": "Optional list of state names or abbreviations, for example Georgia, CA, Texas. Leave empty to include all states.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "closedFrom": {
                        "title": "Closed from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional earliest closing date in YYYY-MM-DD format."
                    },
                    "closedTo": {
                        "title": "Closed to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional latest closing date in YYYY-MM-DD format."
                    },
                    "includeDetailUrls": {
                        "title": "Include detail URLs",
                        "type": "boolean",
                        "description": "Add the FDIC detail page URL for each failed bank when the table provides one.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
