Contact us
/// Pay · Whitelabel Neo-bank

One platform. Any app you can imagine.

Protocore Pay is a single whitelabel platform — ledger, accounts, KYC, cards, crypto — 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
Multi-chain
All major blockchains
/// 01

The core does the banking

Ledger, accounts with IBANs, KYC, card issuing, and crypto 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
  • [ 04 ]Crypto alongside fiat — all major blockchains
/// 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 a clean exchange, Lumen a super-app, Fern puts transfers first, Volt an ultra-dark minimal stablecoin neo-bank, Meridian a multi-currency card app with crypto rewards — 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 fiat and crypto rails, 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 wallet opens to its owner.
/// 03

Biometric unlock

The app opens with Face ID and falls back to PIN. Biometrics gate the wallet, 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 at 08:47 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 — +€340.00 in, −€195.00 out, history attached.
/// 06

Contact profiles

Every contact has a money page. The demo profile shows both directions between two people — €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.

Every rail in one list — SEPA, P2P, card, and crypto, search on top.
/// 10

Unified history

One list holds every rail. The demo history mixes a €3,200.00 SEPA salary, a €500.00 USDC conversion, a P2P send, card payments, and a USDC top-up over Base — searchable, filtered by in, out, card, and crypto. A declined charge keeps its decline reason inline instead of disappearing.

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

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, transactions above the set limit confirmed by SMS, and change PIN, rename, 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.
/// 12

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.
/// 13

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
Salary in, sorted — rules route the paycheck across sub-accounts on arrival.
/// 14

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. Shown here in Volt, one of the example directions.

A €2,000 team budget, €500 per card — and a €200 raise waiting on approval.
/// 15

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, €500 per card, spend bars per employee. When someone needs more, the request travels in the flow: a €200 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.
/// 16

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.

€500 waiting on 1.0100 — the rule moves the money, the fee locked up front.
/// 17

Auto-convert rules

Users set FX rules instead of watching charts. In the demo, €500 converts to USDC when the rate reaches a target the user set — the current rate and the 30-day best sit on the same screen — with the fee locked at rule creation, not at execution. Alert-only rules watch the rate without moving money. Shown here in Fern, one of the example directions.

Flexible USDC and staked ETH — the projection stated before the deposit.
/// 18

Earn

Balances can work. The demo shows €1,086.10 earning across flexible USDC and staked ETH, with a twelve-month projection stated before anyone commits a cent. Accrual is daily, payout weekly. Shown here in Halcyon, one of the example directions.

0.0042 BTC earned so far — 1.5% back, every purchase crediting its slice.
/// 19

Crypto rewards on spend

Card spend can earn crypto. In Meridian, one of the example directions, every purchase credits a slice of BTC — 1.5% back in the demo, a product parameter set per tenant, not a market rate — and the hub tracks 0.0042 BTC accrued across coffees and market runs, with milestones and monthly accrual underneath. Rewards land in a BTC account on the same ledger as everything else.

  • [ 01 ]A per-purchase BTC credit on every card transaction
  • [ 02 ]The back-rate is a tenant setting, not a promise about markets
  • [ 03 ]Rewards redeem to a ledger account, not a points scheme
EUR, USDC, GBP, and BTC under one identity — the move reviewed before it runs.
/// 20

Multi-currency accounts

One customer holds many balances. In Meridian, one of the example directions, a €2,458.30 EUR main account sits beside a USDC stablecoin account, a GBP travel balance, and the BTC account where card rewards land — each with its own ledger view and its own history. Conversion between them is always explicit: the exact rate is shown on the review screen before you confirm, never applied silently.

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

Notifications

One feed carries money, security, and product. The demo shows a €3,200.00 salary landing, a new sign-in alert, a card payment, a referral reward, a completed swap, 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.
/// 22

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.
/// 23

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.
/// 24

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.
/// 25

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 the fiat ledger and crypto rails. 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 ]Both rails 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.
/// 26

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.
/// 27

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.
/// 28

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 wallet 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, and a cross-currency send delivers USDC for exactly €120.00 in, the rate guaranteed for 24 hours.

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.

Crypto alongside fiat

BTC, ETH, Base, and Solana sit in the same app as the EUR account. €120 buys USDC funded straight from the EUR balance; €500 exchanges to USDC at a stated rate with the fee shown before confirm. One balance sheet, two kinds of assets.

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. 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, earn, crypto, 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: a clean, light exchange.
  • The ETH page — live price and chart, your 0.052 ETH position, buy or sell from the same screen.
  • Buying USDC — €120 in, USDC out, funded straight from the EUR account.
  • Earn — flexible USDC and staked ETH, rewards accrued daily and paid weekly.
  • Payment links — request money with a link, settle to the ledger.
/// 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.
  • Exchange — €500 into USDC, rate and fee stated before confirm.
  • 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.
  • Send — exactly €120.00 in, USDC out, the rate guaranteed for 24 hours.
  • Recipients — @handle or IBAN, each contact in their own currency.
  • Auto-convert — €500 moves itself when the rate reaches 1.0100, fee locked now.
  • Payroll — B2B batch payouts from the same accounts.
/// Example 04 · Volt
  • Volt — one example direction: an ultra-dark, minimal stablecoin neo-bank.
  • Pay — €120.00 to @andrei, instant and free, straight from Daily.
  • Groups — the Cluj trip, €480 across four members, one Settle up.
  • Salary sorter — incoming pay splits itself across sub-accounts.
  • Team cards — a €2,000 budget, €500 per-card limits, approvals in the flow.
/// Example 05 · Meridian
  • Meridian — one example direction: a crypto-plus-fiat card app in deep petrol dark.
  • Card — one gradient card, 1.5% back in BTC, every purchase crediting its slice.
  • Accounts — EUR, USDC, GBP, and BTC in one list, every move reviewed before it runs.
  • Spend abroad — the card picks the right account at the till, GBP first, EUR as fallback.
  • Rewards — 0.0042 BTC so far, milestones on the way to 0.005, redeem when you like.
/// The platform app
  • Identity check — verification runs 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, all inside the conversation.
  • Contact profile — one person, both directions: +€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.
  • History — every rail in one list, a failed charge flagged inline.
  • 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.
  • Referrals — code AION-4K, six joined, €60 earned.
  • Stories — full-screen product moments, tappable like you expect.
  • Privacy controls — discoverable on your terms, balances hidden on demand.
/// The operator console
  • User 360 — one customer, every balance, card, and transaction in view.
  • Transactions — both rails in one list, 4,912 rows deep.
  • 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 platform: the ledger, accounts, cards, and crypto. Whether you run under your own permissions, a sponsor, or a partner is a commercial 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, card issuing, and crypto live in the platform; the app decides only what to show and how. That is why a clean exchange and an ultra-dark stablecoin bank can run on identical plumbing.

  • Yes. Fiat and crypto live in one core under a single double-entry ledger — a balance is a balance whether it arrived by SEPA or on-chain, across all major blockchains. The app chooses how much of that to surface to the user.

  • The operator console — customer 360s, transactions across both rails, 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 standalone license — ledger, accounts, cards, and crypto. Scope follows the modules you switch on and the scale you run at, not a per-seat count.

[ 02 ]

Build & operate

We shape the app layer to your brand and operate the platform for you. 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. Standalone or whitelabel, 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 tokens, so an early build already looks like your product, not ours.

Request sandbox access
/// Further reading
Availability

Available standalone or whitelabel — under the Protocore brand or yours.

In the ecosystem

Pay is the core the family orbits — Center operates it, Issuing draws cards from it, Chain settles its crypto, and Agents spends on its rails.

Pick a product. Or take the core.

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

Contact us