A good share of the automation requests we get in Switzerland touch a bank account sooner or later: reconciliation, payment matching, month-end reporting. And that's where projects that looked easy on paper get stuck, because bank data access here is gated: the APIs exist technically, but most SMEs can't reach them.
The typical situation (imagine a small business in Zurich: Bexio for accounting, vendors paid from a business account):
- the bank's API is "for partners only", meaning enterprise customers and licensed fintechs
- the portal exports CSVs that need manual cleanup before any tool accepts them
- the EU-style open banking interfaces stop at the Swiss border
- and nobody is going to negotiate an EBICS contract for a modest monthly vendor run
So values get copied by hand, or someone is paid to copy them, or month-end is just slow. Not because automation is hard, but because the tool for it has been kept out of reach. The banks' reasoning isn't unreasonable (security, FINMA, AML, KYC, etc). The outcome is still that most Swiss SMEs reconcile by hand in a country that prides itself on precision.
Why PostFinance is interesting
PostFinance is one of the few Swiss institutions that consistently leans the other way: published APIs, clean EBICS and ISO 20022 support, account information reachable for business customers, and documentation a non-banking engineer can actually read. It's the rare case of a bank treating its API surface as a product rather than a compliance ornament.
That changes what a small firm can reasonably ask for:
- fetch every transaction since Friday, classify them, post the matching ones to accounting, flag the rest
- when a customer pays invoice 4881, mark it paid and send the receipt
- at month-end, pull the statement, reconcile against receivables, mail a clean delta to the bookkeeper
None of this is exotic. In our projects, this kind of boring automation usually returns 6–10 hours a week to a finance team. It just needs the tool to be within reach.
The layer between the API and the SME
An open API alone doesn't close the gap: most small businesses will never write OAuth flows or ISO 20022 parsers, and they shouldn't have to. What's missing is the layer between the bank's interface and the company's actual process: pull the movements, parse and classify (AI helps where the data is messy), post to Bexio or the ERP, notify a human where needed, log every step. This is the space platforms like flow8 work in, and because the whole thing can run on the company's own infrastructure, transaction data doesn't have to traverse a third-party SaaS. For anyone thinking about banking secrecy and FINMA expectations, that detail usually matters more than the speed.
A word on safety, because money moves
Automating reads on a bank account is very different from automating payments, and the order matters. What we recommend (and follow ourselves):
- read-only first: pull, reconcile, report; months of this before anything writes
- drafts, not sends: payment drafts that require a human approval click, with both the draft and the approval logged
- dual control on anything material: two approvers, or one plus a threshold rule, configured once in the execution layer so every flow inherits it
- hard limits and alarms: per-transaction caps, daily caps, anomaly alerts (cheap to set up, priceless when something misbehaves)
It's roughly how a finance team would supervise a new employee, applied to a flow.
The point worth making
"Automation" gets discussed as if it were a single, freely available capability. It isn't: its accessibility is rationed by whoever owns the upstream API. Open APIs are an accessibility decision, not a tech detail. And an execution layer is what turns a published API into a process a non-engineer can own: on its own, a bank API is useful to a handful of integrators; behind an execution layer, it's usable by anyone who can describe their month-end in a sentence.
I'd like more Swiss banks to follow PostFinance's lead here. And if you're an SME sitting on manual reconciliation: the pieces exist, and the setup is closer to hours than months. Happy to share how we scope these, if useful!