Commet
  • Pricing
Log InTry out

Subscription Billing Cycles: How They Work

How subscription billing cycles work: anchor dates, monthly and annual intervals, proration on mid-cycle plan changes, and how to automate recurring charges.


TL;DR

  • Subscription billing means automatic recurring charges: the customer subscribes to a plan and the system charges them at the start of every billing cycle, with no manual work.
  • The billing cycle anchors to the date the customer subscribed — not the calendar month. Someone who subscribes on the 15th pays on the 15th of every month.
  • When a customer changes plans mid-cycle, upgrades apply immediately with proration and downgrades wait until renewal. The billing date never moves.
  • Automating it takes three pieces: plans with a price and interval, a checkout that captures the payment method, and a billing engine that generates and charges invoices at every renewal.

What Is Subscription Billing?

Subscription billing is the model where a customer pays on a recurring schedule — typically monthly or annual — for ongoing access to a product. Instead of a one-time sale, the commercial relationship is a living contract: the customer subscribes to a plan, the system charges them automatically at the start of each period, and access continues as long as payments keep landing.

The central object is the subscription: the link between a customer and a plan. The plan defines what is included (features, quantities, seats) and what it costs per interval. The subscription defines since when, in which currency, and with which payment method. Everything else — invoices, renewals, failed-payment retries — derives from that link.

What separates subscription billing from manually charging someone every month is full automation of the cycle: the system generates the invoice, charges the saved card, issues the receipt, and retries when a payment fails. If your team has to remember to charge customers, that is not subscription billing — it is manual invoicing with a calendar. See recurring billing for the automated process in detail.

How Does a Billing Cycle Work?

The billing cycle is the window between two consecutive invoice dates. It anchors to the subscription date: a customer who subscribes on January 15 with a monthly interval pays on January 15, February 15, March 15. There is no global "billing day" for your product; every customer carries their own anchor date.

Three things happen inside every cycle, always in the same order:

  1. At the start, the plan's base price is charged upfront. If the plan includes usage quantities (API calls, credits, balance), they reset to their full amount.
  2. Throughout the cycle, the system records consumption: usage events, seats added, addons activated. Everything is attributed to the current period.
  3. At the close, the system takes a snapshot, calculates overage if consumption exceeded what was included, and issues the closing invoice: next period's base price plus any usage charges from the period that just ended.

The typical intervals are monthly, quarterly, and annual. Monthly cycles vary slightly in length because months have 28 to 31 days — the system uses the real days in the period, not a fixed assumption of 30. A subscription starting January 31 skips to the last day of February and returns to the 31st in March.

One detail that matters if you charge for usage: even on an annual plan, usage overage is evaluated on a monthly cadence. That prevents a customer from front-loading a year's worth of consumption against one giant annual quota.

What Happens When a Customer Changes Plans Mid-Cycle?

It depends on the direction of the change. The fair rule — and the one Commet applies by default — is: changes that benefit the customer apply immediately; changes that hurt them wait until renewal.

Upgrades: immediate, with proration. The customer gets a credit for the unused days on the old plan and a charge for those same days at the new plan's rate. Example: they are on Starter at $29/month, and on day 15 of a 30-day cycle they upgrade to Pro at $99/month. A $14.50 credit for the 15 unused days, a $49.50 charge for the 15 remaining days on Pro: they pay $35.00 net and get the new features instantly. Proration guarantees they never pay twice for the same days.

Downgrades: at the next renewal. The customer keeps their current plan's features until the end of the period they already paid for, and the cheaper plan starts with the new cycle. This avoids issuing credits larger than the new charge (which would force a refund to the card) and respects what the customer already bought.

The anchor date never moves. Changing plans does not reset the cycle. If the customer pays on the 10th, they keep paying on the 10th after the change. A predictable billing date eliminates an entire class of support tickets.

Usage-Based or Fixed Subscription Pricing?

Fixed subscriptions work when your cost to serve each customer is stable: same price every period, predictable revenue for you, predictable spend for the customer. It is the right model for most traditional SaaS.

Usage-based billing wins when cost varies widely per customer — APIs, AI products, infrastructure. If a heavy customer costs 100x more to serve than a light one and both pay $49/month, the heavy one destroys your margin. Consumption has to be in the price, through one of three models: metered (included quantity + overage), credits (prepaid blocks), or balance — a prepaid wallet where every event deducts the real cost. See balance billing for how that model works.

It is not a binary decision: the hybrid is the most common pattern in mature products. A fixed base subscription covers the predictable part, with a metered feature on top for the variable part. The plan stays $29/month; the AI feature gets 50,000 included tokens and overage beyond that. Both live in the same billing cycle and on the same invoice.

How Do You Automate Subscription Billing?

Define your plans with a price and interval, create the subscription from your code, and redirect the customer to checkout to capture the payment method. From there, every renewal generates and charges the invoice without you touching anything.

With @commet/node, creating a subscription is one call:

import { Commet } from "@commet/node";

const commet = new Commet({ apiKey: process.env.COMMET_API_KEY! });

const subscription = await commet.subscriptions.create({
  customerId: "user_123",
  planCode: "pro",
  billingInterval: "monthly",
});

redirect(subscription.data.checkoutUrl);

The customer completes payment at checkout, the subscription goes active, and subsequent cycles charge themselves. To verify access from your application, commet.subscriptions.getActive({ customerId }) returns the current subscription with its status.

What the platform you choose has to cover for the automation to be complete:

  • Correct cycles and proration. Real days in the period, a stable anchor date, immediate upgrades and renewal-time downgrades. If the cycle is wrong, every downstream invoice is wrong.
  • Failed payments handled. Cards expire and charges get declined. Dunning — automatic retries and reminders — is the difference between a recovered payment and a customer silently lost.
  • Taxes and compliance solved. Commet operates as a Merchant of Record: it is the legal seller, it calculates, collects, and remits taxes on every sale, and it handles refunds. It processes card payments, charges in local currency in 20+ markets, and pays out in local currency in 112 countries.
  • Simple pricing. Commet charges 4.5% + $0.40 per successful transaction, with no monthly fees — see pricing for details.

The Essentials

Subscription billing is automatic recurring charging anchored to a billing cycle that starts the day the customer subscribes and never moves. The base price is charged upfront at cycle start; overage is invoiced at the close. Upgrades apply immediately with proration, downgrades wait until renewal. If your cost per customer varies, add usage-based billing on top of the fixed base instead of choosing between them. And automate the entire cycle — invoices, charges, retries, taxes — so getting paid never depends on someone remembering.

Developers

  • Documentation
  • Templates
  • GitHub

Frameworks

  • Next.js
  • Remix
  • Nuxt
  • SvelteKit
  • Astro
  • Express
  • Hono
  • Django
  • FastAPI

Resources

  • Blog
  • Changelog
  • Pricing

AI

  • Agents
  • MCP Server
  • Agent Skills
  • Claude Code
  • Codex
  • Cursor

Learn

  • Guides
  • Glossary
  • Solutions
  • Billing for AI Models
  • Comparison

Compare

  • Stripe alternative
  • Orb alternative
  • Recurly alternative
  • Paddle alternative
  • Chargebee alternative
  • Lago alternative

Company

  • About
  • Open Source
  • Terms
  • Privacy

Countries

  • Mexico
  • Argentina
  • Colombia
  • Chile
  • Peru
  • Ecuador
  • Uruguay
  • Paraguay
  • Bolivia
  • Panama
  • El Salvador
  • Brazil
XLinkedInGitHub