Contact us
/// Pay · Whitelabel Banking Software

One platform. Any app you can imagine.

Protocore Pay is whitelabel banking software — ledger, accounts, KYC, cards — with an app layer that becomes whatever product you design. Halcyon, Lumen, Fern, Volt, and Meridian, shown below, are five example directions of infinitely many. Yours is built for your brand and your users.

Contact usAll products
1
Whitelabel platform
Any
Design language · feature mix
IBAN
Accounts + cards
5
Example app directions
/// 01

The core does the banking

Ledger, accounts with IBANs, KYC, and card issuing sit in one platform. Client apps talk to the core; they never reimplement it. That is why the example apps below can disagree about everything visible and agree about every balance.

  • [ 01 ]Double-entry ledger under every account and card
  • [ 02 ]IBAN accounts, physical and virtual cards
  • [ 03 ]KYC and onboarding as core flows, skinned per app
/// 02

The app layer takes any shape

The app layer is genuinely open: any design language, any feature mix, any audience. The five directions shown here demonstrate it — Halcyon is light and clean, Lumen a super-app, Fern puts transfers first, Volt is ultra-dark and minimal, Meridian a travel card app in deep petrol dark — five of infinitely many. Your app starts from your brand, not from one of ours.

  • [ 01 ]P2P and chat payments, payment links, and groups
  • [ 02 ]Payroll and B2B batch payouts
  • [ 03 ]Subscriptions control and salary sorting as modules
  • [ 04 ]Team cards with per-card controls
/// 03

The console behind every app

Whatever the front end looks like, operations run through the same back office: customer 360s, transactions across every rail, card controls, payment links, and insights. Every privileged action is reason-required and audited. The console ships with the platform — and is also available as its own product, Protocore Center.

/// 04

Whitelabel without the compromise

Most whitelabel banking means your logo on someone else's app. Protocore Pay means your app on our core: your designers own every screen, your product team owns the feature mix, and the platform underneath is already running in production demos you can walk through today.

/// Features
Identity check — verification runs before the first euro moves.
/// 01

KYC & onboarding

Verification runs before the first euro moves. The app frames the document, walks the identity steps, and unblocks the account when checks pass. Onboarding is a core flow, skinned per app — each whitelabel renders its own version of the same steps, and the resulting tier follows the customer into the operator console. Shown in the platform reference app, the neutral Protocore-branded build every whitelabel starts from.

  • [ 01 ]Document capture and identity steps in the app
  • [ 02 ]Tiering decided in the core, rendered per front end
  • [ 03 ]KYC status visible to operators in User 360
Six digits to a masked number — resend on a countdown, not on demand.
/// 02

OTP verification

Sensitive steps ask for a one-time code. The demo sends six digits to a masked +40 number, with three already entered and resend waiting on a 24-second countdown. Codes gate sign-in and risky changes — not every tap.

Face ID first, PIN as the fallback — the app opens to its owner.
/// 03

Biometric unlock

The app opens with Face ID and falls back to PIN. Biometrics gate the app, card reveals, and privacy changes. The device does the matching; the platform only sees the result.

A payment sent as a message — settled on the same ledger as every other transfer.
/// 04

Chat payments

Money moves inside the conversation. A payment is a message: composed in the thread, confirmed in the thread, and posted on the core ledger like any other transfer. Shown here in Lumen, one of the example directions — the module drops into any app you design on the platform.

€120.00 sent, €75.00 requested — Pay and Decline live in the bubble.
/// 05

Requests in the thread

A request is a message with buttons. In the demo thread, €120.00 goes out as a message and a €75.00 request waits in the bubble with Pay and Decline. Accepting settles on the core ledger the same second. Shown in the platform reference app.

One person, both directions — 14 transactions, +€340.00 in, −€195.00 out.
/// 06

Contact profiles

Every contact has a money page. The demo profile shows both directions between two people — 14 transactions, €340.00 received, €195.00 sent — with Send and Request one tap away and the shared history underneath. The relationship is the unit, not the transaction.

A request composed as a link — share it anywhere, settle to the ledger.
/// 07

Payment links

Request money with a link. The payer opens it and pays; the amount settles to the ledger with no app install on their side. Links carry state — active, paid, expired — and the operator console runs a full back office over them: 214 links in the demo, each with its settlement transfer attached. Shown here in Halcyon, one of the example directions.

€395.00 awaiting, €1,240.00 collected in 30 days — links run like a business.
/// 08

The payment-links hub

Users run their links like a small business. The hub carries a personal pay.protocore.io/@handle page with an on-off switch, €395.00 awaiting across three open links, and €1,240.00 collected in thirty days. Links filter by awaiting, paid, and cancelled; reusable any-amount links expire on schedule.

Status, note, reference 9F21-0716 — and the receipt as a PDF.
/// 09

Transaction detail & receipts

Every transaction opens into a full record: status, category, note, sender, receiver, and reference 9F21-0716 in the demo. The receipt downloads as a PDF. What the customer sees is the same ledger entry the operator sees in the console — one record, two views.

€312.40 of €2,000 used — limit, PIN, and terminate on one screen.
/// 10

Card controls

Limits and controls live next to the card, not in a support queue. The demo card shows €312.40 spent of a €2,000 monthly limit, payments above €250 confirmed by SMS, and change PIN, rename, replace, and terminate one tap deep. Shown in the platform reference app; Lumen renders the same controls in its own skin.

  • [ 01 ]Per-card monthly limits with SMS step-up above them
  • [ 02 ]Freeze, rename, change PIN in place
  • [ 03 ]Terminate is a user action, not a ticket
Face ID to show, auto-hide in 30 seconds — and no screenshots.
/// 11

Secure card reveal

Full card details stay masked until the user proves presence. Reveal requires Face ID, details auto-hide after 30 seconds, and screenshots are disabled while they are visible. Number, expiry, and CVV copy individually — the whole card never sits exposed on screen.

€38.97 a month under control — one price rise flagged, one merchant the card declines.
/// 12

Subscriptions control

Recurring charges become a single controlled list — €38.97 a month in the demo. A price rise is flagged the moment it lands (GymFlex, up to €24.99), a likely duplicate service is pointed out, and an unwanted merchant is blocked at the card instead of begged by email. Shown here in Lumen, one of the example directions.

  • [ 01 ]Recurring spend as one monthly total
  • [ 02 ]Price rises and duplicates flagged automatically
  • [ 03 ]Block a merchant at the card, not by cancellation email
A €2,000 team budget, €500 per card — and a €500 to €700 raise waiting on approval.
/// 13

Team cards

A business issues cards to its team against a shared budget with per-card limits — €2,000 a month across the demo team with €1,240 of it used, €500 per card, spend bars per employee. When someone needs more, the request travels in the flow: a €500 to €700 limit raise waits on an approver, who decides in place. Shown here in Volt, one of the example directions.

  • [ 01 ]One monthly budget, per-card limits underneath
  • [ 02 ]Spend visible per employee as it happens
  • [ 03 ]Limit raises requested and approved in the flow
One batch, a whole team paid — payroll from the same accounts as everything else.
/// 14

Payroll & B2B payouts

The same accounts that pay a friend pay a team. Batch payouts run payroll and B2B disbursements from a business account as SEPA credit transfers — one batch, many recipients, every leg posted on the ledger individually. Shown here in Fern, one of the example directions.

GBP first, EUR as fallback — the card picks the right balance at the till.
/// 15

Multi-currency accounts

One customer holds more than one balance. In Meridian, one of the example directions, a EUR main account sits beside a GBP travel balance, each with its own ledger view and its own history. Abroad, the card pays from GBP first and falls back to EUR when it runs low — the London trip in the demo comes to £17.00 plus €38.60 across three payments.

Money, security, and limits in one feed — grouped by day, read state kept.
/// 16

Notifications

One feed carries money, security, and product. The demo shows a €1,250.00 salary landing, a new sign-in alert, a card payment, a referral reward, a card added to Apple Wallet, an expired request, and a prompt to finish verification and unlock €5,000 a day. Grouped by day, read state tracked, delivered by push and in-app.

Code AION-4K — six joined, two pending, €60 earned, every reward on the ledger.
/// 17

Referral program

Growth is built in, not bolted on. Each user gets a code — AION-4K in the demo — a QR, and a share sheet; the hub counts six joined, two pending, and €60 earned. Rewards post to the ledger like any other credit, and the console tracks the program from the other side.

Full-screen product moments — twelve perks told like a story, not a changelog.
/// 18

Stories & engagement

Product moments ship as full-screen stories. The demo announces a Plus tier with twelve perks — higher limits, free cards, 2% back on card payments — behind story progress bars and a single call to action. Stories are content: managed per tenant and targeted from the console's campaigns, no app release required.

Discoverable on your terms — 15 minutes at a time if that's all you want.
/// 19

Privacy controls

Users decide how findable they are. Discoverability by phone number is a switch, a temporary window opens for 15 minutes when two people need to connect, and balances hide on demand for over-the-shoulder moments. Biometric login toggles on the same screen — privacy is a setting, not a support ticket.

User 360 — a €2,458 balance, €38.4k lifetime flow, two cards, 184 transactions, one screen.
/// 20

The operator console

Every app on the platform ships with the same back office. User 360 puts one customer's balances, cards, devices, KYC tier, and 184 transactions on a single screen; the transactions view runs 4,912 rows across every rail. Every privileged action requires a written reason and lands in the audit log. The console is also available as its own product — Protocore Center.

  • [ 01 ]User 360 — one customer, complete
  • [ 02 ]Every rail in one transactions list, 4,912 rows deep
  • [ 03 ]Reason-required actions, immutable audit log
14 campaigns — matched audience, delivery funnel, and failures counted per row.
/// 21

In-app campaigns

Operators run in-app messaging without a release. The demo lists 14 campaigns across fullscreen, banner, and card formats, each row carrying its matched audience and delivery funnel — one sent campaign matched 8,412 users with 8.1k delivered and 5.2k read, and the 18 failures are counted, not hidden. Campaigns send, schedule, activate, and deactivate from the console.

48 credits, two awaiting co-sign — operator, reason, and balance delta on every row.
/// 22

Manual credits with approval

Money is never typed into existence casually. Every manual credit records operator, time, amount, reason, and the before-and-after balance; the demo queue holds 48 credits with two awaiting a co-sign. A €500.00 goodwill credit waits on a second operator, a €40.00 fee reversal sits executed, and a €15.00 promo adjustment stands rejected — every decision on the record.

€1,000.00 above the threshold — a second operator signs before it posts.
/// 23

Funding a user

Funding a real balance states its blast radius first. The demo issues €1,000.00 — above the €500 single-operator threshold — so the request routes to a second operator and executes only after approval. The dialog shows the balance moving from €2,458.30 to €3,458.30, demands a written reason the approver reads, and the audit log keeps all of it.

/// And more

P2P by @handle or IBAN

Send to a person, not an account number. Recipients resolve by @handle or IBAN, each with their own receiving currency — the demo sends €120.00 to @andrei instantly and free.

Groups & settle-up

Shared expenses get a shared ledger. The demo group — a Cluj trip, €480 across four members — tracks who is up and who owes, sends reminders to the ones who owe, and closes with one Settle up instead of four separate transfers.

Unified history

One list holds every rail. The demo history mixes a €1,250.00 salary, a P2P send, and card payments — grouped by day, with search and filters in the header. A declined charge keeps its decline reason inline instead of disappearing.

Salary sorter

Incoming pay splits itself. A salary arrives and the sorter routes it across sub-accounts by rules the user set once — rent here, savings there, the rest to daily spending. No payday ritual, no manual transfers.

Standing orders & scheduled payments

Payments can recur. Standing orders repeat a transfer on a schedule; scheduled sends move one payment to a future date. Both post as ordinary ledger transactions, both cancel from the screen that created them, and both show up in history like everything else.

Statements & exports

Every account produces statements. Monthly PDFs for people, CSV exports for accountants, and a PDF receipt on any single transaction. Operators export filtered console views the same way — what you can see, you can take with you.

Limits per KYC tier

Limits follow verification. Each tier carries its own daily and monthly caps, and the app tells users exactly what the next step unlocks — the demo prompt reads €5,000 a day. Operators see the tier, the limits, and the headroom in User 360.

Device management

Sessions are visible and revocable. A new sign-in raises a notification the moment it happens; users review their devices and end any session remotely. Trusted devices carry biometric unlock; new ones start from full verification.

Screening workflows

The platform ships hooks for sanctions and AML screening workflows. Events fire at onboarding and on transactions and route to the screening provider you choose; hits open cases for human review, and every operator decision is reason-required and logged. You set the policy — the platform carries the workflow.

Refunds, reversals & disputes

Edge cases have paths. Reversals release authorization holds before settlement; refunds post after it as counter-entries that reference the original transaction. Failed top-ups reconcile through the console, and revoking a payment link is not a refund — the back office keeps the difference explicit. Nothing is deleted; the ledger only ever adds.

APIs, webhooks & sandbox

Everything the apps do runs through the platform API, and the same surface is yours. Webhooks push transaction, KYC, card, and payment-link events to your systems; a sandbox tenant with seeded test data lets your team integrate end to end before a single real euro moves.

Localization & accessibility

The app layer ships multi-language, with copy, numbers, dates, and currency formats localized per market. Screens carry labeled controls, contrast-checked palettes, and screen-reader order — the whitelabel you ship starts from an accessible baseline instead of retrofitting one.

Theming & the whitelabel pipeline

Whitelabel is a pipeline, not a paint job. Design tokens, typography, components, and feature mix configure per tenant and build into your branded app — Halcyon, Lumen, Fern, Volt, and Meridian came out of the same pipeline, five example directions of infinitely many. Your designers own every screen; the core underneath never forks.

Feature flags per tenant

Every module is a switch. Chat payments, stories, referrals, groups, team cards — each turns on per tenant, and flags roll out to slices of users before going wide. Operators flip them from the console's config panel, not from a deploy.

Ops & SLAs

The back office is built for the on-call reality. Breakers pause a provider without a deploy, error queues and webhook logs surface failures as they happen, and reconciliation tracks every rail. Uptime and support terms are agreed per contract — the tooling to honor them ships with the platform.

/// In the product
/// Example 01 · Halcyon
Halcyon — one example direction, light and clean: a €75.00 request as a link, shared anywhere.
/// Example 02 · Lumen
  • Lumen — one example direction: an indigo super-app.
  • Card controls — freeze, toggles, and €312.40 of €2,000 spent, all on one screen.
  • Chat payments — money moves inside the conversation.
  • Subscriptions — €38.97 a month, a price rise flagged, one service the card declines.
/// Example 03 · Fern
Fern — one example direction: transfers first, for people who mostly send.
Recipients — @handle or bank account, each contact in their own currency.
Payroll — six people, €9,600.00, one batch from the business account.
/// Example 04 · Volt
  • Volt — one example direction: an ultra-dark, minimal money app.
  • Pay — €120.00 to @andrei, instant and no fee, straight from Daily.
  • Groups — the Cluj trip, €480 across four members, one Settle up.
  • Team cards — a €2,000 budget, €500 per card, a €200 raise waiting on your approval.
/// Example 05 · Meridian
Meridian — one example direction, deep petrol dark: the card picks the right account at the till.
/// The platform app
  • Identity check — three steps before the first euro moves.
  • OTP — six digits to a masked number, resend on a countdown.
  • Biometric unlock — Face ID first, PIN as the fallback.
  • Chat thread — €120.00 sent, €75.00 requested, Pay and Decline in the bubble.
  • Contact profile — 14 transactions, +€340.00 in, €195.00 out.
  • Payment links hub — €395.00 awaiting, €1,240.00 collected in 30 days.
  • Transaction detail — status, note, reference 9F21-0716, receipt as PDF.
  • Card settings — €312.40 of €2,000 used, PIN and terminate one tap deep.
  • Secure reveal — Face ID to show, auto-hide in 30 seconds, no screenshots.
  • Notifications — money, security and limits in one feed, unread on top.
  • Referrals — code AION-4K, six joined, two pending, €60 earned.
  • Stories — full-screen product moments, twelve perks told like a story.
  • Privacy controls — discoverable on your terms, 15 minutes at a time if you like.
/// The operator console
  • User 360 — one customer, every balance, card, and transaction in view.
  • Payment links back office — 214 links, and revoke is not a refund.
  • Campaigns — 14 in-app campaigns, audience and delivery funnel per row.
  • Manual credits — every euro reason-required, co-signed, and audited.
  • Fund a user — €1,000.00 needs a second operator; the reason is logged.
/// FAQ

The platform, answered.

  • Those are two separate things — the software, and the regulated permissions to hold money and issue cards. Protocore Pay is the software: the ledger, accounts, and cards. The service runs under permissions that are yours — your own, a sponsor's, or a partner's — an arrangement that sits alongside the software, not inside it, and we build for either path.

  • One platform, one app layer. Halcyon, Lumen, Fern, Volt, and Meridian are five example directions built on the same core — not five products. They disagree about every screen and agree about every balance; yours is a sixth, designed for your brand.

  • Because the client apps talk to the core, they never reimplement it. Ledger, accounts, KYC, and card issuing live in the platform; the app decides only what to show and how. That is why a light, clean app and an ultra-dark minimal one can run on identical plumbing.

  • You do. Protocore Pay is software we build and license: the app ships under your brand, and the accounts and cards run under your permissions. We build the product; the program is yours.

  • The operator console — customer 360s, transactions across every rail, card controls, payment links — with every privileged action reason-required and audited. It ships with the platform, and is also its own product, Protocore Center.

  • That is the point. The app layer starts from your brand and your feature mix, not from one of the demo apps. Most whitelabel banking is your logo on someone else's app; here it is your app on our core.

/// Pricing

How Protocore Pay is engaged.

[ 01 ]

Platform license

Run the core yourself under a software license — ledger, accounts, and cards. Scope follows the modules you switch on and the scale you run at, not a per-seat count.

[ 02 ]

Build & host

We shape the app layer to your brand and run the software for you — hosting, releases, monitoring — while the service stays yours. What moves the engagement is how much of the product we build and which rails you enable.

[ 03 ]

Revenue-share

For programs starting from zero, an engagement that scales with the payments moving through the platform instead of an upfront license.

Whichever model fits, cost tracks scale and surface area — active accounts, the modules you enable, and how much of the app layer we build. Licensed as software, scoped one program at a time.

/// Evaluate

Put Protocore Pay in your hands.

[ 01 ]

Guided demo walkthrough

We walk you through the live apps and the operator console end to end — the five example directions and the platform reference build — on a call shaped around what you're building.

[ 02 ]

Sandbox tenant

Your own tenant seeded with test accounts, cards, and transactions, so your team can click through onboarding, payments, and card controls without touching production.

[ 03 ]

API access, webhooks, and docs

Keys for the core APIs, signed webhooks, and the integration docs — enough to stand a proof-of-concept app against the ledger.

[ 04 ]

Whitelabel starting point

The neutral reference app under your brand's design tokens, so an early build already looks like your product, not ours.

Request sandbox access
/// Further reading
Availability

Licensed as software — deployed whitelabel under your brand.

In the ecosystem

Pay is the core the family orbits — Center operates it, and Issuing draws its cards from Pay's ledger.

Pick a product. Or take the core.

Everything above runs in production demos we can walk you through — product by product, or as one platform under your brand. Tell us what you're building and we'll show you the shortest path to it.

Contact us