Python SDK

pip install authforge-sdk

from authforge import AuthForgeClient

client = AuthForgeClient(
    app_id="YOUR_APP_ID",
    app_secret="YOUR_APP_SECRET",
    public_key="YOUR_PUBLIC_KEY",
)

license_key = input("Enter license key: ")

if client.login(license_key):
    print("Authenticated!")
    # Your app logic here; the signed session covers the grace period
else:
    print("Invalid license key.")
    exit(1)

client = AuthForgeClient(
    app_id="...",               # Required; from dashboard
    app_secret="...",         # Required for online login/validate; pass None or "" for login_from_file only
    public_key="YOUR_PUBLIC_KEY",  # Required; Ed25519 public key from your AuthForge dashboard (base64)
    online_heartbeat=False,   # Optional; True enables periodic online check-ins (/auth/heartbeat)
    heartbeat_interval=900,   # Optional; background timer cadence (check-ins when online, local session checks otherwise)
    api_base_url="https://auth.authforge.cc",  # Optional
    on_failure=None,          # Optional; callable(reason: str, exc: BaseException | None)
    request_timeout=15,       # Optional; HTTP timeout in seconds
    ttl_seconds=None,         # Optional; grace period (session TTL). None = server default (24h). Clamped to [3600, 604800].
    hwid_override=None        # Optional; custom identity (for example "tg:123456789")
)

success = client.login(license_key)

result = client.validate_license(license_key)
if result["valid"]:
    print(result["session_token"], result["app_variables"], result["license_variables"])
else:
    print(result["code"])

import sys
import threading
from authforge import AuthForgeClient, AuthForgeError

license_lost = threading.Event()

def handle_failure(reason: str, exc: Exception | None):
    if reason == "heartbeat_failed" and isinstance(exc, AuthForgeError) and exc.transient:
        # No verdict on the license: keep running. The SDK checks in again every
        # heartbeat_interval and reports session_expired (definitive) once the
        # ttl_seconds grace period is used up.
        print(f"AuthForge check-in failed ({exc.code}), retrying", file=sys.stderr)
        return
    code = exc.code if isinstance(exc, AuthForgeError) else exc
    print(f"License check failed: {reason} ({code})", file=sys.stderr)
    # This can run on the heartbeat thread: signal the main thread instead of exiting here.
    license_lost.set()

client = AuthForgeClient(
    app_id="YOUR_APP_ID",
    app_secret="YOUR_APP_SECRET",
    public_key="YOUR_PUBLIC_KEY",
    online_heartbeat=True,
    ttl_seconds=3600,  # retry window for transient check-in failures
    on_failure=handle_failure,
)

if not client.login(input("License key: ").strip()):
    sys.exit(1)

while not license_lost.is_set():
    do_one_unit_of_work()  # keep units short so the loop notices the signal quickly

save_application_state()
client.logout()
sys.exit(1)

if client.login(license_key):
    # App-wide variables (set in dashboard or API)
    app_vars = client.get_app_variables() or {}
    if app_vars.get("maintenanceMode"):
        print("Server is under maintenance.")
        exit(0)

    # Per-license variables
    license_vars = client.get_license_variables() or {}
    plan = license_vars.get("plan", "basic")
    if plan == "pro":
        enable_pro_features()

# Default: activate online, then run through the grace period (24h by default)
client = AuthForgeClient(
    app_id="...",
    app_secret="...",
    public_key="YOUR_PUBLIC_KEY",
    ttl_seconds=259200,  # Optional: extend the grace period to 3 days (clamped to 1h-7d)
)

# Strict policy: periodic online check-ins for fast revocation
client = AuthForgeClient(
    app_id="...",
    app_secret="...",
    public_key="YOUR_PUBLIC_KEY",
    online_heartbeat=True,
    heartbeat_interval=900,  # 15 minutes (default)
)

client = AuthForgeClient(app_id="APP_ID", app_secret=None, public_key="PUBLIC_KEY")

# Step 1 (customer machine): write an activation request the operator drops into the mint dialog.
client.write_activation_request("machine.authforge-request")

# Step 2 (customer machine, after you deliver the file): path or armored text.
if client.login_from_file("license.authforge"):
    info = client.get_offline_license()
    print("Offline license valid until", info["expires_at"] or "forever")
    print(client.get_license_variables())

import sys
import threading
from authforge import AuthForgeClient, AuthForgeError

license_lost = threading.Event()

def on_auth_failure(reason, exception):
    if reason == "heartbeat_failed" and isinstance(exception, AuthForgeError) and exception.transient:
        print(f"Check-in failed ({exception.code}); retrying on the next interval")
        return
    print(f"Auth failure: {reason}")
    if exception:
        print(f"  Detail: {exception}")
    # May run on the SDK's background thread: signal the main loop instead of exiting here.
    license_lost.set()

def save_state():
    print("Saving application state...")
    # Your save logic here

client = AuthForgeClient(
    app_id="YOUR_APP_ID",
    app_secret="YOUR_APP_SECRET",
    public_key="YOUR_PUBLIC_KEY",
    online_heartbeat=True,   # Optional strict policy: check in every 15 minutes
    heartbeat_interval=900,
    on_failure=on_auth_failure,
)

license_key = input("Enter license key: ")
if not client.login(license_key):
    print("Invalid license key.")
    sys.exit(1)

print("Licensed and running!")

# Check variables
app_vars = client.get_app_variables() or {}
min_version = app_vars.get("minVersion")
if min_version and __version__ < min_version:
    print(f"Please update to version {min_version} or later.")
    sys.exit(1)

# Your application main loop
try:
    while not license_lost.is_set():
        # App logic here
        license_lost.wait(1)
except KeyboardInterrupt:
    pass

save_state()
client.logout()
sys.exit(1 if license_lost.is_set() else 0)