Products and infrastructure built with developers in mind.
Developer-facing software should be inspectable. StablePay gives you a versioned API, signed lifecycle webhooks, and a deployment you run on your own infrastructure — with docs that describe the actual system, not an abstraction of it.
What developers come here to avoid.
Building a payment gateway is a project of its own. Renting one hands the interesting parts to someone else. StablePay sits between the two.
- Building a gateway from scratch
Confirmation tracking, retries, webhooks, reconciliation, and an operator UI are months of work before the first real payment.
- A black-box processor
A hosted vendor's ledger cannot be inspected, and its webhook behaviour is whatever the vendor decides this quarter.
- Fragile one-off adapters
A script that polls a chain, a cron job that writes a file. It works until the missed event nobody was watching.
- Docs that describe a brochure
Marketing pages that abstract away the contract. You want the lifecycle, the events, and the failure modes written down.
What you get to integrate against.
The surface is deliberately small and explicit. Support is limited to what is implemented and tested; anything planned is marked as planned.
- Payment intents, links, and invoices
Create payments through a versioned API. The host application stays in control of customer accounts; the gateway records payment state, retries, and exceptions.
- Signed webhooks
Lifecycle events are signed so your service can verify what it receives, and replay tokens let you recover from downtime without guessing what was missed.
- Configurable tokens and networks
Connect the chains, tokens, and RPC providers you actually operate. Network packs are added when they are implemented and tested — not before.
- Operator dashboard
Tracking, confirmation, and settlement status for the humans on call, running inside your deployment rather than someone else's console.
The payment lifecycle, end to end.
Every StablePay payment moves through the same five stages. Your application creates and listens; the gateway tracks, reconciles, and settles.
- 01
Create
Your service creates a payment intent, link, or invoice through the API and keeps its own reference.
- 02
Track
The indexer watches the configured network and records confirmation state in your PostgreSQL database.
- 03
Listen
A signed webhook fires as the payment moves through its lifecycle. Verify the signature, update your order, return 2xx.
- 04
Reconcile
The dashboard and API show what is open, confirmed, or in flight, so the answer never depends on a vendor's support desk.
- 05
Settle
Funds land in wallets you control. Signing keys never leave your environment, and the studio never holds customer funds.
Proof from named engagements.
- Digital assetsVellum Markets
Vellum needed stablecoin settlement they could operate themselves — not another hosted processor with a black-box ledger.
Time to first live payment: 17 daysManual reconciliation: −64% - Energy servicesHelios Grid
A field-services company needed to pay contractors in stablecoin on jobs that close in hours — and keep an audit trail the existing ERP could accept.
Median contractor settlement: 14 days → 11 hoursERP exceptions after ingest: < 0.4%
Who this is for, and what it is not.
Who it is for
- Developers integrating stablecoin payments without building a full gateway
- Engineering teams that want to inspect and run their own payment infrastructure
- Agencies deploying a branded gateway for clients they already operate
- Teams comfortable with Docker, PostgreSQL, and operating a service
Not this
- Not a hosted payment processor
- Not a custodian or bank
- Not legal or compliance advice
- Not a promise of every chain — only what is implemented and tested
From evaluation to production.
Read the contract before you talk to anyone. The product page and engineering notes are written for technical buyers.
- 01
Read the contract
Product page, lifecycle, architecture layers, and the engineering notes on webhooks and signing boundaries.
A clear picture of what the API does and does not do.
- 02
License and deploy
Choose a plan, pull the Docker image, and run it against PostgreSQL and the RPC providers you operate.
A gateway running in your environment.
- 03
Integrate and handover
Wire intents and webhook handlers into your application. Handover includes runbooks for the 2am case.
Live payments and a runbook your on-call can use.
From the journal.
Designing adapters that do not try to own your ERP
Operations software earns trust by sitting between systems, not replacing them. The adapter layer is where that promise is kept or broken.
By Daniel Whitfield
Idempotency in payment intents: making retries boring
Every network call can be repeated. The only question is whether repeating it is safe.
By Daniel Whitfield
25 tips for writing reliable webhook handlers
Small, concrete habits that turn a fragile webhook endpoint into one you can forget about — verification, idempotency, speed, testing, and operations.
By Daniel Whitfield
Questions worth asking.
Is StablePay a hosted service?
No. It is payment gateway software you purchase, deploy, and operate. We do not process payments, hold funds, or run wallets on your behalf.
Where do signing keys live?
In your environment. Production signing, RPC providers, databases, and secrets stay under your control.
Which networks and tokens are supported?
Tokens and networks are configurable, and support is limited to what is implemented and tested. Anything not yet shipped is marked as planned.
What happens if my webhook endpoint is down?
Events are signed and replay tokens are provided so you can recover state rather than guess what was missed.
Can you help with the integration?
For selected teams, yes — feature development and Web3 integration engagements with a written scope and a handover.
Inspect it before you buy it.
Start with the product page and the engineering notes. If the contract fits your system, the licensing path is short.