Banq — Intelligent Bill Splitting for bunq
The Problem
When you pay a group dinner and friends reimburse you via Tikkie, your bunq account tells a misleading story: the full bill appears as an expense, and each Tikkie appears as income. Your monthly spending looks inflated, categories are
wrong, and your actual personal cost is buried in noise. There's no native way to reconcile a split bill against its reimbursements.
What We Built
Banq is an AI-powered bill splitting companion for bunq that closes this loop end-to-end — from scanning a receipt at the table to a clean, accurate monthly spending overview.
How It Works
Capture — Point your camera at any receipt. AWS Textract extracts every line item with its price in seconds. No manual entry required.
Describe — Record a short voice memo saying who ordered what. AWS Transcribe converts it to text, and Claude Sonnet 4.6 fuzzy-matches natural speech ("the chicken thing", "I had the pasta") to the exact receipt items.
Split — Claude intelligently assigns items to people, distributes tax and tip proportionally, handles shared items, and returns a structured split with each person's exact share.
Request — One click generates real bunq.me payment links for every person at the table.
Reconcile — As Tikkies come in, Banq automatically detects them in your bunq transaction history using a structured reference tag (SPLIT|TXN{id}|{person}|{amount}) embedded in each payment request. It shows you in real time who has paid and what you've actually spent.
Summarize — The monthly overview pulls your full bunq transaction history and applies footnote logic: the original bill is categorized correctly (e.g. Food & Drink), and only your actual personal share — after reimbursements — counts toward your net spend. The result is a truthful picture of your monthly finances, broken down by category, with split transactions clearly annotated.
The Core Innovation
The SPLIT|TXN tag embedded in bunq payment descriptions is the key mechanism. It creates a machine-readable back-reference that travels with the money itself — meaning no separate database, no manual reconciliation, and no ambiguity about which Tikkie belongs to which bill. The reimbursement automatically nets against the original expense in your monthly summary.
Tech Stack
┌───────────────┬─────────────────────────────────────────────────────────────────────────┐
│ │ │
├───────────────┼─────────────────────────────────────────────────────────────────────────┤
│ Banking │ bunq API — payments, accounts, Tapix categorization, sandbox simulation │
├───────────────┼─────────────────────────────────────────────────────────────────────────┤
│ AI Splitting │ Anthropic Claude Sonnet 4.6 │
├───────────────┼─────────────────────────────────────────────────────────────────────────┤
│ OCR │ AWS Textract │
├───────────────┼─────────────────────────────────────────────────────────────────────────┤
│ Transcription │ AWS Transcribe │
├───────────────┼─────────────────────────────────────────────────────────────────────────┤
│ Backend │ Python / Flask │
├───────────────┼─────────────────────────────────────────────────────────────────────────┤
│ Frontend │ Vanilla JS with bunq design language (Maven Pro, dark mode) │
└───────────────┴─────────────────────────────────────────────────────────────────────────┘
Impact
Banq turns bunq into a complete group expense manager. Every split bill is tracked, every reimbursement is reconciled, and your monthly spending summary reflects what you actually spent — not what temporarily passed through your account on behalf of others.
❯ focus on these points: ## Inspiration
## What it does
## How we built it
## Challenges we ran into
## Accomplishments that we're proud of
## What we learned
## What's next for Tikkie split
⏺ Inspiration
Every Dutch person knows the ritual: you pay the restaurant bill, send Tikkies to everyone at the table, and watch your banking app report that you somehow spent €180 on dinner this month — and received €130 in "income." bunq's monthly
insights are genuinely useful, but they have no concept of group spending. The gross bill hits your expenses, the reimbursements land as income, and the real story — you paid €50 for your own meal — is never told. We wanted bunq to
understand the difference between money that passed through your account and money you actually spent.
What it does
Banq is an AI-powered bill splitting companion built on top of bunq that handles the full lifecycle of a group expense:
- Scans receipts using your camera and OCR to extract every line item automatically
- Understands natural language — record a quick voice memo describing who ordered what, and Claude matches "the chicken thing" to the correct receipt item
- Splits the bill intelligently — assigns items per person, distributes tax and tip proportionally, handles shared dishes
- Sends real bunq payment requests with bunq.me links for each person's exact share
- Reconciles in real time — detects incoming Tikkies in your bunq history and tracks who has paid
- Fixes your monthly summary — shows your true personal spend per category, with split bills correctly netted against their reimbursements, not counted as income
How we built it
The core insight is a structured tag embedded in every payment request description: SPLIT|TXN{id}|{person}|{amount}. This tag travels with the money through bunq, so when a Tikkie lands in your account, we can automatically link it to the original expense — no manual reconciliation, no external database.
Stack:
- bunq API for payments, account history, Tapix categorization, and sandbox simulation
- Claude Sonnet 4.6 (Anthropic) for receipt-to-split AI reasoning via structured OCR + voice transcript input
- AWS Textract for receipt OCR and AWS Transcribe for voice-to-text
- Python / Flask backend with disk-persisted footnotes
- Vanilla JS frontend built to match the bunq design language — dark mode, Maven Pro, rainbow gradient bar
The monthly summary applies "footnote logic" server-side and client-side: expenses with linked reimbursements show their net personal cost, categories are assigned based on the original large transaction, and the totals reflect what
actually left your wallet.
Challenges we ran into
The reconciliation link. Getting a Tikkie payment to reliably point back to its originating expense was the hardest problem. bunq doesn't have a native concept of linked payments, so we had to encode the relationship in the payment description itself and parse it back out during account history scans.
Sandbox vs. production gaps. bunq's Tapix categorization is not active in sandbox, so we built a complete local category overlay that computes the same breakdown from raw payments — effectively reimplementing the insights layer for
development and demo.
State across server restarts. Flask's debug auto-reload clears in-memory state constantly during development. We moved footnote persistence to disk (footnotes.json) so reconciled splits survive restarts, which turned out to be important for demo reliability.
Token limits on complex receipts. Early versions of the Claude integration hit max_tokens on large receipts, silently truncating the JSON response. We raised the limit, added compact JSON instructions to the system prompt, and added an
explicit guard for the max_tokens stop reason.
Accomplishments that we're proud of
The SPLIT|TXN tagging system working end-to-end without any external database — the relationship between a bill and its reimbursements lives entirely in the bunq transaction history itself. It's simple, auditable, and requires zero infrastructure beyond what bunq already provides.
Getting Claude to reliably parse messy, real-world receipt OCR and ambiguous voice descriptions into a clean, structured split — including edge cases like shared dishes, tax distribution, and natural language like "I had the pasta and we
shared the bottle of wine" — with a single prompt.
Building a monthly summary that genuinely tells the truth about your spending, which was the original motivation for the whole project.
What we learned
bunq's API surface is much richer than it appears at first — the insights, event feed, and Tapix categorization endpoints open up a real personal finance layer that most integrations never touch. The sandbox environment is excellent for development but diverges from production in important ways (Tapix being the main one) that you only discover by reading carefully.
Claude handles ambiguous, real-world input far better than rule-based parsing would — the voice memo matching in particular would be extremely brittle with regex or keyword approaches. Giving Claude the full receipt context and the full
transcript in a single structured prompt, rather than trying to pre-process either, produced significantly better results.
What's next for Tikkie Split
- Automatic detection — hook into bunq's event feed to detect new large outgoing payments and prompt the user to split them immediately, without manual input
- Multi-bill tracking — a persistent ledger of who owes what across multiple outings with the same group of friends
- Smart recurring detection — identify bills you split regularly (weekly team lunch, shared subscriptions) and automate the split without re-scanning
- Real Tikkie API integration — replace bunq.me payment links with native Tikkie requests for a fully native payment experience
- Export to bunq Insights — push the corrected category data back into bunq so the official app reflects the true spend breakdown
Log in or sign up for Devpost to join the conversation.