Bank Directory API: Search 3,000+ Banks Across 63 Countries

Building a payment form? You need a bank name dropdown. Building a compliance workflow? You need to resolve banking institutions by country. Building analytics on payment corridors? You need structured bank data across markets. In every case, you need a bank directory — and maintaining one yourself is a losing proposition.

Edge's Bank Directory API gives you searchable, structured access to over 3,000 financial institutions across 63 countries. Search by bank name, filter by country, look up by BIC code, or retrieve the full directory for a given market. Every record includes the institution's name, BIC/SWIFT code, country, and address data.

Why You Need a Bank Directory API

If you have ever tried to build a bank selection dropdown for an international payment form, you already know the pain. Where do you source the data? How do you keep it current when banks merge, rebrand, or open new branches? How do you handle transliteration for banks in non-Latin markets?

The Problem with Static Bank Lists

Many fintech applications ship with a hardcoded JSON file of bank names, scraped from various sources. This approach has predictable failure modes:

• Stale data: Banks merge (Credit Suisse into UBS), rebrand (Facebook's Libra becoming Diem and then shutting down), and restructure constantly. A list that was accurate six months ago is already degrading.
• Incomplete coverage: Most static lists cover one country well and everything else poorly. Expanding to a new market means sourcing a new list, deduplicating, normalizing formats, and maintaining it forever.
• No structured identifiers: A list of bank names without BIC codes is not useful for payment routing. You need the name-to-BIC mapping to be authoritative.

The API Approach

An API-based bank directory solves these problems by decoupling your application from the data maintenance burden. You query at runtime, get current data, and never worry about stale records. When you expand to a new country, the data is already there — no new sourcing required.

What Data Is Available

Every bank record in the Edge directory includes:

Field	Description	Example
bank_name	Official institution name	BNP PARIBAS
bic	BIC/SWIFT code (8 or 11 characters)	BNPAFRPP
country_code	ISO 3166-1 alpha-2 code	FR
country_name	Full country name	France
city	City of the institution or branch	PARIS
address	Street address	16 BOULEVARD DES ITALIENS
is_head_office	Whether this is the primary office	true

This structure is consistent across all 63 supported countries, so your frontend code does not need country-specific parsing logic.

API Endpoints and Examples

The Bank Directory API supports three primary query patterns: search by country, search by bank name, and lookup by BIC.

Search Banks by Country

Retrieve all banks registered in a specific country:

curl -X GET "https://api.edge.bh/v1/banks?country=BH" \
  -H "X-Api-Key: your_api_key_here"

{
  "success": true,
  "data": [
    {
      "bank_name": "AHLI UNITED BANK B.S.C.",
      "bic": "AUBBBHBM",
      "country_code": "BH",
      "country_name": "Bahrain",
      "city": "MANAMA",
      "address": "BUILDING 2495, ROAD 2832, BLOCK 428, AL SEEF"
    },
    {
      "bank_name": "BANK OF BAHRAIN AND KUWAIT B.S.C.",
      "bic": "BBKUBHBM",
      "country_code": "BH",
      "country_name": "Bahrain",
      "city": "MANAMA",
      "address": "43 GOVERNMENT AVENUE"
    }
  ],
  "meta": {
    "total": 48,
    "country": "BH"
  },
  "credits_used": 1,
  "credits_remaining": 4950
}

Search Banks by Name

Find banks matching a name query, useful for autocomplete and search interfaces:

curl -X GET "https://api.edge.bh/v1/banks?search=deutsche&country=DE" \
  -H "X-Api-Key: your_api_key_here"

{
  "success": true,
  "data": [
    {
      "bank_name": "DEUTSCHE BANK AG",
      "bic": "DEUTDEFF",
      "country_code": "DE",
      "country_name": "Germany",
      "city": "FRANKFURT AM MAIN",
      "address": "TAUNUSANLAGE 12"
    },
    {
      "bank_name": "DEUTSCHE BANK AG",
      "bic": "DEUTDEFF500",
      "country_code": "DE",
      "country_name": "Germany",
      "city": "FRANKFURT AM MAIN",
      "address": "TAUNUSANLAGE 12",
      "branch": "BAD HOMBURG V.D. HOEHE"
    }
  ],
  "meta": {
    "total": 12,
    "search": "deutsche",
    "country": "DE"
  },
  "credits_used": 1,
  "credits_remaining": 4949
}

You can also search globally without a country filter:

curl -X GET "https://api.edge.bh/v1/banks?search=hsbc" \
  -H "X-Api-Key: your_api_key_here"

This returns HSBC entities across all countries in the directory — useful for building global bank search interfaces.

Lookup by BIC Code

For direct BIC-to-bank resolution, use the dedicated BIC/SWIFT Lookup endpoint:

curl -X GET "https://api.edge.bh/v1/bic/COBADEFF" \
  -H "X-Api-Key: your_api_key_here"

Building a Bank Selection Dropdown

One of the most common use cases is building a bank selector for payment forms. Here is a complete implementation using the Bank Directory API:

JavaScript / React Example

async function fetchBanks(country, searchQuery = "") {
  const params = new URLSearchParams({ country });
  if (searchQuery) {
    params.set("search", searchQuery);
  }

  const response = await fetch(
    `https://api.edge.bh/v1/banks?${params.toString()}`,
    {
      headers: {
        "X-Api-Key": process.env.NEXT_PUBLIC_API_KEY,
        "Content-Type": "application/json",
      },
    }
  );

  if (!response.ok) throw new Error("Failed to fetch banks");

  const result = await response.json();
  return result.data;
}

// React component with debounced search
function BankSelector({ country, onSelect }) {
  const [query, setQuery] = useState("");
  const [banks, setBanks] = useState([]);
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    const timeout = setTimeout(async () => {
      setLoading(true);
      try {
        const results = await fetchBanks(country, query);
        setBanks(results);
      } catch (err) {
        console.error("Bank search failed:", err);
      } finally {
        setLoading(false);
      }
    }, 300); // 300ms debounce

    return () => clearTimeout(timeout);
  }, [country, query]);

  return (
    <div>
      <input
        type="text"
        placeholder="Search for your bank..."
        value={query}
        onChange={(e) => setQuery(e.target.value)}
      />
      {loading ? (
        <p>Searching...</p>
      ) : (
        <ul>
          {banks.map((bank) => (
            <li key={bank.bic} onClick={() => onSelect(bank)}>
              <strong>{bank.bank_name}</strong>
              <span>{bank.bic} — {bank.city}</span>
            </li>
          ))}
        </ul>
      )}
    </div>
  );
}

Python — Populating a Payment File

For backend systems that generate payment files (MT103, ISO 20022, SEPA XML), you can resolve bank names during file generation:

import requests
import os

def get_banks_for_country(country_code: str) -> list:
    response = requests.get(
        "https://api.edge.bh/v1/banks",
        params={"country": country_code},
        headers={
            "X-Api-Key": os.environ["EDGE_API_KEY"],
            "Content-Type": "application/json",
        },
    )
    response.raise_for_status()
    return response.json()["data"]

def find_bank_by_name(name: str, country: str = None) -> list:
    params = {"search": name}
    if country:
        params["country"] = country

    response = requests.get(
        "https://api.edge.bh/v1/banks",
        params=params,
        headers={
            "X-Api-Key": os.environ["EDGE_API_KEY"],
            "Content-Type": "application/json",
        },
    )
    response.raise_for_status()
    return response.json()["data"]

# Find all Barclays entities in the UK
barclays = find_bank_by_name("barclays", "GB")
for bank in barclays:
    print(f"{bank['bank_name']} | {bank['bic']} | {bank['city']}")

Combining Bank Directory with IBAN Validation

The Bank Directory API becomes even more powerful when combined with Edge's IBAN validation. Consider a payment form where the user enters an IBAN:

1. Validate the IBAN — confirm the structure, check digit, and country format are correct.
2. Extract the country code from the IBAN (positions 1-2).
3. Look up the bank using the embedded bank code from the IBAN, or display the country's bank list for confirmation.

This gives your user a complete, verified picture of where their payment is going — before they click "Send."

async function enrichPaymentDetails(iban) {
  // Step 1: Validate the IBAN
  const ibanResult = await fetch(
    `https://api.edge.bh/v1/iban/validate/${iban}`,
    { headers: { "X-Api-Key": process.env.EDGE_API_KEY } }
  ).then((r) => r.json());

  if (!ibanResult.data.is_valid) {
    return { valid: false, error: "Invalid IBAN" };
  }

  // Step 2: Get the bank details from the IBAN's BIC
  const bic = ibanResult.data.bic;
  if (bic) {
    const bankResult = await fetch(
      `https://api.edge.bh/v1/bic/${bic}`,
      { headers: { "X-Api-Key": process.env.EDGE_API_KEY } }
    ).then((r) => r.json());

    return {
      valid: true,
      iban: ibanResult.data,
      bank: bankResult.data,
    };
  }

  return { valid: true, iban: ibanResult.data, bank: null };
}

Coverage: 63 Countries

The Edge Bank Directory covers financial institutions across the following regions:

• Europe (SEPA zone): All 36 SEPA countries including EU member states, EEA, UK, Switzerland, and Monaco. This covers the vast majority of European payment flows.
• Middle East and GCC: Bahrain, Saudi Arabia, UAE, Kuwait, Qatar, Oman, and others. Deep coverage of GCC banking institutions that are often missing from Western-centric directories.
• Asia-Pacific: Key markets including Singapore, Hong Kong, Japan, Australia, and India.
• Americas: United States, Canada, Brazil, and other major markets.
• Africa: Key financial centers including South Africa, Nigeria, Kenya, and Egypt.

For the full list of supported countries and their metadata, see the Country Data API.

Real-World Use Cases

Payment Platforms

Whether you are building a remittance app, a B2B payment platform, or a payroll system that sends to multiple countries, the bank directory powers the user-facing bank selection step. Instead of asking users to type their bank name (and misspell it), you present a searchable list filtered by their country. The result: fewer payment errors, better conversion rates, and lower support ticket volume.

KYC and Onboarding Workflows

When onboarding a new client, you collect their banking details. Showing "We found: HSBC Holdings PLC, London" after they enter their BIC code is a trust signal. It confirms your platform has institutional-grade data infrastructure, which matters when you are asking someone to trust you with their financial information.

Payment Analytics and Reporting

Fintech companies and corporate treasury teams use bank directory data to enrich their transaction analytics. Instead of seeing raw BIC codes in reports, they see "Citibank N.A., New York" — making reports readable by non-technical stakeholders. Aggregating payment volume by bank and country becomes trivial when every transaction is enriched with directory data.

Compliance and Audit Trails

Regulatory reporting often requires identifying the financial institutions involved in transactions. A bank directory lookup ensures that your audit trail includes the institution's full legal name and registered address, not just a cryptic 8-character code. This is particularly relevant for transaction monitoring under the Bank Secrecy Act (BSA), EU Anti-Money Laundering Directives, and similar frameworks.

Pricing

Each Bank Directory API call costs 1 credit, regardless of how many results are returned. Searching for all banks in Germany (100+ results) costs the same as a single-bank lookup. This makes the API cost-effective for building bank selection interfaces where you might query on every keystroke (with debouncing, of course).

Get started with free credits at app.edge.bh. No credit card required for initial testing.

Performance Considerations

For production payment forms with type-ahead search:

• Debounce API calls to 200-300ms. Do not fire a request on every keystroke.
• Cache country-level results if your user has already selected a country. The bank list for a given country changes infrequently — caching for 24 hours is safe.
• Use the search parameter server-side rather than fetching all banks and filtering client-side. The API handles the filtering efficiently.

Frequently Asked Questions

How many banks are in the directory?

The directory contains over 3,000 bank records across 63 countries. This includes head offices and major branches. Coverage varies by country — major financial centers like Germany, the UK, and France have hundreds of entries, while smaller markets may have dozens.

How often is the bank directory updated?

The directory is maintained regularly to reflect institutional changes. Bank mergers, new entrants, branch closures, and name changes are incorporated to keep the data current. This is not a static export — it is an actively maintained dataset.

Can I retrieve the entire directory for a country in one call?

Yes. Querying with just a country parameter returns all banks in that country in a single response. For countries with large banking sectors, this may return 100+ records. The call costs 1 credit regardless of the number of results.

How does the search work? Is it fuzzy or exact match?

The search parameter performs a case-insensitive partial match on the bank name. Searching for "deutsche" will match "Deutsche Bank AG", "Deutsche Postbank AG", and similar. It is not a full fuzzy search (it will not correct typos), but it is flexible enough for type-ahead interfaces where the user is refining their query as they type.

Can I combine country and name search in one call?

Yes. Passing both country=DE and search=commerz will return only German banks matching "commerz" — such as Commerzbank AG. This is the recommended pattern for payment forms where the user has already selected their country.

What is the relationship between this API and the BIC/SWIFT Lookup API?

The BIC/SWIFT Lookup API is optimized for resolving a specific, known BIC code into bank details. The Bank Directory API is optimized for searching and browsing — finding banks by name, listing banks by country, and building selection interfaces. If you already have a BIC and just need the bank name, use the BIC lookup. If you need to help users find their bank, use the directory.

---

Ready to integrate a global bank directory into your application? Sign up for Edge and start building with free credits. One API, 3,000+ banks, 63 countries.