• Pricing
  • Blog
Log inBook a demo
Blog
November 9, 2026

Plan versions: change your pricing without duplicating plans

Plans now have versions. Edit in drafts, keep customers on earlier versions, see every version and run experiments that compete with the current one.

G
Guido Irigoyen·@guidooirigoyen

A SaaS plan changes many times. The price goes up, a feature is added, a limit goes down. The hard part is what happens to the customers who already pay for it.

Until now, every edit to a plan in Commet reached existing customers at their next renewal. If you wanted to keep someone on their old price, the only way out was to duplicate the plan. Over time the catalog filled up with copies of the same product, and it got hard to tell who paid what and why.

Now every plan has versions. The plan is the product, like Pro. A version holds its complete terms at a given moment: prices, trials, features, credit and balance rules, add-ons, credit packs and country prices. Every subscription is pinned to one version, and every new buyer gets the current one.

Change a price without a copy#

When it helps: you want new buyers to pay $59 for Pro while the customers who signed up at $49 keep their price. Before, that meant a second plan to maintain. Now it is a new version of the same plan.

Duplicate the plan

Pro · $49

·

Publish a version

Pro · version 1 · $49

·

1/4

Pro sells at $49 to your existing customers.

Duplicating the plan leaves you with Pro and Pro 2, a checkout to repoint and every later change made twice. Publishing a version keeps one Pro: version 2 sells $59 to new buyers, and earlier subscribers stay on the version they bought.

In the dashboard, the first change you make to a plan opens a draft from the version you are viewing. Nobody sees it until you publish it. You can keep several drafts open, undo each change on its own from Changes in this draft, and discard the draft. Name, description and visibility are not versioned: they apply at once.

A draft of Pro from version 1 with two changes, the monthly price from $49.00 to $59.00 and the yearly price from $490.00 to $590.00, each with Undo, and the Discard draft and Review and publish buttons.

Through the SDK, prepare the draft and publish it. Each block you send replaces that block, so prices lists every interval the draft sells. Prices are in USD cents.

new-price.ts
const draft = await commet.plans.createDraft({ id: "pln_pro" });

await commet.plans.updateDraft({
  id: "pln_pro",
  draftId: draft.id,
  prices: [
    { billingInterval: "monthly", price: 5900, isDefault: true },
    { billingInterval: "yearly", price: 59000 },
  ],
});

await commet.plans.publishDraft({
  id: "pln_pro",
  draftId: draft.id,
  publishAs: "current",
  move: "keep",
});

Send preview: true to publishDraft first to check everything without publishing. Any other plan edit through the SDK, API, CLI or MCP publishes a new current version at once and moves nobody.

Choose what happens to existing customers#

When you publish a version, you choose what happens to subscribers of earlier versions. Only you move them; Commet never moves anyone on its own.

moveWhat happens
keepThey stay on their version, with its price and features.
period_endEverything changes at their next renewal. Until then nothing in the current period changes.
nowFeatures, limits and included credits or balance change today, without resetting usage. The new price is charged from the next renewal.

A move never prorates or refunds, and it keeps the subscription's currency, country, interval and price. A customer on an older version is not a special case: they live there until you decide to move them.

Step 2 of 3 of publishing: move subscribers to version 2, with Keep them on their version, Move them at their next renewal selected, and Move them now.

Nobody moves without fitting#

When it helps: version 2 allows 5 seats and Acme uses 8. Moving Acme blindly would break their account. Commet checks every subscriber against the new version first, and if one doesn't fit, nobody moves until you decide what happens to them.

Keep them on their version

Acme · version 1 · $49

·

Move them at renewal

Acme · version 1 · move waits

409 subscribers_do_not_fit · 8 seats > 5

1/3

Acme pays $49 on version 1 with 8 seats. Version 2 costs $59 and allows 5.

Kept on version 1, Acme renews at $49 with its 8 seats. Moved at renewal, the move waits because 8 seats don't fit version 2. With a change that lowers its seats to the limit, Acme renews on version 2 at $59 with 5 seats, and Commet sends subscription.version_changed.

A move that doesn't fit fails with 409 subscribers_do_not_fit and lists each subscriber with the reasons. Send a change for each one in changes, applied at its renewal: another interval, seats at the version's limit, add-ons to stop charging, or keeping it on its version. See Resolve conflicts for every change.

move-subscribers.ts
await commet.plans.createMove({
  id: "pln_pro",
  fromVersionId: "plr_v1",
  toVersionId: "plr_v2",
  effective: "period_end",
  changes: [{ subscriptionId: "sub_acme", seatLimit: true }],
});

To move a single subscription, use subscriptions.changeVersion. Repeating the same request changes nothing, and a new one replaces the pending move.

change-version.ts
await commet.subscriptions.changeVersion({
  id: "sub_acme",
  planVersionId: "plr_v2",
  effective: "period_end",
});

If a scheduled move no longer fits when the renewal arrives, the subscription renews on its version and appears under Needs a change. Move it again with a change, or leave it with plans.keepSubscriberOnVersion.

Every version in sight#

The plan page in the dashboard shows the whole history:

  • Versions lists every published version with what changed in each, and the plan's drafts.

  • Subscribers shows each subscriber's version and any pending move with its date.

  • Moves shows how many subscribers moved, are on track, need a change or were left out, and cancels a move not yet finished.

The Versions tab of Pro: a draft from version 3, version 3 as current with team members from 3 to 5, version 2 with the monthly price from $49 to $59, and version 1.

Through the SDK, plans.listVersions returns the versions newest first with their subscription counts, and plans.compareVersions returns every term that differs between two of them.

compare-versions.ts
const changes = await commet.plans.compareVersions({
  id: "pln_pro",
  versionId: "plr_v2",
  against: "plr_v1",
});

Experiments: versions that compete#

When it helps: you think Pro could sell at $59 but don't want to change it for everyone yet. An experiment sells a version only to the buyers you send to it, while everyone else keeps buying the current version.

planCode: pro

Pro · version 2 · $49

·

planCode: pro:price-test

price-test 1 · $59

experiment running

1/4

Pro sells at $49. You publish a draft at $59 as price-test.

The plan code pro keeps selling version 2 at $49 while pro:price-test sells $59. When the experiment works, making it current turns its version into version 3, its subscribers stay where they are, and both codes sell version 3 from then on.

Commet doesn't split traffic: you decide who gets the experiment by sending its code after the plan code.

experiment.ts
const draft = await commet.plans.createDraft({ id: "pln_pro" });

await commet.plans.updateDraft({
  id: "pln_pro",
  draftId: draft.id,
  prices: [
    { billingInterval: "monthly", price: 5900, isDefault: true },
    { billingInterval: "yearly", price: 59000 },
  ],
});

await commet.plans.publishDraft({
  id: "pln_pro",
  draftId: draft.id,
  publishAs: "experiment",
  experimentCode: "price-test",
});

await commet.subscriptions.create({
  customerId: "user_123",
  planCode: "pro:price-test",
});

await commet.plans.makeExperimentCurrent({
  id: "pln_pro",
  code: "price-test",
});

If it doesn't work, plans.archiveExperiment stops selling it. Its code sells the current version, so links already shared keep working, and you choose whether its subscribers stay, move at renewal or move now.

Prices by country in each version#

Each version sets its countries with their own currency and prices. One version can charge $29 in Uruguay and $49 in the United States. If a country you sell is missing a price, publishing stops and names the country. Market prices are not versioned: a subscription that pays one keeps paying it through every move.

If you already use Commet#

Your plans already have their current version, and every subscription is pinned to a version of its plan. The Subscribers tab shows each one's version and any pending move.

One behavior changes: editing a plan no longer reaches existing subscribers at their renewal. An edit from the dashboard, the SDK, the API, the CLI or MCP publishes a new version for new buyers and moves nobody. If your integration changes a price or a feature expecting every customer to get it, move them after the edit with plans.createMove, or publish the draft with move: "period_end".

SDK, CLI, MCP and webhooks#

  • @commet/node 9.10 adds the draft, version, experiment and move methods on plans, plus subscriptions.changeVersion. Subscriptions return planVersion and scheduledVersionChange.

  • The CLI adds commands such as commet plans list-versions, commet plans create-move and commet subscriptions change-version.

  • Two webhooks: subscription.version_changed when a subscription changes version, and subscription.version_change_canceled when a pending move will not happen. @commet/next handles them with onSubscriptionVersionChanged and onSubscriptionVersionChangeCanceled.

  • The Commet skill knows plan versions, so your coding agent can set them up for you: npx skills add commet-labs/skills.

Start#

Open any plan in the dashboard to see its current version. Your existing customers stay where they are: nothing moves until you move them. If you kept duplicated plans for small changes, this is the moment to bring them back into one. Read Plan Versions for the full reference.

Subscription billing built for developers and agents

Get startedBook a demo

Accept global payments, handle usage-based pricing, subscriptions, and seats — without building your own infrastructure.

Frameworks

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

Resources

  • Documentation
  • Guides
  • Blog
  • Templates
  • Changelog
  • Glossary
  • Billing for AI models

Company

  • Solutions
  • About
  • Open Source

Compare

  • Stripe Billing
  • Orb
  • Chargebee
  • Lago
  • Autumn
  • Yuno

AI

  • Commet Agents
  • MCP Server
  • Skills
  • Skills on GitHub
  • Claude Code
  • Codex
  • Cursor
Follow us
© 2026 Commet Co.TermsPrivacy PolicyCookie Policy