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"])

def handle_failure(reason: str, exception: Exception | None):
    if reason == "login_failed":
        print("Login failed; check your license key.")
    elif reason == "heartbeat_failed":
        print("Session check failed; saving state and shutting down.")
        save_application_state()
    # The SDK will exit after this callback returns if you don't handle it

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

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 signal
import sys
from authforge import AuthForgeClient

def on_auth_failure(reason, exception):
    print(f"Auth failure: {reason}")
    if exception:
        print(f"  Detail: {exception}")
    save_state()
    sys.exit(1)

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 True:
        # App logic here
        pass
except KeyboardInterrupt:
    save_state()