You are not running an integration project across five suppliers and hoping they agree on what a merchant is. There is one record of the merchant, and everything downstream reads it.
The hierarchy and the permissions are native. Nobody spins up a separate instance per tenant, so a sub-partner is a row — not a deployment.
The merchant lifecycle, and the module that carries each part of it. Every partner uses a different subset — nothing here is reserved for one kind of partner.
Deals, contacts, organisations and pipeline health — sell on the same platform you deliver on.
→Public self-service link or a guided in-portal flow, with registry lookup and identity documents.
→Templates, electronic signing, resend, reversal and a full audit trail.
→Change a price once and every new contract picks it up.
→Pairing, activation, fleet inventory, firmware versions and remote configuration.
→Attended register for hospitality and retail — offline-first, card and cash.
→The self-service terminal: unattended checkout that survives reboots and outages.
→We find the broken terminal before the merchant calls.
→Tickets from POS, app, chat and hotline — with the customer context attached.
→eKasa and EET 2.0, on-device and service-side, with offline and retry handling.
→The device-facing backbone and the single record of what happened.
Core, ISO, Partner, Vendor and Merchant services over GraphQL, one permission model.
One identity across every portal and application in the chain, with SDKs.
Per-resource, per-possession access that survives an audit.
Documentation, sandbox and API keys for third-party systems.
Durable delivery with replay, plus SSE and WebSocket channels.
Templated email, mobile push and event-triggered rules.
Partner brand colours and logo across portals and applications.
Cross-tenant administration and configuration.
Six steps that collect everything the contract needs — and never ask for it twice.
Every acquirer collects something different. Steps, fields, documents and validation rules are configured per partner — the merchant is only asked for what you need.
We push completed applications into the acquirer's or provider's own systems over API — merchant records arrive where your teams already work, not as an export someone re-keys. Each connection is scoped with the partner.


Send a public self-service link and the merchant completes the application without anyone from your team in the portal — or run the same flow as a guided in-portal wizard. Same data, same contract, either way.
The merchant types a company name; we pull the rest from the national business registry. Companies and sole traders alike.
If a merchant stalls halfway through, your team picks the application up remotely and completes it.
One sign-up provisions every product the merchant ordered — terminal, POS, fiscalisation, services. Nothing is asked twice.
The contract is generated from a template, signed electronically and filed — with resend, reversal and a full audit trail, and a signing pipeline each ISO can switch on or off. Prices come from the product catalogue, so change a price once and every new contract picks it up.
Card acceptance is only one part of it. Because the data is already on file, adding a product later is an activation, not a second onboarding.



Adding a product later is an activation — not a second onboarding.
Because the data is already on file.Vendor, ISO, partner and merchant each get their own surface — reading and writing the same data, under one permission model.
The operating cockpit — merchants, branches, devices, contracts, acquirers, catalogues, teams and profitability in one place.
Run a whole merchant portfolio from one place.A sub-partner's own book of business, plus its API keys, webhook endpoints and delivery history.
A partner manages its own merchants and its own integration without asking us.The master product catalogue: product types, categories, packages and discounts.
Define the product once and every ISO sells from the same source.The merchant's own view — company details, users, documents and contracts, branches, devices.
The merchant self-serves instead of emailing support.Turnover, transactions, MSC, interchange, acquirer cost and net profit — per portfolio, per acquirer and per MID. Not a monthly export: a live read-model fed by change-data-capture, so asking questions never slows the platform down.
Deals, contacts and organisations with a pipeline dashboard and deal health notifications. You sell on the system you deliver on, so a won deal becomes an onboarding without leaving the tool.


Vendor → ISO → sub-ISO → partner → merchant → branch. Roles are per-resource and per-possession — own versus any — with default roles per organisation type, so an audit finds an answer instead of a spreadsheet.
Sales reps, technicians, support and managers with KPI fulfilment, plus an asset and subscription register that knows what every merchant actually has — and what they don't yet.
A sub-partner is a row — not a second deployment.
The hierarchy lives in the data model and in the permissions.Pairing, activation, firmware and health for every terminal in the field — without visiting one.
A device is paired to a branch and activated from the portal. Reactivation after a swap is the same flow — no engineer, no support ticket, no serial numbers in a spreadsheet.
Fleet inventory with firmware and application versions per device, plus remote configuration. You know what is running in the field before you decide to change it.

The self-service terminal software: card and cash, a launcher, a foreground service that restarts on boot, offline cache, circuit breaker and health checks. It survives reboots and outages because the shop cannot wait for the network.
What hardware and software each merchant has, subscription size and validity, and monthly used-services reporting — so billing matches reality.
The register, the self-service terminal and the owner's mobile app are products your merchants use every day. See the merchant stack →
We find the broken terminal before the merchant calls.
Health telemetry from every device, with alerting thresholds and automatic incidents.Every market has its own rules. We build and maintain fiscalisation in-house, country by country — and deliver it as an API, so it works for your software too, not only ours.
Fiscal registration of every transaction, on the device and on our side, with offline and retry handling for the moments the connection is not there.
Per-merchant activation, the Czech receipt format and the same offline and retry path. One product, sold legally in a second market.
Where a proven local fiscalisation already exists, we integrate it instead of rebuilding it. The market decides, not our roadmap.
Fiscalisation reaches you through the Integration Hub as an API — usable with or without the rest of the platform, if that is all you need from us.
Every sale is fiscalised without the merchant thinking about it.
On-device and service-side, with offline handling and retry.Event-driven by design: every card tap and every fiscal action fires an event you can subscribe to — no polling, no nightly export.
An integration API for third-party systems, with documentation, a sandbox and API keys. A cash register or an ERP vendor integrates payments without becoming a payments company.
Subscriptions managed from the Partner portal, durable delivery with an outbox relay and retry, delivery history and replay. If your endpoint was down, the event is still there.


Server-sent transaction streams and device WebSocket channels — follow a payment as it happens, not after the fact.
A cloud application securely triggers actions on the local device: card payment and fiscalisation managed from the cloud, with no local integration on the merchant's counter.
Sign-in, sessions, tokens, account linking and account selection across organisations, with client libraries for TypeScript and Android.
Per-resource, per-possession access — own versus any — with default roles per organisation type, shared by every API surface.
One identity across every portal and application in the chain.
Veslo Auth, with SDKs for TypeScript and Android and documentation you can integrate against alone.Everything above runs on the same backbone — one device-facing service, one API contract, one place to operate it all. You never buy it separately.
The device-facing backbone: pairing and activation, locations and terminals, transactions and their lifecycle, fiscal events, live channels and webhook dispatch with an outbox relay. Everything a terminal talks to, and the single record of what happened.
Core, ISO, Partner, Vendor and Merchant services over GraphQL, each audience with its own API surface rather than a filtered view of one — bound by a shared permission model and strict backward compatibility.
Cross-tenant administration and configuration. One place to operate the platform across every tenant, instead of logging into each one to change a setting.
Templated transactional email, mobile push and event-triggered rules. The right person hears about it without anyone watching a screen.
Your brand colours and logo across portals and applications, driven per ISO from the same hierarchy — so your customers see your brand, not ours.
Ticket intake from the register, the mobile app, chat, hotline and messaging, linked to the CRM record with routing rules. Support requests arrive with the customer context already attached.
Three of our products never appear in a partner contract, because your merchants use them: the POS cash register, the Veslo Pulse self-service terminal and the merchant mobile app with revenue widgets on the owner's home screen. See the merchant stack →
One backbone. Every portal, every device, every market.
A Postgres write store, asynchronous events, and a read-model that answers questions without slowing anything down.Tell us about your portfolio — we'll set you up with a partner workspace and a demo.