Back to blog

Guides

Non-custodial crypto subscriptions: a real Stripe alternative for global SaaS

QBitFlow Team

8 min read

On this page · 7 sections

Getting recurring revenue from crypto-native customers should be simple. It isn't.

Your subscription service works great for customers who pay by card. Then a customer in Argentina, Nigeria, or Indonesia tries to subscribe. Their card doesn't clear. Or you're a crypto-native SaaS (a DAO tooling provider, a blockchain analytics API, an AI-compute service) and your customers already hold USDC. They'd rather pay in it than convert to fiat and back again.

Stripe doesn't solve this. It geo-gates by design: if the customer is in the "wrong" country, they can't pay you. And even when it works, Stripe holds your money until its next payout. That's not a bug. It's how every custodial processor works: the money passes through them before it reaches you.

This guide covers how to set up non-custodial USDC subscriptions with QBitFlow, on Ethereum, Base or Solana, so you collect directly into your wallet, no one holds your funds, and any customer with a compatible wallet and a supported token can subscribe.


What's broken with crypto subscriptions today

"Crypto subscriptions" is a misleading category. Most solutions fall into one of three buckets:

Request-invoice systems. You send a payment link; the customer pays manually each cycle. That's not a subscription. It's a polite request you hope they honor.

Custodial processors. You accept crypto, they convert it to fiat and hold it. You've replaced one payout-delay problem with another, and now you've also lost the on-chain verifiability that was the whole point.

Roll-your-own smart contracts. You build the allowance logic, manage billing cycles, handle retries, cancellations, and state transitions yourself. Weeks of engineering work, and most teams don't have a payments engineer.

QBitFlow is a different approach: a non-custodial recurring billing system. Your customer signs one allowance at checkout. QBitFlow then charges each bill on its due date, through the open-source contract on-chain. The funds move directly from your customer's wallet to yours; QBitFlow never holds the money at any point.

One thing to be clear about upfront: subscriptions are token-only (ERC-20 on Ethereum and Base, SPL tokens on Solana). USDC, USDT, EURC and DAI work; a chain's native coin (ETH or SOL) doesn't, for subscriptions. And what the customer pays is exactly what you receive: there's no auto-swap or routing through a liquidity pool. If a customer pays in USDC, you receive USDC.


What ships out of the box

Before you integrate, here's what's live:

  • Subscriptions on Ethereum, Base and Solana, in the supported tokens (the list is in the docs)
  • Billing intervals from 1 hour to 1 year: daily, weekly, monthly, yearly, or any interval in between
  • Free trials: your customer starts one by signing a message, which moves no funds and costs no gas. The subscription is trial, and your backend receives subscription.created. If the trial ends unconfirmed, it becomes trialExpired (with actionRequired: "confirmTrial"), and your customer has 7 days to confirm it by signing the subscription itself.
  • Subscription webhooks on every change: subscription.billed for each bill, subscription.statusChanged on each status (active, paused, pastDue, stopped, cancelled…), subscription.actionRequiredChanged when your customer has something to do, and subscription.billingFailed on each failed attempt. No polling required
  • Customer management page: your customers top up their allowance, pause, resume or cancel, without contacting your support team
  • Your own cancellation: you can end a subscription at once, or at the end of the period your customer paid for, without their signature
  • An accounting export: every payment, bill, refund and fee, as CSV or JSON, with the on-chain split of each

On security and trust: QBitFlow's contracts are open-source on GitHub, readable and forkable by anyone, including your own engineers. They have not been formally audited yet. Every payment has an on-chain transaction hash you can verify in a block explorer directly, not a number in a processor's dashboard you have to take on faith. Funds never pass through QBitFlow custody at any point: QBitFlow's role is to trigger each bill, not to hold or route your money.


How the spending-cap model works

The key difference from card billing: QBitFlow uses a spending cap model, not pull-on-demand.

When a customer subscribes:

  1. They choose how many billing periods to authorize and sign once: an allowance of that many bills, each at most a maximum per period. That signature pays the first bill.
  2. On each due date, QBitFlow charges one bill through the contract, which checks the maximum, the allowance and the customer's balance. No additional customer action needed.
  3. Money lands directly in your wallet once the transaction confirms. No payout window. No intermediary.

A few things this model gives you that card billing doesn't:

The cap is customer-signed. The maximum per bill is part of what the customer signs. Your system can't charge beyond it without a new signature from the customer, a meaningful trust guarantee for subscription customers who've been burned by surprise charges.

A low allowance is a prompt, not a failure. When what's left of the allowance covers about one more period or less, the subscription stays active with actionRequired: "topUpAllowance", and you receive subscription.actionRequiredChanged before any bill fails. You can prompt your customer to top up, rather than discovering a churn after the fact. If a bill does fail, the subscription goes pastDue and QBitFlow retries it 1, 3, 5 and 7 days later before cancelling it.

No chargebacks. Payments are final once confirmed. A customer who wants a refund requests it from their page. You review it in your dashboard and approve it, for all of it or a share, by signing the transfer from your wallet, or deny it with a reason. Refund decisions are yours, not a card network's.


Setting up a USDC subscription

1. Sign up and add your wallet

Go to qbitflow.app/get-started. You connect your wallet with a browser extension or a mobile QR scan. No seed phrases, no pasting addresses. Your wallet is where you're paid from day one; QBitFlow never has access to your keys.

Start in test mode (get test tokens from the faucet in your dashboard) and switch to live when you've validated the flow. Live uses its own API key, wallets and webhook endpoints.

2. Create a checkout session

With the TypeScript SDK (npm install qbitflow), one call opens a hosted checkout for a subscription. The product can be inline, as here, or one of your catalog's:

TypeScript

import { DurationUnit, Placeholders, QBitFlow } from 'qbitflow'; const client = new QBitFlow(process.env.QBITFLOW_API_KEY ?? ''); // The subscription exists, with the session's id, once the customer signed (here: started the// trial). Act on the subscription.created webhook.const session = await client.checkoutSessions.createSubscription({	productName: 'Premium',	description: 'Access to all premium features',	price: 29.99, // USD per period	frequency: { value: 1, unit: DurationUnit.Months },	trialPeriod: { value: 7, unit: DurationUnit.Days },	minPeriods: 3, // the periods the customer commits to (optional)	reference: 'order-1043',	successUrl: `https://yourapp.com/subscribed?uuid=${Placeholders.UUID}`,	cancelUrl: 'https://yourapp.com/pricing',}); // Redirect the customer to the hosted checkout page.console.log(`Redirect the customer to ${session.link}`);

Your customer lands on the hosted checkout (its theme and logo are yours to set), picks the chain and the token, connects their wallet and signs. The session's id (sub@…) is the subscription's id for life: store it.

3. Handle events with a webhook

Create your endpoint once, in the dashboard (Settings → Webhooks) or through the API, and store its signing secret. The SDK's router verifies each delivery's signature over the raw body, runs your handler for its type, and answers QBitFlow:

TypeScript

import express from 'express';import { hasAccess, webhooks } from 'qbitflow'; const router = webhooks	.router(process.env.QBITFLOW_WEBHOOK_SECRET!)	.on('subscription.created', async (subscription, event) => {		await grantAccess(subscription.uuid, event.id); // idempotent: deduplicate on event.id	})	.on('subscription.statusChanged', (sub) => {		console.log(`${sub.uuid}: ${sub.previousStatus} -> ${sub.status}, access: ${hasAccess(sub)}`);	}); const app = express();app.post('/webhooks/qbitflow', express.raw({ type: 'application/json' }), router.nodeHandler());app.use(express.json()); // the rest of your API, after the webhook routeapp.listen(3000);

Grant access while now is before the subscription's currentPeriodEnd, whatever its status: hasAccess does exactly that. A stopped or paused subscription has paid for its period.

4. The customer management page

Every subscription ships with a hosted page where your subscribers can:

  • See the subscription, its next bill and its recent bills
  • Top up their allowance before it runs out
  • Pause and resume it, or cancel it, without contacting your support

You don't build or host this. It's included.


Pricing

0.99% per transaction, down to 0.5% with volume, enforced on-chain. QBitFlow's fee is taken by each bill's transaction: at 0.99%, a 100 USDC bill means 99.01 USDC lands in your wallet. No monthly platform fee, no setup cost. The network fee is separate.


Who this is (and isn't) for

Good fit:

  • SaaS products with crypto-native customers: Web3 tools, blockchain analytics APIs, AI-compute services, DAO tooling
  • Subscription businesses with a global customer base where Stripe has limited reach
  • Developer teams who want a production-ready subscription primitive without building it

Not the right fit today:

  • You need customers to pay in fiat (credit/debit card, bank transfer): QBitFlow is crypto-native only
  • You need to change a running subscription's price or plan: prices are locked, so you cancel it at the end of its period and send a new checkout

If you're unsure whether QBitFlow fits your use case, the fastest way to find out is to run a test subscription: test mode works end to end on testnet, no mainnet funds required.


Get started

Subscribe to our newsletter

New posts in your inbox. You confirm your address first.

Take your first payment today. In test mode, for free.