Installation and setup of the macOS SDK

Install

https://github.com/licenseman/licensemanager-swift

dependencies: [
    .package(url: "https://github.com/licenseman/licensemanager-swift", from: "1.0.0"),
],
targets: [
    .executableTarget(
        name: "MyApp",
        dependencies: [.product(name: "LicenseManagerKit", package: "licensemanager-swift")]
    ),
]

It needs macOS 13 or later, and Swift 6 (Xcode 16 or later). Versions follow semantic versioning : from: "1.0.0" gets every 1.x release.

Create the license manager

import LicenseManagerKit
 
let licenseManager: LicenseManager = {
    do {
        return try LicenseManager(
            productID: "x7Kp2QaZ",
            publicKey: """
            -----BEGIN PUBLIC KEY-----
            MCowBQYDK2VwAyEA…
            -----END PUBLIC KEY-----
            """
        )
    } catch {
        fatalError("LicenseManager: \(error.localizedDescription)")
    }
}()

Then show your app, or the activation screen, depending on the state. With SwiftUI, see LicenseObserver.

What happens on creation

LicenseManager.init returns right away. Then, in the background:

1. It reads the stored key. No key: the state is .missingKey as soon as init returns, and ready() returns it.
2. With a key and a valid stored token, the state becomes .active, and ready() returns it right away. The online validation runs in the background: when it refuses the license, the state changes.
3. With a key but no valid stored token, it validates the key online, retrying for up to 30 seconds, and ready() returns once it’s done, with .active or the reason the app is locked.
4. It starts the clock check, now and every hour.

init throws a ConfigError only for a mistake in your code: an empty product id (.missingProductID) or public key (.missingPublicKey), a public key that isn’t an Ed25519 key in PEM format (.invalidPublicKey), or no version (.missingVersion, see below). You’ll see it the first time you run the app. Everything else, a locked Keychain, no network, an unreadable machine id, is handled without failing.

Options

try LicenseManager(
    productID: "x7Kp2QaZ",                        // both required
    publicKey: publicKey,
    options: .init(
        fingerprint: .provider { readMyID() },    // default: the Mac's hardware UUID
        version: "2.3.1",                         // default: CFBundleShortVersionString
        machineName: "Jane's MacBook",            // default: the computer name
        platform: "macOS",                        // default: "macOS 26.5.1"
        minOfflineDuration: 3 * 24 * 60 * 60,     // default: zero, in seconds
        keychainService: "com.acme.photo",        // default: the bundle id
        useKeychain: true                         // default: false for ad-hoc signed builds
    )
)

version

By default, it’s your app’s Version (CFBundleShortVersionString, MARKETING_VERSION in Xcode), like 2.3.1: the same in debug and release builds. Executables without an Info.plist, like swift run ones, have none: pass version, or init throws .missingVersion.

machineName and platform

Both are sent with every validation, and replace what LicenseManager knows about the machine. The computer name is the one in System Settings > General > Sharing, like “Jane’s MacBook Pro”, which is what makes machines easy to recognize in the customer portal. Pass your own value if you’d rather not send it.

One product per manager

A LicenseManager manages one product. An app selling several products, like an app and a paid plugin with their own licenses, can create one LicenseManager per product: their stored data and fingerprints are kept apart.

Development and release builds

Point your debug builds at a test product, and your release builds at the live one. Both share the same public key, which is one per organization:

#if DEBUG
let productID = "t3Hw9LmB"   // test product
#else
let productID = "x7Kp2QaZ"
#endif

A test key validated against the live product answers not_found, and the opposite too: the SDK shows .invalidKey.

Network access

The SDK makes two kinds of requests, with URLSession, without cookies or cache:

Both are HTTPS, so App Transport Security needs no exception. On a network that blocks them, or without the sandbox’s network entitlement, the SDK handles it like being offline.