Charge For It: License Activation

This is the part that turns your app into a product. The licensing system is already built and running. What is missing is your answer to one question: is this key real?

What already works, before you write anything

Run the app and open the License screen:

• entering a key and activating it
• refusing a key, with a reason your UI can display
• storing the key encrypted by the operating system
• staying valid for 7 days with no network
• deactivating, back to unlicensed

Verified on a packaged build, not asserted:

activate "INVALID-TEST-KEY"    -> status invalid, reason "stub explicitly rejects this key"
activate "ESTK-4C9A-77B1-2F60" -> status active, masked "ESTK-****-****-2F60"
restart the app                -> still active
deactivate                     -> inactive

The key was checked against every file the app writes. It appears in plaintext in none of them.

The one thing you have to build

The bundled validator is a stub. It accepts any key you type, which is what you want while you build the screens, and exactly what you must not ship.

1. Ask for your validator

That last instruction is the one worth insisting on, and it is worth understanding why rather than trusting it.

2. The distinction that matters

A validated license keeps working for 7 days without a network. When revalidation fails because of a network problem, the user stays where they are and the clock keeps running. Only an explicit invalid answer from your backend revokes access.

Get that backwards and every customer on a plane, on hotel wifi, or behind a corporate proxy loses access to software they paid for. It is the single most expensive mistake in this file, and it is one line.

3. Check three things

1. isStub is false on your provider, or the startup warning stays.
2. A network failure throws, rather than returning { kind: 'invalid' }. Ask your agent to show you that branch specifically.
3. The provider is actually wired in. src/main/index.ts should pass yours to licenseManager.init({ provider: ... }).

4. Decide what unlicensed means

The template stores the state and shows it. What an unlicensed user can still do is your product decision, and it deserves a deliberate answer rather than a default.

Common choices: everything works but exports carry a watermark; a 14 day trial; the app opens read-only. Read licenseManager.current().status, which is one of inactive, active, invalid, or grace_expired.

If you want to read the code

import type { LicenseValidator, ValidationResult } from '../types';

class MyLicenseProvider implements LicenseValidator {
  readonly name = 'my-backend';
  readonly isStub = false;

  async validate(licenseKey: string): Promise<ValidationResult> {
    const res = await fetch('https://api.example.com/licenses/validate', {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ key: licenseKey }),
    });

    if (!res.ok) {
      // A network problem is NOT an invalid key. Throwing here keeps the user
      // inside the offline grace window instead of locking them out.
      throw new Error(`Validation endpoint returned ${res.status}`);
    }

    const data = await res.json();
    if (!data.valid) {
      return { kind: 'invalid', reason: data.reason ?? 'This key is not valid.' };
    }
    return { kind: 'valid', userEmail: data.email };
  }
}

export const myLicenseProvider = new MyLicenseProvider();

licenseManager.init({ provider: myLicenseProvider });

src/main/licensing/providers/README.md in the repo has skeletons for Gumroad, Lemon Squeezy and a plain custom endpoint.

Next: Make It Yours.