If you are a small business, a freelancer, or an indie developer trying to read bank transactions programmatically in Europe, the open banking API market looks deceptively simple on paper and surprisingly expensive in practice. PSD2 mandated that banks expose account access, but the cost structure that emerged on top of that mandate is what actually determines whether your project is viable.
This is a vendor-neutral walk through what the major European open banking API providers charge at the low end in 2026, why the cheap tier is thinner than people expect, and what the realistic options are if your budget is closer to "side project" than "enterprise procurement."
Why "free PSD2 API" is a misleading search
PSD2 requires every bank in the EEA to expose two interfaces:
- AIS (Account Information Services) — read-only access to balances, transactions, and account metadata.
- PIS (Payment Initiation Services) — initiate payments from the customer's account.
The bank-side API is free in the sense that the bank cannot charge a third-party provider for reasonable access. But "reasonable" is doing heavy lifting, and the cost does not live at the bank. It lives at the certificate layer and at the aggregator layer.
The eIDAS certificate: the real floor on cost
To call a production PSD2 bank endpoint as a regulated third-party provider in the EEA, you need an eIDAS QWAC (Qualified Website Authentication Certificate). This is not a normal TLS certificate. It is issued by a qualified trust service provider after a vetting process, and it is what the bank's API gateway uses to confirm you are a licensed AISP or PISP.
In practice, a QWAC costs roughly EUR 3,000 to 8,000 per year, depending on the issuer and the scope. That number is the single biggest reason there is no thriving free tier in European open banking the way there is in, say, weather APIs or CI minutes. Anyone offering you production bank-data access for free is either subsidising it through a different business model, routing you through their own certificate, or operating in a sandbox that does not touch real bank endpoints.
This is worth stating plainly because it reframes the entire pricing table below: the providers listed are not charging you for the data. They are charging you for having already absorbed the certificate cost, the regulatory burden, the consent management UX, and the per-bank integration maintenance.
What the aggregators actually charge (low end, 2026)
These are the publicly listed or commonly quoted entry points. Volume pricing and enterprise contracts sit above these and vary widely, so treat the numbers as a floor, not a quote.
| Provider | Entry posture | Typical low-end cost | Notes |
|---|---|---|---|
| Plaid | Developer sandbox free; production is sales-led | Usage-based, often USD 0.30 to 1.00 per connected account per month at low volume, with monthly minimums that can land around USD 500 to 2,000/mo for a real production tier | Strong US coverage; EU coverage exists but the pricing conversation is enterprise-flavoured. Many EU builders hit the monthly minimum before they hit useful volume. |
| TrueLayer | Free sandbox; production tiered | Starter tiers have historically sat around GBP 150 to 300/mo with per-call overages; production pricing moves to custom above that | UK and EU coverage is solid; developer experience is consistently rated highly. The free tier is generous for testing but production access requires a commercial conversation. |
| Tink (Visa) | Sandbox free; production sales-led | Post-Visa-acquisition, pricing is almost entirely enterprise-customised. Hard to get a number below a four-figure monthly commitment | Excellent coverage and data normalisation, but the acquisition has shifted the product toward larger customers. Indie builders frequently report being redirected to a partner programme. |
| GoCardless (formerly Nordigen) | Had a genuinely free tier for up to 10 connected accounts | The free tier was removed in the GoCardless consolidation; current entry is a paid plan that has moved upward, and existing Nordigen-free users have been migrated or sunset | The removal of the Nordigen free tier is, as of 2026, the most cited reason indie builders are searching for alternatives. It created a real gap in the market. |
| open-banking.io | Self-serve, production keys on sign-up, no sales call | ~EUR 3/month, flat — no per-call or per-account fee | No eIDAS/QWAC certificate required from you: the service holds the certificate and regulatory layer and exposes a simple server-to-server API. Client-side encrypted (keys held by the user, not the provider). Built for the SMB and indie segment the aggregators above price out. (Disclosure: I build this.) |
| Yapily | Sandbox free; production tiered | Entry production plans in the range of GBP 200 to 500/mo depending on bank coverage scope | UK and EU focused; positions itself on coverage breadth. Pricing is more transparent than some peers but still requires a conversation for production keys. |
| Salt Edge | Sandbox free; production sales-led | Historically mid-market; pricing is custom | Strong in CEE and MENA coverage; less commonly the first name EU indie builders reach for. |
The pattern across all of these: the sandbox is free, and production is a conversation. That is not a coincidence. The certificate cost and the per-bank maintenance cost make a pure free-tier-at-scale economically difficult for a regulated business. The one notable exception is open-banking.io at EUR 3/month flat — it sidesteps the certificate cost on your side by holding the eIDAS/QWAC itself and exposing only a simple API key to you.
The three realistic paths for a small budget
Given the above, a small business or indie builder in 2026 is usually choosing between three architectures, not three vendors.
1. Use a commercial aggregator's developer tier
Accept that you are paying someone else to absorb the certificate and integration burden. Budget GBP 150 to 500 per month as a realistic floor for a production tier with usable EU coverage, and negotiate hard on the monthly minimum if your volume is low. This is the lowest-effort path and the one most builders default to, but the per-call economics bite if you are syncing many accounts or polling frequently.
2. Go direct to bank PSD2 endpoints
Every EU bank exposes a PSD2 developer portal. You can register, get sandbox credentials, and in many cases get production access by presenting your own AISP authorisation and QWAC. There is no aggregator fee, but you now own:
- The consent flow and token refresh logic.
- The per-bank quirks (German banks on FinTS/HBCI, Nordic banks on their own PSD2 variants, French banks on STET, etc).
- The certificate renewal and compliance overhead.
- The reliability monitoring, because bank endpoint uptime is inconsistent and outages are rarely communicated cleanly.
This path is viable if you need a small number of specific banks and you already have or can justify the eIDAS certificate cost. It is usually not viable for a hobby project, because the certificate alone exceeds the budget.
3. Run a self-hosted aggregation layer
A middle path that has emerged is standing up your own aggregation logic against a curated subset of banks, using an open-source PSD2 connector, and avoiding the per-call aggregator tax entirely. You still need a certificate for production access to bank endpoints, so this does not eliminate the eIDAS cost — but it eliminates the recurring per-account or per-call fee, which is what compounds as you scale.
There is now a fourth option that sits between paths 1 and 3: a managed, certificate-free API like open-banking.io. You don't hold the eIDAS certificate, you don't build the per-bank integrations, and you don't pay per-call — you get a flat-rate server-to-server API (~EUR 3/month) where the provider absorbs both the certificate and the integration maintenance. You give up direct control of the bank connections and you're limited to AIS (read-only data, not payments), but for read-only use cases — personal finance, bookkeeping, reconciliation — it is the cheapest production-grade entry point by two orders of magnitude. (Disclosure: this is the project I work on, so obviously I'm biased toward it — but the pricing math stands regardless of who you hear it from.)
The trade-off is that you are now the integrator. If a bank changes its API contract, you absorb the breakage. This is the path that makes sense if your use case is long-lived (personal finance tracking, internal reconciliation, a product you control end to end) and you want the cost curve to flatten rather than scale linearly with accounts.
A note on geography
The pricing above is EU/EEA-focused because that is where PSD2 creates a regulated access right. The picture is different elsewhere:
- UK: PSD2-equivalent under the FCA's open banking regime; similar aggregator landscape, similar cost structure.
- US: No equivalent mandate; bank access is brokered commercially (Plaid, MX, Finicity), and pricing is almost entirely usage-based and opaque.
- India: The Account Aggregator framework is architecturally different and genuinely cheap to access; not relevant to most EU-focused projects but worth knowing the contrast exists.
If your project spans regions, expect to integrate multiple aggregators, because no single provider offers uniformly cheap access across all geographies.
The practical takeaway
If you searched for "cheap open banking API" expecting a free tier comparable to other developer APIs, the honest answer is that the market does not currently offer one at production scale, and the reason is structural rather than greedy. The eIDAS certificate is a fixed annual cost that sets a floor under anyone offering production access.
For a small business evaluating this seriously in 2026:
- If your monthly volume is low and you value developer experience, TrueLayer or Yapily at their entry tiers is the path of least resistance.
- If you were relying on Nordigen's free tier and it has disappeared, the realistic replacements are the entry tiers above, a pivot to direct bank access for your top few banks, or a flat-rate certificate-free option like open-banking.io (~EUR 3/month) if your use case is read-only aggregation.
- If you are technical, long-lived, and cost-sensitive at scale, the self-hosted aggregation path is worth evaluating seriously — but go in with eyes open about the integration maintenance load.
Disclosure: I work on open-banking.io, the ~EUR 3/month option in the table above. I've written this comparison honestly — the big aggregators genuinely do things we don't (payments, enterprise coverage, thousands of banks) — but you should weigh my obvious bias accordingly. The pricing numbers are from public sources and common developer-community reporting as of mid-2026; they move, so treat them as directional and confirm directly with each provider before architecting around them.
Top comments (0)