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
·
Pro sells at $49 to your existing customers.
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.

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.
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.
move | What happens |
|---|---|
keep | They stay on their version, with its price and features. |
period_end | Everything changes at their next renewal. Until then nothing in the current period changes. |
now | Features, 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.

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
Acme pays $49 on version 1 with 8 seats. Version 2 costs $59 and allows 5.
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.
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.
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.

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.
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
Pro sells at $49. You publish a draft at $59 as price-test.
Commet doesn't split traffic: you decide who gets the experiment by sending its code after the plan code.
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/node9.10 adds the draft, version, experiment and move methods onplans, plussubscriptions.changeVersion. Subscriptions returnplanVersionandscheduledVersionChange.The CLI adds commands such as
commet plans list-versions,commet plans create-moveandcommet subscriptions change-version.Two webhooks:
subscription.version_changedwhen a subscription changes version, andsubscription.version_change_canceledwhen a pending move will not happen.@commet/nexthandles them withonSubscriptionVersionChangedandonSubscriptionVersionChangeCanceled.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.