Key Information

Retrieves detailed information about a license key from the server.

This function returns comprehensive license details in JSON format.

Signature

std::string GetKeyInfo(const std::string& licenseKey);

Parameters

licenseKey

Type: std::string

Description: The license key to query

Format: "XXXX-XXXX-XXXX-XXXX"

Required: Yes

Returns

Type: std::string

Value	Description
JSON string	License information
Empty string	Error or license not found

Description

This function queries the server for detailed information about a license key, including:

• License status (active, expired, suspended)

• Creation and expiration dates

• HWID binding information

• Device limits

• User information

• Custom notes

You must call SendHeartbeat() before using this function.

Basic Example

qPapel::ProtectedAuth auth;
auth.Init(config);
auth.SendHeartbeat();

std::string info = auth.GetKeyInfo("XXXX-XXXX-XXXX-XXXX");

if (!info.empty()) {
    std::cout << info << std::endl;
} else {
    std::cerr << "Error: " << auth.GetLastError() << std::endl;
}

Response Format

The function returns a JSON string with the following structure:

{
  "license_key": "XXXX-XXXX-XXXX-XXXX",
  "status": "active",
  "created_at": "2024-01-15T10:30:00Z",
  "expires_at": "2025-01-15T10:30:00Z",
  "hwid_bound": "ABC123DEF456...",
  "max_devices": 1,
  "current_devices": 1,
  "user_email": "[email protected]",
  "note": "Customer #12345",
  "product_name": "Premium Loader",
  "tier": "premium"
}

Parsing JSON Response

Manual Parsing

std::string info = auth.GetKeyInfo(licenseKey);

if (!info.empty()) {
    // Check status
    if (info.find("\"status\":\"active\"") != std::string::npos) {
        std::cout << "License is active" << std::endl;
    }
    
    // Check expiration
    if (info.find("\"expires_at\":null") != std::string::npos) {
        std::cout << "Lifetime license" << std::endl;
    }
}

With JSON Library

Display Raw

Use Cases

Display License Details

std::string info = auth.GetKeyInfo(licenseKey);

if (!info.empty()) {
    std::cout << "=== License Information ===" << std::endl;
    std::cout << info << std::endl;
    std::cout << "===========================" << std::endl;
}

Check Expiration

Check Device Limit

Verify Tier

Response Fields

Field	Type	Description
license_key	string	The license key
status	string	active, expired, or suspended
created_at	string	ISO 8601 timestamp
expires_at	string/null	ISO 8601 timestamp or null for lifetime
hwid_bound	string/null	Bound hardware ID or null
max_devices	number	Maximum allowed devices
current_devices	number	Currently registered devices
user_email	string	Associated user email
note	string	Custom note from dashboard
product_name	string	Product name
tier	string	License tier (if applicable)

Error Handling

std::string info = auth.GetKeyInfo(licenseKey);

if (info.empty()) {
    std::string error = auth.GetLastError();
    
    if (error.find("not found") != std::string::npos) {
        std::cout << "License key does not exist" << std::endl;
    }
    else if (error.find("network") != std::string::npos) {
        std::cout << "Network error - check connection" << std::endl;
    }
    else {
        std::cout << "Error: " << error << std::endl;
    }
} else {
    // Process license info
    std::cout << info << std::endl;
}

Complete Example

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

void DisplayLicenseInfo(qPapel::ProtectedAuth& auth, const std::string& key) {
    std::cout << "\nFetching license information..." << std::endl;
    
    std::string info = auth.GetKeyInfo(key);
    
    if (!info.empty()) {
        std::cout << "\n=== License Information ===" << std::endl;
        
        // Clean up escaped newlines
        size_t pos = 0;
        while ((pos = info.find("\\n", pos)) != std::string::npos) {
            info.replace(pos, 2, "\n");
            pos += 1;
        }
        
        std::cout << info << std::endl;
        std::cout << "===========================" << std::endl;
        
        // Check specific fields
        if (info.find("\"status\":\"active\"") != std::string::npos) {
            std::cout << "\nStatus: Active" << std::endl;
        }
        
        if (info.find("\"expires_at\":null") != std::string::npos) {
            std::cout << "Type: Lifetime License" << std::endl;
        }
        
    } else {
        std::cerr << "Failed to retrieve license info" << std::endl;
        std::cerr << "Error: " << auth.GetLastError() << std::endl;
    }
}

int main() {
    qPapel::AuthConfig config;
    config.apiKey = "pk_your_api_key";
    config.productSecretKey = "your_secret_key";
    config.productHmacKey = "your_hmac_key";
    
    qPapel::ProtectedAuth auth;
    auth.Init(config);
    
    if (auth.SendHeartbeat()) {
        std::string licenseKey;
        std::cout << "Enter license key: ";
        std::cin >> licenseKey;
        
        DisplayLicenseInfo(auth, licenseKey);
    }
    
    return 0;
}

Web Dashboard

License information is managed from Dashboard → Keys

1

View License Details

Navigate to Dashboard → Keys, find the license in the table, and view details such as:

• Status badge (Active/Expired/Suspended)

• Creation and expiration dates

• Bound HWID

• Device count

• User information

2

Edit License Information

From the dashboard you can:

• Extend expiration — Add more time

• Reset HWID — Unbind from current device

• Suspend/Activate — Toggle license status

• Edit note — Update custom note

• View logs — See usage history

Best Practices

When to Use GetKeyInfo

• Displaying license details to user

• Checking expiration before critical operations

• Verifying tier for feature access

• Logging license information

• Troubleshooting license issues

Performance Consideration

GetKeyInfo makes a server request. Cache the result if you need to check multiple fields.

Related Functions

• ValidateKey - Validate license key

• GetSessionToken - Get session token

• SendHeartbeat - Required before GetKeyInfo