How to Set Up On-Chain Subscriptions for Recurring Crypto Payments

What on-chain subscriptions actually are

An on-chain subscription is an automated, recurring payment settled directly on a public blockchain. Instead of relying on centralized billing systems, merchants and users use smart contracts to manage recurring stablecoin payments. The paying party is often an autonomous program (an "agent") that triggers transfers at set intervals, using cryptographic signatures rather than card network authorizations.

This model differs sharply from traditional fiat billing. Traditional subscriptions depend on banks and credit card processors to handle recurring charges, dispute resolutions, and reconciliation. These intermediaries introduce friction, including processing fees and the risk of chargebacks. On-chain subscriptions remove the middleman. The settlement happens in stablecoins, with the logic enforced by code rather than a financial institution.

It is also distinct from one-off NFT mints. While an NFT mint is a single transaction, a subscription requires persistent state management—tracking whether a user has paid for the current period, handling renewals, and managing cancellations. True on-chain subscriptions solve this by enabling a "subscribe and forget" experience, where the smart contract automatically debits the user's wallet or escrow without requiring manual token wrapping, unwrapping, or relayer networks for every cycle.

By moving this process onchain, platforms like Solana are attempting to replace the entire centralized billing infrastructure with a transparent, programmable alternative. This shift reduces operational overhead for merchants and gives users direct control over their payment agents, creating a more efficient economic loop for digital services.

Choose your blockchain and payment rail

Selecting the right blockchain for recurring crypto payments requires balancing transaction costs, settlement speed, and wallet compatibility. Onchain subscriptions rely on automated smart contracts to pull funds at regular intervals, meaning every failed transaction due to high gas fees or slow finality breaks the subscriber experience. For high-frequency micro-subscriptions, such as daily news access or per-use API calls, the underlying layer must be cheap enough to process small amounts without eroding margins.

Solana has emerged as a primary candidate for this use case due to its low fees and high throughput. Recent developments, such as Solana's onchain subscription plans, allow merchants to publish fixed pricing tiers directly on the blockchain, enabling automated pull payments without the friction of traditional banking rails [[src-serp-5]]. This infrastructure moves the entire billing process onchain, reducing reliance on centralized card networks that charge 2-3% per transaction [[src-serp-7]].

However, Solana is not the only option. Ethereum Layer 2 networks like Base offer robust security and deep liquidity for stablecoins, though transaction costs can be slightly higher than Solana during peak congestion. Ethereum Mainnet remains prohibitively expensive for micro-payments due to gas fees that often exceed the subscription value itself. The choice ultimately depends on your target audience's wallet preferences and the volume of transactions.

The table below compares the key technical metrics for the most viable options for onchain subscription models.

If you are building for a global audience accustomed to mobile wallets, Solana's speed and negligible fees provide the best user experience for recurring small payments. For enterprise-grade stability and integration with existing DeFi protocols, Base or Arbitrum may be more suitable despite the slightly higher latency. Always test your subscription logic with actual stablecoin transactions on the testnet before going live.

Set up the recurring billing contract

Configuring the subscription contract is the technical backbone of your recurring crypto payments. Whether you are deploying a custom smart contract or using a no-code protocol like Unlock Protocol, the goal is to automate the recurring logic so that access is granted or denied based on payment status without manual intervention.

1. Define subscription parameters

Before writing code or selecting a provider, you must define the core variables of your subscription model. Determine the currency (typically a stablecoin to avoid volatility), the billing interval (weekly, monthly, or annual), and the access tier. If using a no-code tool, you will input these values directly into the configuration dashboard. For custom contracts, these parameters will be defined as state variables in your Solidity code.

2. Choose your deployment method

You have two primary paths for deployment:

• No-code/Low-code protocols: Platforms like Unlock Protocol allow you to create recurring subscriptions by configuring a smart contract template. This is the fastest route for creators who want to launch quickly without maintaining custom code. It handles the recurring logic and token transfers automatically.
• Custom smart contracts: If you need complex logic, such as prorated refunds, multi-tier access, or integration with other DeFi protocols, you will need to write and deploy a custom ERC-20 or ERC-721 based contract. This requires auditing and a higher level of technical expertise.

3. Configure payment logic and automation

The core of the setup is ensuring the contract can process recurring payments. In a no-code solution, this involves linking your wallet and specifying the payment token. The protocol will then handle the automatic deduction and access renewal. If building custom, you must implement a renewSubscription function that checks the current block timestamp against the last payment date. If the interval has passed, the contract should require a new payment to extend access. Ensure you have a mechanism to handle failed transactions or insufficient funds gracefully.

4. Test on a testnet

Never deploy a recurring payment contract directly to mainnet without extensive testing. Use a testnet like Sepolia or Goerli to simulate the subscription lifecycle. Test scenarios include:

• Successful monthly renewal.
• Failed payment due to insufficient balance.
• Early cancellation and refund logic (if applicable).
• Edge cases like network congestion or high gas fees.

This step is critical to prevent financial loss or access denial for your users. Tools like Hardhat or Foundry can help automate these tests.

5. Deploy and verify

Once testing is complete, deploy the contract to the mainnet. If you used a no-code platform, this step is often automatic. For custom contracts, use Etherscan or Blockscout to verify your source code. Verification ensures that users and other contracts can interact with your contract confidently, as they can review the exact code being executed. After deployment, distribute the contract address to your users and integrate it with your frontend to trigger subscription purchases.

1

Define parameters

Set currency, interval, and access tier. These are the foundational inputs for either a no-code dashboard or your Solidity state variables.

2

Select deployment path

Choose between a no-code protocol like Unlock Protocol for speed or a custom smart contract for complex logic and integration needs.

3

Configure automation

Link your wallet and payment token. For custom contracts, implement a renewSubscription function that checks timestamps and requires payment to extend access.

4

Test on testnet

Simulate the full lifecycle on Sepolia or Goerli. Verify successful renewals, failed payments, and cancellation logic before going live.

5

Deploy and verify

Deploy to mainnet and verify your source code on Etherscan. This builds trust by allowing users to audit the contract’s behavior.

Previous

12345

Next

Integrate the checkout experience

Embedding the subscription widget is the final step in connecting your frontend to the blockchain. The goal is to create a frictionless path for users to pay with stablecoins while keeping the flow familiar to web2 users.

Choose the right integration method

Most on-chain subscription platforms, such as Unlock Protocol, provide pre-built components or SDKs that abstract the complex smart contract interactions. Instead of writing raw Solidity code to handle recurring payments, you can drop their React or Vue components directly into your application. This approach ensures that the wallet connection, signature validation, and token transfer happen securely in the background.

Configure the subscription parameters

Before deploying, define the recurring logic in your widget configuration. You need to specify the token address (e.g., USDC on Ethereum Mainnet), the payment amount, and the recurring interval (monthly, yearly). Ensure your UI clearly displays these terms to the user before they click "Subscribe." Transparency here reduces support tickets and chargebacks, even though on-chain transactions are irreversible.

Test with a staging environment

Never launch a recurring payment widget in production without testing. Use a testnet like Sepolia or a local Hardhat node to simulate the subscription lifecycle. Verify that:

1. The user’s wallet connects correctly.
2. The initial payment is processed and recorded on-chain.
3. The subscription state updates in your database or frontend cache.

Automating this flow reduces friction for your members and can significantly reduce churn by making it easy to manage their access. Unlock Protocol offers detailed guides on setting up these recurring structures with minimal code.

Avoid common setup mistakes

Even a well-architected on-chain subscription contract can fail if the user experience isn't airtight. Most churn and support tickets stem from three predictable errors: unclear approval flows, broken cancellation logic, and mishandled gas fees.

Mismanaged gas fees

If your subscription contract relies on the user paying gas for every renewal, adoption will stall. Users expect a "set and forget" experience, not a daily transaction confirmation. Use account abstraction or relayer networks to cover gas costs, or ensure the fee structure is bundled into the subscription price. Without this, the friction of manual gas payments breaks the recurring promise.

Poor cancellation flows

A subscription is only as good as its exit. If users cannot easily cancel via their wallet interface, they will perceive the service as predatory. Ensure your smart contract exposes a clear cancel() function that immediately stops future charges. Don't bury cancellation options in complex documentation; make it a primary button in the UI.

Inadequate user education

Wallet approvals are often misunderstood by non-crypto-native users. If a merchant requests an unlimited token approval without explanation, users may reject it or, worse, leave the funds exposed. Always provide a clear, step-by-step guide on what they are signing. Transparency builds trust and reduces chargeback-style disputes in decentralized environments.

Frequently asked: what to check next

What are on-chain payments?

An on-chain payment settles directly on a public blockchain using stablecoins, rather than routing through traditional card networks. The transaction is authorized by a cryptographic signature from the payer’s wallet, which can be a person or an autonomous agent program executing the transfer.

Are on-chain subscriptions better than traditional billing?

Traditional subscriptions rely on centralized billing systems, banks, and credit cards, which often involve high fees and friction. On-chain solutions aim to move this process entirely on-chain, allowing for "subscribe and forget" mechanics without the need for escrow, token wrapping, or relayer networks.