tbi bank API Integration & OpenBanking Data Export — PSD2 AIS/PIS + protocol analysis
Turn tbi bank’s shopping, card activity, loan obligations, and rewards into auditable OpenData/OpenFinance outputs—delivered as authorized integration source code with reconciliation-ready APIs.
Integrate tbi bank data securely, then ship APIs you can run in production.
Our studio performs app interface analysis and authorized API integration patterns (PSD2-style access). We normalize what your backend needs: balances and transactions (AIS), payment initiation flows (OpenFinance/PIS patterns), shopping limit BNPL schedules, reward ledgers, and loan installment obligation timelines.
- Transaction ledgers across card payments, transfers, and shopping-limit installment actions.
- Account balance signals to support posting windows, reconciliation, and cashflow forecasting.
- BNPL installment structure (3/6/12) plus payment holiday states for credit and affordability reporting.
Feature modules built around tbi bank capabilities
1) AIS balances export (time-stamped snapshots)
We design an adapter that fetches balances from authorized flows and stores them as “balance_at” records, not just one current value.
Use case: reconciliation dashboards that show whether a period’s postings match the expected availability and currency context (EUR/lev, depending on the user’s setup).
2) OpenBanking transaction export (ledger normalization)
We map app-level fields into an OpenData ledger model: occurred_at, booking_date, direction, product_type, currency, and stable reference IDs suitable for idempotent re-sync.
Use case: automated ERP imports and finance BI queries (time-range filtering, category tags, and audit logs).
3) Shopping limit BNPL installment reconciliation (3/6/12)
We build a BNPL ledger view that transforms “one purchase” into installment due entries—so your downstream systems can book deferred debit, track amount due, and produce month-by-month reporting.
Use case: BNPL installment reconciliation for finance teams that need predictable fields for installment status and next due dates.
4) Cash withdrawal from shopping limit (event class modeling)
We treat this as a distinct event type in your OpenFinance mapping: it affects cashflow and obligation timelines differently than “shopping purchase installments”.
Use case: credit exposure and risk monitoring that must understand when “cash-out” increases outstanding obligations.
5) Rewards/cashback ledger sync (up to 10%)
We normalize reward events into a “rewards journal” for analytics: reward_pending → reward_available → transferred_to_neon_account, plus merchant- and category-based percentages.
Use case: merchant attribution, loyalty reporting, and finance reconciliation for cashback provisions.
6) Loan obligations + payment holiday timeline
We expose a timeline API that can power collection workflows and affordability analytics without forcing your product to parse mobile UI steps.
Use case: budgeting and risk dashboards that need next installment due plus holiday flags to adjust forecasts.
Core benefits for integration teams
Instead of treating tbi bank as a black box, we build an integration layer that makes app finance data predictable for your backend. Every capability is delivered with request/response examples, deterministic mapping rules, and a test plan for changes in authorization or UI flows.
A meaningful OpenData/OpenFinance integration requires consistency: stable IDs for dedupe, clear currency handling, and reconciliation-friendly timestamps. We implement those constraints so your systems can re-run sync jobs without double-counting.
- OpenData normalization: consistent fields for amounts, timestamps, references, and product types.
- Operational safety: retries, idempotency keys, and structured error mapping for resilient polling/ingestion.
- Auditability: consent context logs and least-data retention controls aligned with GDPR thinking.
- Source-code delivery: working implementation code and integration documentation.
API integration instructions (how we connect)
You provide the integration scope (for example: “OpenBanking transaction export” plus “shopping-limit BNPL installment reconciliation”). We map tbi bank’s authorized access steps into a consent-aware integration flow and define a clean boundary in your architecture.
Typical process: consent + session establishment → authorized retrieval (AIS-style accounts/balances/transactions) → protocol-aware normalization → API output for your analytics/accounting services. We also provide a vertical-slice “first delivery” plan so you can validate data quality early.
Your backend owns identity and stores only what it needs. Our module focuses on retrieving authorized data and producing normalized payloads with deterministic dedupe behavior.
Screenshots
Click any thumbnail to open a larger lightbox view. This helps engineering teams match the protocol analysis steps to real in-app screens for shopping limit, installments, rewards, and loan obligations.
Data inventory (OpenData perspective)
Below is a practical map of data types your engineering team can integrate first. We derive these datasets from tbi bank’s app capabilities: accounts/balances, transaction histories, shopping limit installment actions, rewards/cashback events, and loan obligation management. All integrations are designed for authorized access only.
| Data type | Source (screen/feature) | Granularity | Typical use |
|---|---|---|---|
| Account balances | Account overview, balance widgets | Timestamped balance snapshots | Cashflow forecasting, reconciliation checks, currency context |
| Transactions ledger | Card activity + transfers + shopping-limit movements | Transaction-level records, time-range export | OpenBanking transaction export, analytics, anomaly detection |
| Shopping limit BNPL schedule | Shopping limit → installment split flow (3/6/12) | Purchase-level → installment due entries | Installment reconciliation, deferred debit reporting, collections readiness |
| Cash withdrawal from shopping limit | Shopping limit → ATM cash-out option | Event class + due timeline impact | Credit exposure models, cashflow analytics, risk monitoring |
| Rewards/cashback journal | Rewards section → merchant offers and status | Per-purchase reward events + lifecycle status | Loyalty analytics, cashback provision accounting, reporting dashboards |
| Loan obligations timeline | Loans → obligations, installments, payment holiday | Next due dates + installment amounts + holiday flags | Budget planning, risk scoring, customer support automation |
BNPL and rewards are not “one number” datasets. Integration errors usually happen when the pipeline stores raw text instead of lifecycle-aware records. Our inventory focuses on stable fields and state transitions so your system can rebuild results reliably.
Typical integration scenarios (end-to-end)
Each scenario below describes a full integration story: business context, which OpenData/OpenFinance datasets are involved, and how the mapping lands in normalized fields your product can consume.
Business context: a finance team needs reliable imports for monthly closure and must match internal invoices with bank movements.
Data/API involved: tbi bank transactions ledger (card payments + transfers + shopping-limit movements) and time-window queries.
OpenData/OpenFinance mapping: output a normalized ledger (for example, `ledger.items[]`) with `occurred_at`, `booking_date`, `amount.value`, `amount.currency`, `direction`, and `reference_id`, plus a dedupe key to prevent double postings.
Business context: a consumer lending or budgeting platform must represent deferred debit accurately month-by-month.
Data/API involved: installment split actions from the shopping limit (3/6/12), plus the cash withdrawal from shopping limit feature added in 2024.
OpenData/OpenFinance mapping: transform purchase events into installment due entries (`bnpl.installments[]`) with `due_month`, `amount_due`, and `event_class` so your reporting can separate “purchase installment” from “cash-out obligation.”
Business context: a merchant analytics dashboard needs to attribute purchases and forecast reward liability.
Data/API involved: rewards status lifecycle (pending → available) and reward percent rules from the shopping section.
OpenData/OpenFinance mapping: output a rewards journal (`rewards.journal[]`) with `merchant_id`, `reward_rate`, `reward_amount`, `status`, and `available_until` to power monthly summaries and reconciliation with finance systems.
Business context: a personal finance assistant needs to adjust cashflow forecasts when “payment holiday” is requested.
Data/API involved: loan obligations timeline with installments and holiday state.
OpenData/OpenFinance mapping: output a timeline (`loans.obligations[]`) including `next_due_date`, `installment_amount`, and `holiday_flag`, so your budget engine can recalculate without manual UI scraping.
Business context: an e-commerce workflow needs to initiate a payment and track status to reduce customer support tickets.
Data/API involved: PSD2-style Payment Initiation flows (PIS patterns) with consent and payment status retrieval endpoints.
OpenData/OpenFinance mapping: output `payments.initiations[]` with `payment_id`, `status`, `status_updated_at`, and `instructed_amount`, so your order system can reconcile confirmations automatically.
Technical implementation (pseudo-code examples)
These snippets illustrate the integration depth we deliver. They do not claim that tbi bank exposes identical endpoints. Instead, they show how your backend calls our authorized integration module and receives normalized OpenData/OpenFinance payloads.
// 1) Consent-aware AIS: balances + transactions (authorized data export)
POST /integration/tbi-bank/ais:consent
Content-Type: application/json
Authorization: Bearer <CLIENT_ACCESS_TOKEN>
{
"provider": "tbi-bank",
"scopes": ["AIS:readAccounts", "AIS:readBalances", "AIS:readTransactions"],
"psu_context": {"psu_id": "user_123"},
"valid_until": "2026-12-31"
}
// Response (example)
{ "consent_id": "cns_9f2a...", "status": "AwaitingSCA", "redirect_url": "https://.../sca" }
// After SCA completes:
GET /integration/tbi-bank/ais/{consent_id}/{account_id}/balances
GET /integration/tbi-bank/ais/{consent_id}/{account_id}/transactions?from=2026-02-01&to=2026-02-29&cursor=...
// Error handling guidance:
// - On RATE_LIMIT: backoff + continue with cursor
// - On CONSENT_EXPIRED: re-run consent flow and resume from last checkpoint
// 2) Normalize shopping-limit BNPL and cash withdrawal events
// Input: normalized purchase/transaction actions retrieved from authorized retrieval
function buildBnplLedger(purchaseActions, installmentOptions){
// Dedupe key prevents double-booking across repeated sync jobs
// example: bnpl_dedupe_key = purchase_reference + event_class + installment_plan
const items = []
for (action of purchaseActions){
const plan = installmentOptions[action.installment_months] // 3/6/12
if(action.event_class === "SHOPPING_LIMIT_PURCHASE"){
items.push(...expandIntoInstallments(action, plan, "PURCHASE"))
}
if(action.event_class === "SHOPPING_LIMIT_CASH_WITHDRAWAL"){
items.push(...expandIntoInstallments(action, plan, "CASH_OUT"))
}
}
return { "bnpl.installments": items }
}
// Output record shape:
// {
// "bnpl_installment_id": "...",
// "purchase_reference": "...",
// "event_class": "PURCHASE|CASH_OUT",
// "due_month": "2026-03",
// "amount_due": {"value":"...","currency":"EUR"}
// }
// 3) OpenFinance payment initiation mapping + status polling
POST /integration/tbi-bank/pis:payments
Content-Type: application/json
{
"consent_id": "cns_9f2a...",
"instructed_amount": {"value": 120.50, "currency": "EUR"},
"creditor": {"name": "Merchant / Payee", "account_hint": "IBAN-or-alias"},
"remittance_information": "Invoice #INV-2026-001"
}
// Response:
{ "payment_id": "pay_1a2b...", "status": "Pending", "status_updated_at": "..." }
// Poll until settled, with idempotency and backoff:
GET /integration/tbi-bank/pis:payments/{payment_id}/status
// When status becomes "Completed":
// Emit event into your webhook:
// POST https://yourapp.com/webhooks/tbi-bank/payment-status
// { "payment_id":"pay_1a2b...", "status":"Completed", "settled_at":"..." }
Implementation note: we focus on deterministic mapping, strict field validation, and idempotency keys. This is what makes “transaction export OpenBanking” usable in reconciliation pipelines rather than only informative for dashboards.
Compliance & privacy
For EU-based operations involving PSD2-style data access, the integration must respect consent scopes and security expectations. In our delivery, compliance is not a document afterthought; it is implemented into how scopes are requested, how logs are stored, and how long raw extracts are retained.
Relevant regulatory references include PSD2 (Directive (EU) 2015/2366) and GDPR (Regulation (EU) 2016/679). Additionally, we align with Open Banking access patterns such as consent lifecycle management and Strong Customer Authentication (SCA) expectations.
- Scope design mapped to datasets (balances, transactions, payment initiation, and loan/BNPL objects).
- Audit trail: consent context, retrieval timestamps, and transformation hashes.
- Retention windows: keep raw extracts only as long as needed for normalization.
Data flow / architecture
Client App → Consent/session establishment → Ingestion module (protocol-aware authorized retrieval) → Normalization & validation → Storage (minimal raw + structured model) → API output for analytics/accounting.
- Token usage with renew/resume patterns to avoid sync gaps.
- Dedupe and “cursor checkpoint” storage for safe incremental exports.
- State machine logic for BNPL installment and rewards lifecycle.
Market positioning & user profile
tbi bank is a challenger bank in South-East Europe with active presence across Bulgaria, Romania, Greece (and more). Its shopping and card experience targets everyday consumers who manage balances in EUR/lev accounts, split purchases into BNPL installments (3/6/12), and use the shopping section to earn cashback (often up to 10% depending on merchant offers).
Integration relevance is strong because the shopping app shows measurable adoption: in 2024 it surpassed 300,000 users, reached about 2,000 partner retailers, and interest-free installment purchases drove nearly two-thirds of transactions under the BNPL model. For OpenData/OpenFinance products, this means consistent data patterns and frequent real-world events to validate your API behavior.
Platform focus: Android and iOS mobile apps, so integration outputs typically feed web dashboards, mobile companion services, ERP reconciliation jobs, and lending/collections workflows on the backend.
Deliverables & what you receive
We deliver a usable integration package: not only “notes”, but production-oriented assets. Your target is to ship an API or protocol implementation that your team can maintain and re-run safely.
- API specification (OpenAPI/Swagger-style) for the endpoints you request.
- Protocol & authorization flow report (consent/session establishment, scope mapping, token refresh behavior).
- Working source code for authorized AIS/Balances/Transactions and BNPL/rewards/loans normalization (Python/Node.js/Go skeletons depending on your stack).
- Automated test plan and runnable smoke tests for key flows (statement/transactions/Bnpl/rewards/loans).
- Compliance notes (scoping strategy, logging design, and retention recommendations).
- Interface documentation for developers and QA.
About our studio & contact
We are a technical service studio specializing in app interface integration and authorized API integration. Our delivery combines protocol analysis, interface refactoring, OpenData/OpenFinance mapping, and the delivery of developer-ready source code with integration documentation.
Our pricing is transparent: services start at $300. If you want a low-risk start, we can use the option “deliver first, pay upon satisfaction” for the first vertical slice.
- Target app name: tbi bank (already provided).
- Your integration requirements: AIS transaction export, shopping limit BNPL reconciliation, rewards ledger sync, and/or loan obligation timeline.
- Preferred output: JSON API, scheduled sync, and reporting/export formats.
Workflow & proposal steps
- Requirement alignment: confirm scopes (balances, transactions, BNPL schedule, rewards, loans) and success metrics.
- Protocol analysis & interface design: produce the endpoint mapping and normalization rules (typically 2–5 business days).
- Implementation & internal verification: build ingestion, dedupe, and normalized API outputs (typically 3–8 business days).
- Delivery package: API spec, source code, integration documentation, and tests (typically 1–2 business days).
- Optional regression support if the app’s protocol changes after your first deployment.
A first “vertical slice” delivery is often 5–15 business days depending on scope complexity and regulated access requirements.
FAQ
Do you integrate through official open banking endpoints?
Where official PSD2/Open Banking-style access is available, we use it with consent scopes and deliver authorized integration outputs. If a required dataset is only reachable via app protocol paths, we still frame delivery as authorized integration with clear boundaries and evidence-based mapping.
How do you prevent duplicate imports?
We implement idempotency keys and stable dedupe identifiers (based on purchase/reference/event class). We also store cursor checkpoints for incremental sync so reruns do not double-count.
Can we start with one dataset only?
Yes. Many teams start with transaction ledger + balances export to validate mapping quality, then expand to shopping-limit BNPL and rewards lifecycle once the reconciliation rules are confirmed.
Original App (collapsed): tbi bank overview and legal info
tbi bank is a mobile banking experience designed to help you shop, pay, and manage your money. Customers can open a free EUR account, make transfers, and withdraw from ATMs with no fees (per product terms). The app also lets users activate a shopping limit so they have extra funds available anytime.
- Split purchases into 3, 6, or 12 installments directly from the phone.
- Use a “switch” concept to choose whether payments come from personal funds or the shopping limit.
- Model cash withdrawal from the shopping limit as its own event class (feature added in 2024).
- Apply for a personal loan and manage obligations inside the app.
- Make installment payments and request a payment holiday when needed.
- Control your budget with obligation-aware insights.
- Shop smart inside the Shopping section with a large partner retailer list.
- Earn rewards/cashback for eligible shopping actions; rewards can be up to 10% depending on merchant offers.
- Rewards follow a lifecycle (pending, available, transfer to neon account) suitable for OpenData/OpenFinance reporting.
Note: the Greek version of the app does not yet offer all services mentioned above, but they will be available soon. For integrations, that means you should expect feature flags per region/language and design datasets with graceful fallback behavior.
TBI Bank EAD, headquarters and address for correspondence: Sofia 1421, Lozenets district, 52 - 54 Dimitar Hadjikotsev Street, e-mail: office@tbibank.bg, website: www.tbibank.bg. Registered in the Commercial Register at the Registry Agency at the Ministry of Justice with UIC 131134023, licensed as a Bank and respectively carrying out banking activity according to License No B 30 and orders RD 22 - 1067 / 13.08.2003, No RD 22 - 1067 / 12.06.2007, RD 22 - 1560 / 20.07.2007, RD 22 - 2270 / 16.11.2009, RD 22 - 0451 / 28.02.2012 and RD 22 - 0451 / 22.10.2012 of the BNB.