Shax Documentation & SDKs

{
  "license_key": "SHAX_SAMPLE_KEY_XXXX_YYYY",
  "application_id": "app_xxxxxxxxxxxxxxxx",
  "api_key": "sk_live_xxxxxxxxxxxxxxxx",
  "hwid": "client_hardware_uuid_or_hash"
}

{
  "success": true,
  "license": {
    "valid": true,
    "status": "ACTIVE",
    "expires_at": "2026-10-11T00:00:00.000Z"
  }
}

from sdk.python.shax import ShaxClient, ShaxError

client = ShaxClient(
    app_id="app_your_application_id",
    api_key="sk_live_your_api_key",
    base_url="http://localhost:3000"
)

try:
    # Activate or validate license
    result = client.activate("SHAX-YOUR-KEY")
    print("License valid! Expires:", result.get("expires_at"))
except ShaxError as e:
    print(f"Validation failed: [{e.code}] {e.message}")

#include "sdk/cpp/shax.hpp"

shax::Client client("app_your_id", "sk_live_your_key", "http://localhost:3000");

try {
    if (client.validate("SHAX-YOUR-KEY")) {
        std::cout << "License active and bound to HWID!" << std::endl;
    }
} catch (const shax::ShaxError& err) {
    std::cerr << "License error: " << err.what() << std::endl;
}

using Shax;

var client = new ShaxClient("app_your_id", "sk_live_your_key", "http://localhost:3000");

var response = await client.ValidateAsync("SHAX-YOUR-KEY");
if (response.Success) {
    Console.WriteLine("License authorized for this workstation.");
}

#include <iostream>
#include <fstream>
#include "sdk/cpp/shax.hpp"

const std::string LICENSE_FILE = "license.key";
shax::Client client("app_your_id", "sk_live_your_key", "http://localhost:3000");

bool auto_login_or_prompt() {
    std::ifstream infile(LICENSE_FILE);
    std::string saved_key;
    
    // Check if key is already saved from previous login
    if (infile >> saved_key && !saved_key.empty()) {
        std::cout << "[Auto-Login] Validating saved key against hardware..." << std::endl;
        try {
            if (client.validate(saved_key)) {
                std::cout << "[Auto-Login] Authorized! Launching software..." << std::endl;
                return true;
            }
        } catch (...) {
            std::cout << "[Auto-Login] Key expired or hardware changed. Removing..." << std::endl;
            std::remove(LICENSE_FILE.c_str());
        }
    }

    // First time user: Prompt for key
    std::cout << "Please enter your license key: ";
    std::string user_key;
    std::cin >> user_key;

    try {
        if (client.activate(user_key)) {
            std::ofstream outfile(LICENSE_FILE);
            outfile << user_key;
            std::cout << "Activated successfully! Saved for next launch." << std::endl;
            return true;
        }
    } catch (const shax::ShaxError& err) {
        std::cerr << "Activation failed: " << err.what() << std::endl;
    }
    return false;
}

using System;
using System.IO;
using System.Threading.Tasks;
using Shax;

class Program {
    static readonly string KeyPath = Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), 
        "MySoftware", 
        "license.key"
    );

    static async Task<bool> InitializeSoftwareAsync() {
        var client = new ShaxClient("app_your_id", "sk_live_your_key", "http://localhost:3000");

        // 1. Check for saved key (Auto-Login)
        if (File.Exists(KeyPath)) {
            string savedKey = (await File.ReadAllTextAsync(KeyPath)).Trim();
            var valResult = await client.ValidateAsync(savedKey);
            if (valResult.Success) {
                Console.WriteLine("[Auto-Login] Session verified! Launching...");
                return true;
            }
            File.Delete(KeyPath); // Invalidate bad key
        }

        // 2. Prompt user once
        Console.Write("Enter License Key: ");
        string inputKey = Console.ReadLine()?.Trim() ?? "";

        var actResult = await client.ActivateAsync(inputKey);
        if (actResult.Success) {
            Directory.CreateDirectory(Path.GetDirectoryName(KeyPath)!);
            await File.WriteAllTextAsync(KeyPath, inputKey);
            Console.WriteLine("[Activation] License activated and saved!");
            return true;
        }

        Console.WriteLine($"Error: {actResult.ErrorMessage}");
        return false;
    }
}