Quick Start

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! Running app...")
    # Your app logic here; the signed session covers the grace period
else:
    print("Invalid license key.")
    exit(1)

using AuthForge;

var client = new AuthForgeClient(
    appId: "YOUR_APP_ID",
    appSecret: "YOUR_APP_SECRET",
    publicKey: "YOUR_PUBLIC_KEY"
);

Console.Write("Enter license key: ");
var key = Console.ReadLine() ?? "";

if (client.Login(key))
{
    Console.WriteLine("Authenticated! Running app...");
    // Your app logic here; the signed session covers the grace period
}
else
{
    Console.WriteLine("Invalid license key.");
    Environment.Exit(1);
}

#include "authforge_sdk.h"
#include <iostream>
#include <string>

int main() {
    authforge::AuthForgeClient client(
        "YOUR_APP_ID",
        "YOUR_APP_SECRET",
        "YOUR_PUBLIC_KEY"
    );

    std::string key;
    std::cout << "Enter license key: ";
    std::getline(std::cin, key);

    if (client.Login(key)) {
        std::cout << "Authenticated! Running app..." << std::endl;
        // Your app logic here; the signed session covers the grace period
    } else {
        std::cout << "Invalid license key." << std::endl;
        return 1;
    }

    return 0;
}

use authforge::{AuthForgeClient, AuthForgeConfig};

fn main() {
    let client = AuthForgeClient::new(AuthForgeConfig {
        app_id: "YOUR_APP_ID".into(),
        app_secret: "YOUR_APP_SECRET".into(),
        public_key: "YOUR_PUBLIC_KEY".into(),
        ..Default::default()
    });

    print!("Enter license key: ");
    let mut key = String::new();
    std::io::stdin().read_line(&mut key).unwrap();
    let key = key.trim();

    match client.login(key) {
        Ok(_) => {
            println!("Authenticated! Running app...");
            // Your app logic here; the signed session covers the grace period
        }
        Err(e) => {
            eprintln!("Login failed: {}", e);
            std::process::exit(1);
        }
    }
}

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"

    "github.com/AuthForgeCC/authforge-go"
)

func main() {
    client, err := authforge.New(authforge.Config{
        AppID:     "YOUR_APP_ID",
        AppSecret: "YOUR_APP_SECRET",
        PublicKey: "YOUR_PUBLIC_KEY",
    })
    if err != nil {
        fmt.Fprintf(os.Stderr, "Init failed: %v\n", err)
        os.Exit(1)
    }

    reader := bufio.NewReader(os.Stdin)
    fmt.Print("Enter license key: ")
    key, _ := reader.ReadString('\n')
    key = strings.TrimSpace(key)

    if _, err := client.Login(key); err != nil {
        fmt.Fprintf(os.Stderr, "Login failed: %v\n", err)
        os.Exit(1)
    }

    fmt.Println("Authenticated! Running app...")
    // Your app logic here; the signed session covers the grace period
}

import { AuthForgeClient } from '@authforgecc/sdk';
import * as readline from 'node:readline/promises';

const client = new AuthForgeClient({
    appId: 'YOUR_APP_ID',
    appSecret: 'YOUR_APP_SECRET',
    publicKey: 'YOUR_PUBLIC_KEY',
});

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const key = await rl.question('Enter license key: ');
rl.close();

if (await client.login(key)) {
    console.log('Authenticated! Running app...');
    // Your app logic here; the signed session covers the grace period
} else {
    console.error('Invalid license key.');
    process.exit(1);
}