Sell offline apps

1. A static page has a Stripe Checkout button. The product is a $2.99 lifetime license.
2. Stripe tells AuthForge Commerce about the payment. Commerce creates a perpetual license with 5 seats and emails the key to the buyer.
3. The app runs as a 1-hour free trial until the buyer enters a key.
4. The app calls activate_offline once. AuthForge returns a lifetime .authforge file bound to that machine.
5. From then on the app starts from the file with no network calls, forever.

​

Before you start

• An AuthForge app (App ID, App Secret, public key).
• A Stripe account.
• One of the six SDKs in your app. The method is activate_offline in Python and Rust, activateOffline in Node.js, and ActivateOffline in Go, C# and C++. See Self-serve activation.

• Perpetual licenses. Licenses with an expiry are refused with offline_activation_requires_perpetual. Subscriptions and time-limited licenses are not supported.
• Seat-limited licenses. Unlimited-seat (shared) keys are refused with offline_activation_requires_seats.
• Apps that opted in. It is off by default. Otherwise the call fails with offline_activation_disabled.

​

What it costs

​

1. Turn on self-serve activation

curl -X PUT https://api.authforge.cc/v1/apps/YOUR_APP_ID \
  -H "Authorization: Bearer af_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{"offlineSelfServe": {"enabled": true}}'

​

2. Sell the license with Stripe

​

Create the product

​

Connect Commerce and map the price

​

Add the button to your page

<a href="https://buy.stripe.com/your_payment_link">Buy for $2.99</a>

<!-- or Stripe's embeddable button -->
<script async src="https://js.stripe.com/v3/buy-button.js"></script>
<stripe-buy-button buy-button-id="buy_btn_..." publishable-key="pk_live_..."></stripe-buy-button>

​

3. Build the app

1. If a license file exists and login_from_file accepts it, run. No network, no credits.
2. Otherwise, if the trial has time left, run in trial mode.
3. Otherwise, ask for the key and call activate_offline with the file path.

​

Full example with the trial timer (Python)

import json
import os
import sys
import time
from pathlib import Path

from authforge import AuthForgeClient, AuthForgeError

APP_DIR = Path(os.environ.get("LOCALAPPDATA") or Path.home() / ".local" / "share") / "MyTool"
LICENSE_PATH = APP_DIR / "license.authforge"
TRIAL_PATH = APP_DIR / "trial.json"
TRIAL_SECONDS = 60 * 60
BUY_URL = "https://example.com/buy"

MESSAGES = {
    "invalid_key": "That key is not valid. Check the email and try again.",
    "revoked": "This license has been deactivated.",
    "offline_activation_limit_reached": "This key is already activated on the maximum number of computers. Contact support to move it.",
    "hwid_mismatch": "This key has no free seat for this computer. Contact support.",
}

client = AuthForgeClient(
    app_id="YOUR_APP_ID",
    app_secret="YOUR_APP_SECRET",  # needed by activate_offline
    public_key="YOUR_PUBLIC_KEY",
)


def licensed() -> bool:
    return LICENSE_PATH.exists() and client.login_from_file(str(LICENSE_PATH))


def trial_seconds_left() -> int:
    APP_DIR.mkdir(parents=True, exist_ok=True)
    try:
        started = json.loads(TRIAL_PATH.read_text())["started"]
    except (OSError, ValueError, KeyError):
        started = time.time()
        TRIAL_PATH.write_text(json.dumps({"started": started}))
    return max(0, int(started + TRIAL_SECONDS - time.time()))


def activate() -> bool:
    key = input("License key: ").strip()
    try:
        client.activate_offline(key, path=str(LICENSE_PATH))
        return True
    except AuthForgeError as exc:
        print(MESSAGES.get(exc.code, f"Activation failed ({exc.code}). Try again later or contact support."))
        return False


if licensed():
    run_app()
elif (left := trial_seconds_left()) > 0:
    print(f"Trial: {left // 60} minutes left. Buy a lifetime license at {BUY_URL}")
    run_app(trial_seconds=left)  # your app stops or nags when the timer ends
elif activate():
    run_app()
else:
    sys.exit(1)

​

The activation pattern in every SDK

import os
import sys
from authforge import AuthForgeError

if not (os.path.exists(LICENSE_PATH) and client.login_from_file(LICENSE_PATH)):
    key = prompt_for_key()
    try:
        client.activate_offline(key, path=LICENSE_PATH)
    except AuthForgeError as exc:
        if exc.code == "offline_activation_limit_reached":
            show_error("This key is already activated on the maximum number of computers. Contact support.")
        else:
            show_error(f"Activation failed ({exc.code}).")
        sys.exit(1)

import fs from "node:fs";
import { AuthForgeError } from "@authforgecc/sdk";

if (!(fs.existsSync(LICENSE_PATH) && client.loginFromFile(LICENSE_PATH))) {
  const key = await promptForKey();
  try {
    await client.activateOffline(key, { path: LICENSE_PATH });
  } catch (error) {
    const code = error instanceof AuthForgeError ? error.code : "unknown_error";
    showError(code === "offline_activation_limit_reached"
      ? "This key is already activated on the maximum number of computers. Contact support."
      : `Activation failed (${code}).`);
    process.exit(1);
  }
}

if _, err := client.LoginFromFile(licensePath); err != nil {
	key := promptForKey()
	if err := client.ActivateOffline(key, licensePath); err != nil {
		if errors.Is(err, authforge.ErrOfflineActivationLimitReached) {
			log.Fatal("This key is already activated on the maximum number of computers. Contact support.")
		}
		log.Fatalf("Activation failed (%s).", authforge.ErrorCode(err))
	}
}

if client.login_from_file(LICENSE_PATH).is_err() {
    let key = prompt_for_key();
    if let Err(err) = client.activate_offline(&key, Some(Path::new(LICENSE_PATH))) {
        if err.code() == "offline_activation_limit_reached" {
            eprintln!("This key is already activated on the maximum number of computers. Contact support.");
        } else {
            eprintln!("Activation failed ({}).", err.code());
        }
        std::process::exit(1);
    }
}

if (!(File.Exists(licensePath) && client.LoginFromFile(licensePath)))
{
    var key = PromptForKey();
    try
    {
        client.ActivateOffline(key, licensePath);
    }
    catch (AuthForgeException ex)
    {
        ShowError(ex.Code == "offline_activation_limit_reached"
            ? "This key is already activated on the maximum number of computers. Contact support."
            : $"Activation failed ({ex.Code}).");
        Environment.Exit(1);
    }
}

if (!(std::filesystem::exists(licensePath) && client.LoginFromFile(licensePath))) {
  const std::string key = PromptForKey();
  try {
    client.ActivateOffline(key, licensePath);
  } catch (const authforge::AuthForgeError& e) {
    ShowError(e.code() == "offline_activation_limit_reached"
                  ? "This key is already activated on the maximum number of computers. Contact support."
                  : "Activation failed (" + e.code() + ").");
    return 1;
  }
}

• Sends one request to POST /auth/offline/activate with the key, this machine’s HWID (the same one login() would send) and a fresh nonce.
• Verifies the returned file locally (signature, app id, this machine’s HWID) before saving it. A file that fails is refused with offline_file_rejected and nothing is written.
• Writes the file to the path atomically and creates parent folders. If the write fails, you get file_write_failed; calling again returns the same file for free.
• Leaves the client in an offline session, exactly as after login_from_file: variables are available, no grace-period timer, no check-ins.
• Never calls your failure callback and never exits the process. A failed activation leaves any existing session alone. You decide what to show.

​

4. Show clear errors

​

5. Support buyers who change machines

• Same machine again (reinstall, deleted file, lost response): free, and the identical file comes back. It never counts twice.
• New or changed hardware: counts as a new machine and costs 2 credits.
• HWID resets do not help. A reset in the portal or dashboard frees seats, but never machine slots, because the old machine’s file keeps working.
• Cap reached: the app gets offline_activation_limit_reached and tells the buyer to contact you.

• Release an offline machine on the license page in the dashboard, or with DELETE /v1/licenses/{licenseKey}/offline-machines/{hwidHash}. This frees one machine slot and that machine’s seat. The released machine’s file keeps working, so release only when you trust the request (for example “my old PC died”). GET /v1/licenses/{licenseKey}/offline-machines lists the machines.
• Raise the license’s HWID slots in the dashboard (up to 16).
• Mint a file by hand for a specific HWID (Offline license files). Hand-minted files do not count against the machine cap.

​

What this does not do

• No time-limited licenses. Subscriptions and fixed-term licenses cannot self-activate. Use online login() and the grace period for those.
• No unbound files at checkout. Every self-serve file is bound to one machine’s HWID.
• No remote kill. Refunds, chargebacks and revocation stop new activations only. Issued files keep working.

​

Checklist

• Self-serve offline activation turned on for the app
• Stripe price mapped as a one-time purchase with blank access length and several HWID slots
• Refund and dispute events subscribed, accepting that they cannot reach issued files
• Buyer email on, with your support contact in the portal policy
• App build has the App ID, App Secret and public key
• Launch order: file, then trial, then key prompt + activate_offline with a path
• Clear message for offline_activation_limit_reached that points to support
• Credit balance or auto-refill for activations that happen long after the sale

​

Next steps

• Offline license files: the feature in detail
• Commerce: the managed Stripe and Lemon Squeezy pipeline
• Offline licensing best practices: choosing between air-gapped files, self-serve activation and online activation