Developer Documentation

Welcome to the ultimate developer SDK reference for LYNX AUTH. Integrate high-performance, stateless client authentication, license activation, and hardware locking directly into your software.

What is Lynx Auth?

Lynx Auth is a complete backend-as-a-service designed specifically for desktop applications, tools, and scripts. It provides a highly secure bridge between your customer's computer and your database, allowing you to control exactly who can use your software.

Official Production Endpoint

All request code examples compile endpoints pointing to our live production server. Always route requests to https://api.lynxauth.qzz.io.

Primary Core Capabilities

Seamless client authorization with immediate response feedback.
Dynamic license activation utilizing isolated client software layers.
Automatic Hardware Identifier (HWID) generation and binding.
Comprehensive telemetry logging through customized Discord webhooks.

Architecture & Workflow

Understanding the secure flow of Lynx Auth is essential for protecting your applications.

1. The Developer Dashboard

You start by creating an Application inside the Lynx Auth dashboard. This generates a unique App Secret that connects your software to our servers securely.

2. Generating Access

Through the dashboard, you generate Users (username/password) or Licenses (single keys). You distribute these credentials to your legitimate customers.

3. The Software Integration

You paste our integration code into your application. When your customer opens your app, it automatically captures their hardware info and prompts for login details.

4. The Secure Handshake

Your app sends the credentials plus the HWID to the Lynx Auth API. The API validates the subscription status, checks the hardware lock, and grants or denies access instantly.

Security & HWID Locks

Understand variables, secure application environments, and hardware locking mechanisms.

Developer Security Scope

Credentials in LYNX AUTH are divided into two distinct entities to prevent sensitive developer keys from leaking:

Developer Owner ID: Your unique identifier associated with your master seller account. Visible inside the main dashboard panel details.
Application Secret Token: An app-level password generated for each created application. Executable builds rely on the App Secret to authenticate incoming queries.

Hardware Identifier (HWID) Binding

A unique physical fingerprint generated from the motherboard, username, or system hardware of the user. Helps limit access to authorized machines.

Automatic HWID Binding

When a customer logs in for the very first time, Lynx Auth records their HWID and locks the account to that specific computer. If they share their username and password with a friend, the friend's computer will generate a different HWID, and the API will block the login attempt.

Managing HWID Resets

If a legitimate customer buys a new computer or upgrades their hardware, their HWID will change, and they will be locked out. You can easily resolve this inside the Lynx Auth dashboard by clicking the "Reset HWID" button next to their username.

Creating Applications

Your first step inside the Lynx Auth dashboard.

Step-by-Step App Creation

1. Log in to your Lynx Auth dashboard panel.

2. Navigate to the Applications section and click Create App.

3. Provide a recognizable name for your software.

4. Once created, click on the application name to enter its isolated management space.

5. Inside the app space, note down your App Secret. You will need this for your code integration.

Managing Users & Access

Generate and control access for your customers.

Creating a New User

1. Open your application inside the dashboard.

2. Navigate to the Users tab.

3. Click Create User.

4. Enter the desired username and password for your customer.

5. Select the subscription duration.

6. Click Create. The user is now instantly active.

User Actions

Next to each user in the dashboard, you have several powerful control options:

Delete: Permanently removes the user.
Reset HWID: Clears their hardware lock so they can log in from a new machine.
Toggle Lock: Disables or enables the HWID lock entirely for that specific user.

User Authentication API

Verify user credentials and client system hardware details directly from your code.

POST /api/1.0/user_login

Validates registration credentials and binds active machine HWID variables.

Request Fields

Field	Type	Description
`ownerid`	String	Developer account identifier
`app_secret`	String	Isolated application key
`username`	String	Target customer username
`password`	String	Target customer password
`hwid`	String	Local machine identifier hash

Console Application Examples

Python (Console App)

import requests
import platform
import hashlib

class LynxAuth:
    def __init__(self, ownerid, secret):
        self.ownerid = ownerid
        self.secret = secret
        self.url = "https://api.lynxauth.qzz.io"

    def get_hwid(self):
        info = f"{platform.node()}-{platform.processor()}"
        return hashlib.sha256(info.encode()).hexdigest()

    def user_login(self, username, password):
        payload = {
            "ownerid": self.ownerid,
            "app_secret": self.secret,
            "username": username,
            "password": password,
            "hwid": self.get_hwid()
        }
        res = requests.post(f"{self.url}/api/1.0/user_login", json=payload)
        return res.json()

if __name__ == "__main__":
    auth = LynxAuth("YOUR_OWNER_ID", "YOUR_APP_SECRET")
    username = input("Enter Username: ")
    password = input("Enter Password: ")
    result = auth.user_login(username, password)
    print("Response:", result)
    if result.get("success"):
        print("Login Successful! Access Granted.")
    else:
        print("Login Failed:", result.get("message"))

C# (.NET Console App)

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Text.Json;

class Program
{
    static async Task Main(string[] args)
    {
        var auth = new LynxAuth("YOUR_OWNER_ID", "YOUR_APP_SECRET");
        Console.Write("Enter Username: ");
        string username = Console.ReadLine();
        Console.Write("Enter Password: ");
        string password = Console.ReadLine();

        string jsonResponse = await auth.UserLogin(username, password);
        Console.WriteLine("API Response: " + jsonResponse);
    }
}

public class LynxAuth
{
    private readonly string ownerid;
    private readonly string secret;
    private readonly string baseUrl = "https://api.lynxauth.qzz.io";
    private static readonly HttpClient client = new HttpClient();

    public LynxAuth(string ownerid, string secret)
    {
        this.ownerid = ownerid;
        this.secret = secret;
    }

    private string GetHwid()
    {
        var info = $"{Environment.MachineName}-{Environment.UserName}";
        using var sha = SHA256.Create();
        var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(info));
        return Convert.ToHexString(bytes).ToLower();
    }

    public async Task<string> UserLogin(string username, string password)
    {
        var payload = new { ownerid, app_secret = secret, username, password, hwid = GetHwid() };
        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        var res = await client.PostAsync($"{baseUrl}/api/1.0/user_login", content);
        return await res.Content.ReadAsStringAsync();
    }
}

C++ (Console App)

#include <iostream>
#include <string>
#include <curl/curl.h>

class LynxAuth {
private:
    std::string ownerid;
    std::string secret;
    std::string baseUrl = "https://api.lynxauth.qzz.io";

    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
        ((std::string*)userp)->append((char*)contents, size * nmemb);
        return size * nmemb;
    }

    std::string postRequest(const std::string& endpoint, const std::string& jsonPayload) {
        CURL* curl = curl_easy_init();
        std::string response;
        if (curl) {
            struct curl_slist* headers = NULL;
            headers = curl_slist_append(headers, "Content-Type: application/json");
            curl_easy_setopt(curl, CURLOPT_URL, (baseUrl + endpoint).c_str());
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonPayload.c_str());
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
            curl_easy_perform(curl);
            curl_easy_cleanup(curl);
        }
        return response;
    }

public:
    LynxAuth(std::string oid, std::string sec) : ownerid(oid), secret(sec) {}

    std::string userLogin(std::string username, std::string password, std::string hwid) {
        std::string payload = "{\"ownerid\":\"" + ownerid + "\",\"app_secret\":\"" + secret + 
                              "\",\"username\":\"" + username + "\",\"password\":\"" + password + 
                              "\",\"hwid\":\"" + hwid + "\"}";
        return postRequest("/api/1.0/user_login", payload);
    }
};

int main() {
    LynxAuth auth("YOUR_OWNER_ID", "YOUR_APP_SECRET");
    std::string username, password;
    std::cout << "Enter Username: ";
    std::cin >> username;
    std::cout << "Enter Password: ";
    std::cin >> password;

    std::string result = auth.userLogin(username, password, "CPP_DEMO_HWID");
    std::cout << "Response: " << result << std::endl;
    return 0;
}

JavaScript / Node.js (Console App)

const readline = require('readline');

class LynxAuth {
    constructor(ownerid, secret) {
        this.ownerid = ownerid;
        this.secret = secret;
        this.baseUrl = "https://api.lynxauth.qzz.io";
    }

    async userLogin(username, password, hwid) {
        const res = await fetch(`${this.baseUrl}/api/1.0/user_login`, {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({
                ownerid: this.ownerid,
                app_secret: this.secret,
                username: username,
                password: password,
                hwid: hwid
            })
        });
        return res.json();
    }
}

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const auth = new LynxAuth("YOUR_OWNER_ID", "YOUR_APP_SECRET");

rl.question('Enter Username: ', (username) => {
    rl.question('Enter Password: ', async (password) => {
        const result = await auth.userLogin(username, password, "NODE_HWID_DEMO");
        console.log("Authentication Response:", result);
        rl.close();
    });
});

Go (Console App)

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

type LynxAuth struct {
	OwnerID   string
	AppSecret string
	BaseURL   string
}

func (a *LynxAuth) UserLogin(username, password, hwid string) (string, error) {
	payload := map[string]string{
		"ownerid":    a.OwnerID,
		"app_secret": a.AppSecret,
		"username":   username,
		"password":   password,
		"hwid":       hwid,
	}
	data, _ := json.Marshal(payload)
	resp, err := http.Post(a.BaseURL+"/api/1.0/user_login", "application/json", bytes.NewBuffer(data))
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	return string(body), nil
}

func main() {
	auth := &LynxAuth{OwnerID: "YOUR_OWNER_ID", AppSecret: "YOUR_APP_SECRET", BaseURL: "https://api.lynxauth.qzz.io"}
	var user, pass string
	fmt.Print("Enter Username: ")
	fmt.Scanln(&user)
	fmt.Print("Enter Password: ")
	fmt.Scanln(&pass)

	res, err := auth.UserLogin(user, pass, "GO_HWID_DEMO")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Response:", res)
}

License Activation API

Enable client activation routes using license activation keys directly without individual passwords.

POST /api/1.0/license_login

Authenticates client connection streams utilizing single license key mappings.

Request Fields

Field	Type	Description
`ownerid`	String	Developer account identifier
`app_secret`	String	Isolated application key
`license_key`	String	Unique LYNX key identifier
`hwid`	String	Local machine identifier hash

Console Application Examples

Python (Console App)

import requests
import platform
import hashlib

class LynxAuth:
    def __init__(self, ownerid, secret):
        self.ownerid = ownerid
        self.secret = secret
        self.url = "https://api.lynxauth.qzz.io"

    def get_hwid(self):
        info = f"{platform.node()}-{platform.processor()}"
        return hashlib.sha256(info.encode()).hexdigest()

    def license_login(self, key):
        payload = {
            "ownerid": self.ownerid,
            "app_secret": self.secret,
            "license_key": key,
            "hwid": self.get_hwid()
        }
        res = requests.post(f"{self.url}/api/1.0/license_login", json=payload)
        return res.json()

if __name__ == "__main__":
    auth = LynxAuth("YOUR_OWNER_ID", "YOUR_APP_SECRET")
    key = input("Enter License Key: ")
    result = auth.license_login(key)
    print("Response:", result)
    if result.get("success"):
        print("License Activated Successfully!")
    else:
        print("Activation Failed:", result.get("message"))

C# (.NET Console App)

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Text.Json;

class Program
{
    static async Task Main(string[] args)
    {
        var auth = new LynxAuth("YOUR_OWNER_ID", "YOUR_APP_SECRET");
        Console.Write("Enter License Key: ");
        string key = Console.ReadLine();

        string jsonResponse = await auth.LicenseLogin(key);
        Console.WriteLine("API Response: " + jsonResponse);
    }
}

public class LynxAuth
{
    private readonly string ownerid;
    private readonly string secret;
    private readonly string baseUrl = "https://api.lynxauth.qzz.io";
    private static readonly HttpClient client = new HttpClient();

    public LynxAuth(string ownerid, string secret)
    {
        this.ownerid = ownerid;
        this.secret = secret;
    }

    private string GetHwid()
    {
        var info = $"{Environment.MachineName}-{Environment.UserName}";
        using var sha = SHA256.Create();
        var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(info));
        return Convert.ToHexString(bytes).ToLower();
    }

    public async Task<string> LicenseLogin(string key)
    {
        var payload = new { ownerid, app_secret = secret, license_key = key, hwid = GetHwid() };
        var json = JsonSerializer.Serialize(payload);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        var res = await client.PostAsync($"{baseUrl}/api/1.0/license_login", content);
        return await res.Content.ReadAsStringAsync();
    }
}

C++ (Console App)

#include <iostream>
#include <string>
#include <curl/curl.h>

class LynxAuth {
private:
    std::string ownerid;
    std::string secret;
    std::string baseUrl = "https://api.lynxauth.qzz.io";

    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
        ((std::string*)userp)->append((char*)contents, size * nmemb);
        return size * nmemb;
    }

    std::string postRequest(const std::string& endpoint, const std::string& jsonPayload) {
        CURL* curl = curl_easy_init();
        std::string response;
        if (curl) {
            struct curl_slist* headers = NULL;
            headers = curl_slist_append(headers, "Content-Type: application/json");
            curl_easy_setopt(curl, CURLOPT_URL, (baseUrl + endpoint).c_str());
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonPayload.c_str());
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
            curl_easy_perform(curl);
            curl_easy_cleanup(curl);
        }
        return response;
    }

public:
    LynxAuth(std::string oid, std::string sec) : ownerid(oid), secret(sec) {}

    std::string licenseLogin(std::string key, std::string hwid) {
        std::string payload = "{\"ownerid\":\"" + ownerid + "\",\"app_secret\":\"" + secret + 
                              "\",\"license_key\":\"" + key + "\",\"hwid\":\"" + hwid + "\"}";
        return postRequest("/api/1.0/license_login", payload);
    }
};

int main() {
    LynxAuth auth("YOUR_OWNER_ID", "YOUR_APP_SECRET");
    std::string key;
    std::cout << "Enter License Key: ";
    std::cin >> key;

    std::string result = auth.licenseLogin(key, "CPP_DEMO_HWID");
    std::cout << "Response: " << result << std::endl;
    return 0;
}

JavaScript / Node.js (Console App)

const readline = require('readline');

class LynxAuth {
    constructor(ownerid, secret) {
        this.ownerid = ownerid;
        this.secret = secret;
        this.baseUrl = "https://api.lynxauth.qzz.io";
    }

    async licenseLogin(key, hwid) {
        const res = await fetch(`${this.baseUrl}/api/1.0/license_login`, {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({
                ownerid: this.ownerid,
                app_secret: this.secret,
                license_key: key,
                hwid: hwid
            })
        });
        return res.json();
    }
}

const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
const auth = new LynxAuth("YOUR_OWNER_ID", "YOUR_APP_SECRET");

rl.question('Enter License Key: ', async (key) => {
    const result = await auth.licenseLogin(key, "NODE_HWID_DEMO");
    console.log("Activation Response:", result);
    rl.close();
});

Go (Console App)

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

type LynxAuth struct {
	OwnerID   string
	AppSecret string
	BaseURL   string
}

func (a *LynxAuth) LicenseLogin(key, hwid string) (string, error) {
	payload := map[string]string{
		"ownerid":     a.OwnerID,
		"app_secret":  a.AppSecret,
		"license_key": key,
		"hwid":        hwid,
	}
	data, _ := json.Marshal(payload)
	resp, err := http.Post(a.BaseURL+"/api/1.0/license_login", "application/json", bytes.NewBuffer(data))
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	return string(body), nil
}

func main() {
	auth := &LynxAuth{OwnerID: "YOUR_OWNER_ID", AppSecret: "YOUR_APP_SECRET", BaseURL: "https://api.lynxauth.qzz.io"}
	var key string
	fmt.Print("Enter License Key: ")
	fmt.Scanln(&key)

	res, err := auth.LicenseLogin(key, "GO_HWID_DEMO")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Response:", res)
}

Terminal Testing & Auto-Auth

Learn how to test your authentication endpoints directly from your command line, and implement "Remember Me" / Auto-Login features in your software so your users don't have to enter their credentials every time they launch it.

1. Quick Testing via Command Line

You can test if your application logins work without writing a single line of code. Open your terminal (Command Prompt, PowerShell, or Bash) and run the following command. Just remember to replace YOUR_OWNER_ID and YOUR_APP_SECRET with your actual dashboard credentials.

Test User Login using cURL (Command Prompt / Terminal)

cURL Command

curl -X POST https://api.lynxauth.qzz.io/api/1.0/user_login \
-H "Content-Type: application/json" \
-d "{\"ownerid\": \"YOUR_OWNER_ID\", \"app_secret\": \"YOUR_APP_SECRET\", \"username\": \"TEST_USER\", \"password\": \"TEST_PASSWORD\", \"hwid\": \"TEST_HWID\"}"

Test License Login using cURL (Command Prompt / Terminal)

cURL Command

curl -X POST https://api.lynxauth.qzz.io/api/1.0/license_login \
-H "Content-Type: application/json" \
-d "{\"ownerid\": \"YOUR_OWNER_ID\", \"app_secret\": \"YOUR_APP_SECRET\", \"license_key\": \"YOUR_LICENSE_KEY\", \"hwid\": \"TEST_HWID\"}"

Test User Login using PowerShell (Windows)

PowerShell Command

Invoke-RestMethod -Uri "https://api.lynxauth.qzz.io/api/1.0/user_login" -Method Post -ContentType "application/json" -Body '{"ownerid":"YOUR_OWNER_ID", "app_secret":"YOUR_APP_SECRET", "username":"TEST_USER", "password":"TEST_PASSWORD", "hwid":"TEST_HWID"}'

2. Auto-Authentication / Remember Me

To create a smooth user experience, you should save the user's login details locally on their computer after their first successful login. Every time they open your app, you can load these saved details and authenticate them in the background without prompting them again.

Python Implementation (Auto-Auth)

This script saves the credentials to a local credentials.json file. If the file exists, it will try to log in automatically. If the auto-login fails, it will prompt the user for their credentials again.

Python (Auto-Auth Console App)

import os
import json
import requests
import platform
import hashlib

CONFIG_FILE = "credentials.json"

class AutoAuthApp:
    def __init__(self, ownerid, secret):
        self.ownerid = ownerid
        self.secret = secret
        self.url = "https://api.lynxauth.qzz.io"

    def get_hwid(self):
        info = f"{platform.node()}-{platform.processor()}"
        return hashlib.sha256(info.encode()).hexdigest()

    def login(self, username, password):
        payload = {
            "ownerid": self.ownerid,
            "app_secret": self.secret,
            "username": username,
            "password": password,
            "hwid": self.get_hwid()
        }
        try:
            res = requests.post(f"{self.url}/api/1.0/user_login", json=payload)
            return res.json()
        except Exception as e:
            return {"success": False, "message": str(e)}

    def save_credentials(self, username, password):
        with open(CONFIG_FILE, "w") as f:
            json.dump({"username": username, "password": password}, f)

    def load_credentials(self):
        if os.path.exists(CONFIG_FILE):
            try:
                with open(CONFIG_FILE, "r") as f:
                    return json.load(f)
            except Exception:
                return None
        return None

if __name__ == "__main__":
    app = AutoAuthApp("YOUR_OWNER_ID", "YOUR_APP_SECRET")
    creds = app.load_credentials()
    
    logged_in = False
    
    if creds:
        print("Saved credentials found. Attempting background login...")
        res = app.login(creds["username"], creds["password"])
        if res.get("success"):
            print("Auto-login successful! Welcome back.")
            logged_in = True
        else:
            print("Auto-login failed:", res.get("message"))
            
    if not logged_in:
        username = input("Enter Username: ")
        password = input("Enter Password: ")
        res = app.login(username, password)
        if res.get("success"):
            print("Login successful!")
            app.save_credentials(username, password)
            print("Credentials saved locally for next launch.")
        else:
            print("Login failed:", res.get("message"))

C# (.NET Auto-Auth)

Similar to Python, this C# example reads and writes local file settings to achieve auto-login on startup.

C# (Auto-Auth Console App)

using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Text.Json;

class Program
{
    private static readonly string configFile = "config.json";
    private static readonly string ownerId = "YOUR_OWNER_ID";
    private static readonly string appSecret = "YOUR_APP_SECRET";

    static async Task Main(string[] args)
    {
        UserCredentials creds = LoadSavedCredentials();
        bool authenticated = false;

        if (creds != null)
        {
            Console.WriteLine("Found saved credentials. Logging in...");
            authenticated = await PerformLogin(creds.Username, creds.Password);
        }

        if (!authenticated)
        {
            Console.Write("Enter Username: ");
            string user = Console.ReadLine();
            Console.Write("Enter Password: ");
            string pass = Console.ReadLine();

            if (await PerformLogin(user, pass))
            {
                SaveCredentials(user, pass);
                Console.WriteLine("Login successful and credentials saved!");
            }
            else
            {
                Console.WriteLine("Access Denied.");
            }
        }
    }

    static async Task PerformLogin(string username, string password)
    {
        using var client = new HttpClient();
        var payload = new
        {
            ownerid = ownerId,
            app_secret = appSecret,
            username = username,
            password = password,
            hwid = "CSHARP_HWID_AUTO"
        };
        var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
        try
        {
            var res = await client.PostAsync("https://api.lynxauth.qzz.io/api/1.0/user_login", content);
            using JsonDocument doc = JsonDocument.Parse(await res.Content.ReadAsStringAsync());
            return doc.RootElement.GetProperty("success").GetBoolean();
        }
        catch
        {
            return false;
        }
    }

    static void SaveCredentials(string username, string password)
    {
        var creds = new UserCredentials { Username = username, Password = password };
        File.WriteAllText(configFile, JsonSerializer.Serialize(creds));
    }

    static UserCredentials LoadSavedCredentials()
    {
        if (File.Exists(configFile))
        {
            try { return JsonSerializer.Deserialize(File.ReadAllText(configFile)); }
            catch { return null; }
        }
        return null;
    }
}

class UserCredentials
{
    public string Username { get; set; }
    public string Password { get; set; }
}

Discord Webhook Integration

Synchronize customer activity alerts instantly with designated Discord channels.

Once webhooks are configured inside the application parameters modal, LYNX dispatches embedded message payloads silently on each authentication attempt.

Webhook Embed Customizations

Enable activity triggers for user credentials or license activations.
Toggle options to display customer machine HWID strings.
Limit visibility of system credentials by modifying webhook permissions.