Why recurring payments don't exist on-chain (and how we fixed it)

Here is a number that should bother you: zero.

That is how many blockchains have a working, production-grade subscription billing primitive. Not Ethereum. Not Solana. Not Polygon. Zero.

This is not because nobody tried. It is because every previous attempt ran into the same wall. Let me walk you through what happened, why it failed, and what finally makes it possible.

The graveyard of Ethereum attempts

In 2018, Kevin Owocki proposed EIP-1337, a subscription standard for Ethereum. The concept was elegant: a subscriber pre-authorizes a smart contract to pull tokens on a recurring schedule. The contract calls transferFrom() each period. Clean. Simple. Dead on arrival.

The reason? A single Ethereum L1 transaction costs $2-10 in gas. Sometimes $50 during congestion. If you are charging someone $9.99/month for a newsletter, the gas fee alone is more than the subscription. The economics do not work. They never worked. EIP-1337 was abandoned.

EIP-948 tried a different angle, baking subscription support directly into the token standard. But this required every token to implement a new interface. Existing tokens like USDC, DAI, and WETH would need to be redeployed. That is a non-starter when billions of dollars sit in contracts that cannot be upgraded.

Chainlink Automation came later, offering cron-like execution on EVM chains. But it requires LINK staking, keeper network registration, and still faces the gas cost problem on L1. On L2s, gas is cheaper but you lose composability with mainnet liquidity.

Every attempt hit the same wall: transaction costs destroy micro-billing economics.

Here is how the math works on Ethereum vs Stellar for a $9.99/month subscription:

The difference is not incremental. It is the difference between "impossible" and "obvious."

What changed with Stellar

Stellar was not designed to solve this problem specifically. But its properties make on-chain subscriptions not just possible. They make them obvious.

$0.00001 per transaction

Five zeros after the decimal point. You can bill a $1 subscription and the fee is invisible. You can bill daily. You can bill hourly. The economics always work.

5-second finality

No waiting for block confirmations. No 12-minute epochs. The subscriber sees the charge confirmed in their wallet within seconds.

Native USDC

Circle issues USDC directly on Stellar as a Stellar Asset Contract. No wrapped tokens. No bridges. No liquidity fragmentation. The stablecoin your subscribers hold is the stablecoin your contract charges.

SEP-41 token allowances

This is the technical key. Every Stellar token implements approve() and transfer_from(). A wallet holder can authorize another address to spend up to X tokens until ledger Y. A smart contract can then pull funds each billing period without any new wallet interaction.

From "impossible" to five lines of code

With Vowena, subscribing to a plan looks like this:

import { VowenaClient, toStroops } from "@vowena/sdk";

const xdr = await client.buildSubscribe(wallet.address, planId);
// Subscriber signs once. Billing recurs automatically.

That one signature covers both the contract call and the token approval. The subscriber's wallet shows exactly what they are authorizing: "Allow this contract to spend up to X USDC until ledger Y." Transparent. Auditable. Trustless.

Every subsequent billing period, a keeper (any automated script, or even a person) calls charge(). The contract verifies the conditions are met, calls transfer_from(), and moves USDC from subscriber to merchant. No new signatures. No wallet popups. No friction.

What this enables

The obvious use cases are SaaS subscriptions and membership billing in USDC. But the primitives are more powerful than that:

• Micro-subscriptions. Bill $0.01/day for API access. The fee is negligible.
• Creator memberships. A podcast charges $3/month in USDC with a 7-day free trial.
• DeFi management fees. A yield vault charges 0.1% monthly, pulled directly from deposited assets.
• Nonprofit recurring donations. Automated monthly giving with on-chain receipts.
• Cross-border subscriptions. A user in Lagos subscribes to a service in San Francisco. No currency conversion. No international card fees. Just USDC on Stellar.

Getting started

The fastest way to try Vowena is to install the SDK and create your first plan:

Then create a client and build your first subscription:

import { VowenaClient, NETWORKS, toStroops } from "@vowena/sdk";

const client = new VowenaClient(NETWORKS.mainnet);

// Create a plan
const planTx = await client.buildCreatePlan({
  merchant: wallet.address,
  token: NETWORKS.mainnet.usdcAddress,
  amount: toStroops("9.99"),
  period: 2_592_000, // 30 days
  priceCeiling: toStroops("14.99"),
  trialPeriods: 1,
  gracePeriod: 259_200, // 3 days
});

// Subscribe a user
const subTx = await client.buildSubscribe(subscriber.address, planId);

The documentation covers every function, every edge case, every error code. The source code is open on GitHub.

We are building the billing layer that Stellar has been missing. The infrastructure is ready. The subscription primitive was the missing piece.

Now it exists.