Developer Documentation

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

Architecture Overview

LYNX AUTH utilizes a secure web-based console backed by high-speed server routes. Authenticate user sessions, enforce subscription limits, and monitor client footprints in real time.

Base API Endpoint Address

All request code examples compile endpoints pointing to your server instance. To route requests locally, use http://127.0.0.1:8000. To query the production endpoint, use your hosted web domain.

Primary Core Capabilities

Key Concepts

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

Seller Security Scope

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

Developer Owner ID

Your unique identification string 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 container. 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.

Default License HWID State

Newly generated license keys are not locked to any machine hardware by default. The lock state can be activated manually inside the developer dashboard. When locked, the key binds permanently to the first machine that performs a successful login query.

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

Language Integration Templates

Python (requests) 
import requests
import platform
import hashlib

class LynxAuth:
    def __init__(self, ownerid, secret):
        self.ownerid = ownerid
        self.secret = secret
        self.url = "http://127.0.0.1:8000"

    def get_hwid(self):
        system_info = f"{platform.node()}-{platform.processor()}"
        return hashlib.sha256(system_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()
C# (HttpClient) 
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Text.Json;

public class LynxAuth
{
    private readonly string ownerid;
    private readonly string secret;
    private readonly string base_url = "http://127.0.0.1:8000";
    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($"{base_url}/api/1.0/user_login", content);
        return await res.Content.ReadAsStringAsync();
    }
}
C++ (libcurl) 
#include <iostream>
#include <string>
#include <curl/curl.h>

class LynxAuth {
private:
    std::string ownerid;
    std::string secret;
    std::string base_url = "http://127.0.0.1:8000";

    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 post_request(const std::string& endpoint, const std::string& json_data) {
        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, (base_url + endpoint).c_str());
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.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 user_login(std::string username, std::string password, std::string hwid) {
        std::string payload = "{\"ownerid\":\"" + ownerid + "\",\"app_secret\":\"" + secret + 
                              "\",\"username\":\"" + username + "\",\"password\":\"" + password + 
                              "\",\"hwid\":\"" + hwid + "\"}";
        return post_request("/api/1.0/user_login", payload);
    }
};
JavaScript (Fetch) 
class LynxAuth {
    constructor(ownerid, secret) {
        this.ownerid = ownerid;
        this.secret = secret;
        this.baseUrl = "http://127.0.0.1:8000";
    }

    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();
    }
}
cURL (Command Line) 
curl -X POST "http://127.0.0.1:8000/api/1.0/user_login" \
  -H "Content-Type: application/json" \
  -d '{"ownerid":"YOUR_OWNER_ID","app_secret":"YOUR_APP_SECRET","username":"YOUR_USER","password":"YOUR_PASSWORD","hwid":"YOUR_HWID"}'

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

Language Integration Templates

Python (requests) 
import requests
import platform
import hashlib

class LynxAuth:
    def __init__(self, ownerid, secret):
        self.ownerid = ownerid
        self.secret = secret
        self.url = "http://127.0.0.1:8000"

    def get_hwid(self):
        system_info = f"{platform.node()}-{platform.processor()}"
        return hashlib.sha256(system_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()
C# (HttpClient) 
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Text.Json;

public class LynxAuth
{
    private readonly string ownerid;
    private readonly string secret;
    private readonly string base_url = "http://127.0.0.1:8000";
    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($"{base_url}/api/1.0/license_login", content);
        return await res.Content.ReadAsStringAsync();
    }
}
C++ (libcurl) 
#include <iostream>
#include <string>
#include <curl/curl.h>

class LynxAuth {
private:
    std::string ownerid;
    std::string secret;
    std::string base_url = "http://127.0.0.1:8000";

    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 post_request(const std::string& endpoint, const std::string& json_data) {
        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, (base_url + endpoint).c_str());
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.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 license_login(std::string key, std::string hwid) {
        std::string payload = "{\"ownerid\":\"" + ownerid + "\",\"app_secret\":\"" + secret + 
                              "\",\"license_key\":\"" + key + "\",\"hwid\":\"" + hwid + "\"}";
        return post_request("/api/1.0/license_login", payload);
    }
};
JavaScript (Fetch) 
class LynxAuth {
    constructor(ownerid, secret) {
        this.ownerid = ownerid;
        this.secret = secret;
        this.baseUrl = "http://127.0.0.1:8000";
    }

    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();
    }
}
cURL (Command Line) 
curl -X POST "http://127.0.0.1:8000/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":"YOUR_HWID"}'

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