Back to blog

Engineering

Crypto subscription billing: how recurring payments actually work on-chain.

QBitFlow Team

9 min read

On this page · 7 sections

Subscriptions are the backbone of SaaS. Recurring revenue, predictable cash flow, lower churn friction. Stripe made this dead simple for fiat: customer enters a card, you bill monthly, done.

Crypto never got this right.

For years, "crypto subscriptions" meant one of three things: emailing an invoice every month and hoping the customer pays, streaming tokens continuously (which doesn't match how most businesses bill), or routing through a custodial processor that holds funds and bills on your behalf, which defeats the point of crypto.

None of these are actual subscription billing. They're workarounds.

This post breaks down how recurring crypto payments actually work on-chain using smart contract spending caps, why the alternatives fall short, and what's shipped today versus what's still missing.

The core problem: crypto wallets don't support "pull" payments

Credit cards work on a pull model. You give the merchant your card number, and they charge it whenever the billing cycle hits. The customer doesn't do anything after the initial signup.

Crypto wallets work on a push model. Every transaction requires the wallet holder to sign it. Nobody can pull funds from your wallet without your explicit approval. That's the security guarantee of self-custody.

This is great for one-time payments. Terrible for subscriptions.

If every monthly charge needs the customer to open their wallet app, find the right token, approve the transaction and confirm, you've built a subscription model that depends on the customer remembering to pay every single month. That's not a subscription. That's an honor system.

Three approaches (and why two of them break)

1. Manual invoicing

The simplest version: send the customer an invoice or payment link every billing cycle. They click, connect wallet, pay.

This is what most crypto-accepting SaaS companies do today. It works for small volumes. It breaks at scale because:

  • Churn by friction. Every invoice is a decision point. Miss one, and you've lost the customer. Not because they wanted to cancel, but because they forgot.
  • No automation. You need a system (or a human) sending invoices, tracking who paid, chasing who didn't.
  • No spending governance. There's no on-chain commitment from the customer. They can simply stop paying, and you won't know until the invoice goes unanswered.

2. Token streaming (Superfluid, LlamaPay)

Token streaming sends a continuous flow of tokens from sender to receiver, calculated per second. Think of it as a faucet that drips money at a constant rate.

It's elegant for payroll and vesting schedules, use cases where "X tokens per second over Y months" makes sense.

It's a bad fit for most subscription billing because:

  • Subscriptions are discrete, not continuous. A $49/month SaaS plan charges $49 once a month. It doesn't charge $0.0000189 per second. The billing event matters: it's when you check payment status, update access, send receipts.
  • Revenue recognition gets weird. Streaming creates a continuous revenue flow that doesn't map to billing periods. Accounting for "we received 2,592,000 seconds worth of tokens this month" is harder than "we billed $49 on May 1st."
  • Underfunded streams fail silently. If the sender's wallet runs low, the stream stops. No discrete failure event, no "payment failed" webhook. It just dries up.

Streaming solves a real problem. It's just not the subscription problem most SaaS founders have.

3. Spending-cap authorization (the model that works)

Here's the third approach, and the one that actually maps to how subscriptions work in fiat:

  1. Your customer signs one allowance. At checkout they choose how many billing periods to authorize, and they sign once. The allowance covers that many bills, each at most a maximum per period. This is the only wallet interaction a running subscription needs.
  2. QBitFlow bills each due date. The first bill is charged at signing. After that, QBitFlow's scheduler charges one bill per due date. No customer action required.
  3. Funds stay in the customer's wallet. Unlike custodial or escrow models, the customer's tokens sit in their own wallet until each bill. No escrow, no custody, no middleman holding the money.
  4. The cap is the cap. The smart contract enforces it: each bill is at most the maximum per period, and never past the allowance. When the allowance runs low, the customer tops it up or cancels from their own page.

This is a pull model built on push infrastructure. The customer authorizes a bounded pull via smart contract, and each bill executes within those bounds.

How this works in practice

Here's the actual flow for a $49/month SaaS subscription paid in USDC:

Customer side:

  1. Customer clicks "Subscribe" on the merchant's site and lands on the hosted checkout
  2. They pick the chain and the token, choose how many months to authorize, and connect their wallet
  3. They sign the subscription (one wallet interaction), which also pays the first month
  4. Done. No further wallet interaction until they want to top up, pause or cancel

Merchant side:

  1. On each due date, QBitFlow charges the bill against the smart contract. You don't schedule anything, run a billing worker or sign anything
  2. The contract checks that the subscription is active, that the bill is within the customer's maximum and allowance, and that the wallet holds enough
  3. If all checks pass, the tokens move from the customer's wallet to yours, and you receive a subscription.billed webhook
  4. Two things can need the customer's attention:
    • The allowance runs low (a prompt, not a failure): the bill was paid, but 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. Point the customer to their management page to top up.
    • A bill fails: the wallet didn't hold enough, the allowance ran out, or the approval was revoked. The subscription goes pastDue and you receive subscription.billingFailed with the reason. QBitFlow retries 1, 3, 5 and 7 days after the first failure. If a retry succeeds, it's active again. If the last one fails, it's cancelled.

What the merchant sees:

  • Every subscription and its bills, on the dashboard and through the API
  • Its status: trial, trialExpired, active, paused, pastDue, stopped or cancelled
  • What the customer must do, if anything, in actionRequired: topUpAllowance, raiseMaximum or confirmTrial

Webhooks on every transition. You don't poll. QBitFlow sends subscription.created when it starts, subscription.billed for each bill, subscription.statusChanged on every change of status, subscription.actionRequiredChanged when the customer has something to do, subscription.billingFailed on each failed attempt, and subscription.upcomingBill a few days before each bill. To grant access, compare now with the subscription's currentPeriodEnd, whatever its status.

What the customer controls, from their own page:

  • Top up their allowance when it runs low
  • Pause and resume, with a message signed by their wallet (no transaction, no gas)
  • Cancel: the subscription is never billed again and runs until the period they paid for ends
  • See their subscription and its recent bills

No account, no password. The customer's wallet is the account: every action above is signed by the same wallet that authorized the subscription in the first place.

What's actually shipped (not vaporware)

This is where most "crypto subscription" articles get fuzzy. They describe an ideal system without telling you what works today. Here's what's live right now on QBitFlow:

Live and working:

  • Spending-cap subscriptions on Ethereum, Base and Solana
  • Billing frequencies from 1 hour to 1 year: daily, weekly, monthly, yearly or a custom interval
  • Free trials: the customer starts one by signing a message, which moves no funds and costs no gas
  • Automatic billing on each due date by QBitFlow
  • Top-up prompts (actionRequired), pastDue retries for up to 7 days, and every status sent as a webhook
  • Customer management page: top up, pause, resume, cancel
  • Merchant cancellation, at once or at the end of the period the customer paid for
  • Refunds of any bill, in full or in part: requested by the customer or started by you, and sent from your wallet
  • SDKs in TypeScript, Python, Go and PHP

Important constraints:

  • Subscriptions are token-only. You can't bill in a chain's native coin (ETH or SOL): the authorization model needs a token's allowance. USDC, USDT, DAI and the other supported tokens work.
  • Prices are locked. A subscription bills the price the customer subscribed at, and there's no plan change on a running subscription. To move a customer from $49/mo to $99/mo, cancel theirs at the end of its period and send them a new checkout at the new price.

We're honest about these limits because you'll hit them. Better to know now than to discover mid-integration.

Who needs this today?

Three categories of businesses where on-chain subscription billing makes practical sense right now:

1. SaaS with crypto-native customers

If your users already hold USDC or USDT in wallets, you're adding friction by forcing them through Stripe. They have to convert to fiat, use a card, and pay the processor's fees, to pay you for a product they use in the crypto ecosystem. On-chain billing removes the conversion step.

2. Creator platforms and membership sites

Membership models (Patreon-style, premium communities, content subscriptions) map cleanly to spending-cap billing. The marketplace trust layer makes this particularly interesting: a platform can hold a creator's funds while the creator has no wallet yet, then pay them directly once it trusts them.

3. API providers preparing for agent traffic

This one is still emerging, but it's worth watching. The spending-cap model maps directly to agent budgets: an AI agent gets a capped authorization, the API provider bills within the cap, and the user (or the user's organization) controls the maximum exposure.

How to get started

If you want to test on-chain subscription billing:

  1. Sign up at qbitflow.app/get-started with an email and a password
  2. Add a wallet: you only provide a public address on each chain you want to be paid on. No seed phrases, no private keys
  3. Create a subscription product in the dashboard or through the API
  4. Generate an API key and integrate with an SDK (TypeScript, Python, Go or PHP)
  5. Test on testnet first: get test tokens from the faucet in your dashboard, and trigger each test bill yourself instead of waiting for its due date

The full docs are at qbitflow.app/docs.

The honest take

Crypto subscription billing is real, but it's not mature. The spending-cap model solves the core architectural problem, how to do recurring pulls from a push-only wallet, and it's live and working today.

What's still missing across the industry: plan changes on a running subscription, and the kind of billing management dashboard that Stripe has spent a decade refining. We're building toward that, but we're not there yet, and neither is anyone else doing this non-custodially.

If you're a SaaS founder evaluating crypto payments and subscriptions matter to your model, the spending-cap approach is the one worth betting on. The alternatives, manual invoicing and token streaming, solve different problems.

The pieces are coming together. The question is whether your billing is in place when your customers start asking to pay in USDC, or whether you're scrambling to build it after they've already left for a competitor who figured it out first.


QBitFlow is a non-custodial crypto payment gateway with subscription billing, marketplace fee splitting, and hosted checkout on Ethereum, Base and Solana. Get started free.

  • Engineering

    How we solved chargebacks without custody: the QBitFlow refund architecture.

    Every pitch for non-custodial crypto payments runs into the same objection: but what about chargebacks? The assumption underneath (that chargebacks equal consumer protection) concedes the entire dispute-resolution layer before the conversation starts. It shouldn't. This is the architecture we built instead: transparent, verifiable on-chain, and decided by the merchant, not Visa.

    9 min read

  • Engineering

    We built on Ethereum and Solana from day one. Adding Base, our third chain, took a weekend.

    Picking one chain forces you into ideological camps you don't actually want to be in. We built QBitFlow on Ethereum and Solana from the first commit. Six months later, merchants asked for an EVM L2 with sub-cent fees, so we shipped Base over a weekend. The reason it took a weekend instead of a quarter is the upfront discipline of designing for two execution models from day one.

    9 min read

  • Industry

    Stablecoin payments for marketplaces: how platforms can accept crypto in 2026.

    Marketplaces have always borrowed someone else's payment rails (Stripe Connect, PayPal for Marketplaces, Adyen for Platforms) and accepted the trade-offs: a 0.5% markup on top of card fees, multi-day payout delays, and the standing risk that the platform underneath yours decides your sellers are too risky to serve. Stablecoins quietly removed those trade-offs in 2026. This is what changed, what the three real options look like, and how a non-custodial gateway with smart-contract fee splits fits in.

    12 min read

Subscribe to our newsletter

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

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