Graceful license expiration with perpetual fallback access

When a software license expires, there are two ways to respond: cut the user off immediately, or give them a graceful path forward.

Most licensing systems default to the first option. The key returns an error, the app shows a lock screen, and the user has to deal with it. It is the simplest implementation, but it produces the worst outcome for users who let their license lapse because they were busy, offline, or simply forgot to renew.

Perpetual fallback is our answer to this. It is a product-level setting in Keyforge that changes the behavior of expired licenses: instead of becoming immediately invalid, they enter a fallbacked state that your app can handle differently from a full rejection.

How it works

When perpetual fallback is enabled on a product, an expired license returns fallbacked as its status instead of expired. Everything else about the license is unchanged: the key, the device activation, the owner information. Only the status value is different.

Your application checks the status and decides what access to grant:

const data = await res.json();

if (data.status === 'active') {
  // Full access
} else if (data.status === 'fallbacked') {
  // License expired - apply limited access logic
} else {
  // No valid license - prompt for a key
}

What "limited access" means is entirely up to you. Keyforge provides the status signal; your application decides what to do with it.

When to use it

Perpetual fallback is most valuable in three situations.

Subscriptions with user-generated content

If your product is subscription-based and users create or accumulate something of value during their subscription, a hard cutoff on expiry is particularly damaging. A user who cancels loses access to exports, files, settings, or history they built up over time.

With fallback enabled, you can let them retain read-only access to their existing content. They cannot create new things (that is the limited access), but they can still view and export what they already made. This is a far better experience, and it removes a common objection to subscribing in the first place: users are more willing to try a subscription when they know cancellation does not destroy their work.

Grace windows for re-subscription

A common churn pattern is involuntary: a card expired, a payment failed, and the subscription lapsed without the user intending to cancel. A hard cutoff in this scenario is both punishing and counterproductive.

Fallback combined with a date comparison gives you a configurable grace window:

const expiresAt = new Date(data.license.expiresAt);
const now = new Date();
const daysSinceExpiry = (now - expiresAt) / (1000 * 60 * 60 * 24);

if (data.status === 'fallbacked' && daysSinceExpiry < 7) {
  // Within grace window: show a renewal banner but maintain access
} else if (data.status === 'fallbacked') {
  // Grace window over: restrict to limited access
}

This pattern keeps the user inside your app and gives them a clear path to re-subscribe through the Keyforge customer portal, rather than losing them to frustration.

Timed one-time licenses

For one-time purchases with a fixed expiration (for example, a year of updates or access), perpetual fallback gives customers a reason to renew rather than a reason to circumvent.

If the app hard-blocks on expiry, a motivated user starts looking for workarounds. If the app degrades gracefully, showing a "your license has expired, here is what you are missing" message with a renewal link, the friction of circumventing it exceeds the friction of just renewing.

Keyforge's license renewal feature pairs naturally here: customers see the fallback state in the portal and can renew in a standard checkout flow, without contacting support.

Using fallback with offline apps

Perpetual fallback also works alongside Keyforge's JWT-based offline licensing. When a stored license token has expired and the user is offline, you can inspect the token payload to detect the expiry and apply the same limited-access logic on the client side.

The token itself carries the expiration claim as exp. Check it against the current time and decide whether the user is in a grace window or fully lapsed, then apply the appropriate access level. This mirrors the server-side fallback behavior and gives you a consistent experience whether the app is online or offline.

What perpetual fallback is not

It is worth being clear about what this feature does not do. Perpetual fallback is not a workaround for enforcement. A fallbacked license is explicitly expired: the subscription has ended or the timed period is over. The feature is about how you communicate that to the user and what limited access, if any, you choose to grant.

It is also not a substitute for handling payment failures. If a subscription payment fails, the right first response is to retry and notify the customer through your billing portal. Perpetual fallback access is the experience layer after that process has already run its course.

How to get started

Perpetual fallback access is enabled per product in the Keyforge dashboard. Open any product, find the perpetual fallback setting, and toggle it on. It is independent of any payment integration: it works whether you are using Stripe, Polar, Lemon Squeezy, or managing licenses manually.

If you are building a desktop app, see perpetual fallback access for desktop apps for specific patterns and real-world examples.