Overview

After logging in, the left‑side navigation divides the site into four main areas:

• Operations – programs and licenses.
• E‑Commerce – products, referees, customers, orders and payments.
• Settings – user profile, organization, billing and balance.

Search boxes and "Add" buttons appear at the top of most pages, making it easy to find items and create new ones.

Operations

Dashboard

The dashboard summarises your organisation's usage. It displays counts of programs, total and active licences, and API hits, along with charts for licence creation and usage. Use it for a quick health check.

Programs

Purpose: Register software programs and their versions so that products and licences can reference them.

1. Go to Programs and click Add Program.
2. Enter a Program Name and Program Code (unique short identifier). Optionally upload a logo and write a description.
3. Optionally add Configuration parameters (key-value pairs) that will be included in license verification responses.
4. Click Create. The program appears in the table with actions to view (eye), edit (pencil) or delete (trash). The delete icon removes the program permanently.
5. To add a version, click the eye icon, then Add Version. Provide a version number, description and upload the program file. Versions appear beneath the program with actions to edit or delete.

Program Configuration

The Configuration field allows you to define custom parameters that are returned during license verification. These parameters become part of the cryptographic signature, ensuring they cannot be altered by clients. This provides a secure way to control program behavior and enforce policies directly from your license server.

Licences

Purpose: Generate activation keys that allow customers to use your program.

1. Navigate to Licences and click Add Licence.
2. Select the Program, type the Customer Email, set a Limit (devices allowed, 0 = unlimited) and an Expiry Date (or leave blank for unlimited).
3. Click Generate. A unique licence key appears; copy it or send via email. The licence list shows email, program and status (Active, Expired, etc.), with actions to view or edit a licence.

License Management

After creation, only the license status can be edited. Each license maintains its own list of activations, which can be managed based on the Activations Deletable flag. When enabled, users can delete individual activations if needed.

End users can manage their activations directly at www.checkmylicense.dev/myactivations, or you can integrate the activation management flow directly into your own website using the My Activations API together with a Turnstile Widget.

Turnstile Widgets

Turnstile widgets are used to protect the activation management API when you embed it into your own website. Each widget is backed by a Cloudflare Turnstile key pair and is registered in CheckMyLicense under your Organisation settings.

Step 1 — Create a Turnstile widget in Cloudflare

1. Log in to the Cloudflare dashboard and navigate to Turnstile in the left sidebar.
2. Click Add widget, give it a name, and enter the domain(s) where it will be used.
3. Choose a widget type (Managed is recommended) and click Create.
4. Copy the Site Key (public) and the Secret Key — you will need both in the next step.

Step 2 — Register the widget in CheckMyLicense

1. Go to Organisation (under Settings in the left navigation).
2. Scroll down to the Turnstile Widgets section.
3. Click Add Widget and fill in:
   • Description — a label for your own reference (e.g. “My Store Widget”).
   • Public Key — the Site Key you copied from Cloudflare.
   • Secret Key — the Secret Key you copied from Cloudflare (stored encrypted).
   • Status — set to Active.
4. Click Save. The widget now appears in the list with a truncated Widget ID and its Public Key.

Step 3 — Note your Organisation ID

An information bar at the top of the Turnstile Widgets section shows your Organisation ID. Keep this value alongside your widget's Public Key — both are required when calling the My Activations API from your website.

API Integration

CheckMyLicense provides a ready-to-use API for license operations that you can integrate directly with your programs:

• License Creation – programmatically generate licenses
• License Update – modify license status and parameters
• License Check – verify license validity and create activations

For detailed API documentation, parameters, and code examples, please refer to the API section of this help guide.

E‑Commerce

This section enables you to sell programs, reward affiliates, manage customers and handle orders and payments.

Products

Products allow you to commercialize your programs in different packages, offering flexibility in how you monetize your software. Each product can have its own configuration including different activation limits, validity periods, and pricing structures. This opens a wide range of possibilities for your commercial imagination—from offering trial versions with limited activations to premium packages with extended validity and unlimited devices.

Create a Product

1. Navigate to Products and select Add Product.
2. Specify a Title and Product Code, select the Program it belongs to and set the Currency and Price.
3. Mark Discountable if referral codes should apply discounts.
4. Define Limit (number of licences per purchase, 0 = unlimited) and Validity (days before licence expiry, 0 = no expiry).
5. Write a description for storefront display.
6. Click Create. The product appears with actions to view, edit or delete.

Referees and Referral Codes

Referees are affiliates who refer customers using referral codes.

Add Referee

1. Navigate to Referees and click Add Referee.
2. Provide the contact's email, first name and last name.
3. Enter phone number, country, state and address.
4. Click Save.
5. The referee appears in the list with actions to view or edit.

Note: There is no delete option; a referee can only be cancelled (deactivated).

Create Referral Code

Open a referee's detail page and click Add Referral. Enter a unique code and select whether the discount is Percentage Based or Fixed Amount. Provide the discount value, optionally select a Program to limit its scope, and set an Expiry Date (or leave blank for "Never expires").

If Allow Multiple Usage is checked, the code can be redeemed unlimited times; otherwise the usage limit is exactly one. You cannot set custom usage counts beyond one or unlimited.

Customers

To create an order, you must have a customer on file.

1. Go to Customers and click Add Customer.
2. Enter the Email, First Name, Last Name, Phone, Country, State and Address. Click Create.
3. The customer list shows names and emails with actions to view, edit or delete.

Note: Customers can be deleted as long as they don't have any orders associated with them. Once a customer has orders, they can only be deactivated if necessary.

Orders

Order Statuses

• Draft – created but not confirmed. Can be edited or cancelled. Payment cannot be recorded at this stage.
• Pending Payment – order confirmed and awaiting payment. At this status, you may record payments. Once the paid amount equals the order total the status becomes Paid; partial payments change the status to Partial Paid.
• Paid / Partial Paid – payment recorded. A backend job (runs hourly) automatically generates the associated licences. Paid orders can be cancelled within 24 hours; the status then changes to Refunded and another backend job deactivates the licences.
• Cancelled – order cancelled before payment; no licences generated.

Create an Order

1. Navigate to Orders and click Create Order. Select a Customer. Optionally choose a Referral Code; the discount value is calculated automatically.
2. Click Add Product, select the desired product and set the quantity. You may add multiple products. The order total and discount update in real time.
3. Click Create Order. A confirmation modal shows the order code and total. Confirming sets the status to Draft. Open the order details to review.
4. On the order details page, use the icons to Edit (pencil), Confirm (blue check) or Cancel (red icon). Confirming moves the order to Pending Payment; cancelling at this stage removes the order. There is no deletion; cancellation simply marks the order as cancelled.

Payments

Payments must correspond to orders that are Pending Payment (not Draft or already Paid). CheckMyLicense provides a payment screen to handle transactions directly through the platform.

Record a Payment

1. Go to Payments and click Add Payment.
2. Fill in the following details:
   • Order Code – e.g., ORD251017133003DR1
   • Amount – amount paid
   • Provider – name of the payment provider (e.g., cash, stripe, paypal)
   • Status – choose from Captured (successful), Failed, etc.
   • Payment Method and Provider Transaction ID – optional reference values
3. Click Record Payment. If the order status is Pending Payment, the payment is accepted and appears in the payments list. If the order is still Draft or already Paid, the system rejects the payment.

Payments update the Paid Amount field in the order. When total paid equals the order total, the order status changes to Paid. Licences are then generated automatically by the backend job.

Settings

User Profile

Use User Profile to manage your account:

• Upload or update your Profile Picture.
• Edit your Name, Email and Phone Number.
• Change your password via the Change Password dialog after entering your current password.

For Members: Users who are members of an organization (not administrators) have the option to leave the organization. However, leaving will result in loss of access to the organization's resources unless you are re-invited by an administrator.

Organization

This section contains organisation‑wide settings.

Administrator Role

Each organization has one administrator who has exclusive access to critical functions including:

• Managing billing and subscription plans
• Inviting and managing team members
• Accessing API integration keys
• Modifying organization-wide settings

Members are added to the organization via email invitation. The administrator can delegate their role to another team member through the Change Admin function, but doing so will transfer all administrative privileges to the new administrator and revoke them from the current one.

Organization Settings

1. Organization Information: Edit fields such as organisation name, type (Personal or Company), phone, email, country, website, Tax ID and billing address.
2. Email & SMTP Settings: Configure custom email settings to send transactional emails (license deliveries, notifications) from your own domain. If you don't have an SMTP server or prefer not to configure one, the platform will automatically use the built-in email service (checkmylicense@tradet.net) to send all emails on your behalf. This ensures your organization can function seamlessly without requiring SMTP configuration. When custom SMTP settings are configured, you can:
   • Set up SMTP Server – provide your SMTP host, port, username, and password for authentication.
   • Customize Email Sender – define the "from" email address and support email for your organization.
   • Test Configuration – send a test email to verify your SMTP settings are working correctly.
   • Update or Delete – modify your settings at any time or remove them to revert to the default platform email service.
   Note: Email settings are optional. Without custom SMTP configuration, all transactional emails will be sent from checkmylicense@tradet.net. Configure SMTP only if you need emails to come from your own domain for branding purposes.

3. API Keys: Manage your API authentication credentials for license verification operations. You can create up to 3 API keys, each consisting of a unique key (UUID) and secret that are auto-generated for security. Each API key can be:
   • Created – click Create API Key and provide a description (e.g., "Production API", "Development API").
   • Activated/Deactivated – edit the status to control which keys are currently valid for authentication.
   • Deleted – permanently remove keys you no longer need.
   • Copied – use the copy buttons to quickly copy the key or secret to your clipboard.
   • Hidden/Shown – toggle visibility of the key and secret values for security.
   Keep your API keys secure and do not share them publicly. Only active keys will authenticate successfully.
4. Members: Click Manage Members to view and manage your team. Each member entry shows name, email, role (ADMIN or MEMBER), status (Active or Suspended), invited and joined dates. Actions allow:
   • Invite Member – enter an email address to send an invitation link.
   • Change Admin – assign the admin role to another member.
   • Suspend – temporarily remove access from a member. Suspended members can be reactivated later.

There are no limits on the number of members you can invite at present.

Billing

The billing page displays your current consumption and estimated overage costs. You see your next billing date and the usage limits for programs, active licences and API hits. Exceeding these limits incurs overage charges depending on your subscription plan. A list of invoices appears once your organisation has billable transactions.

Subscription Plans

CheckMyLicense offers several subscription packages, each designed to meet different business needs. Plans include varying limits for programs, active licenses, and API hits, with options for overage support when you exceed included limits.

Available Plans

• Starter Kit (Free) – Perfect for getting started with basic features and community support.
• Pay as you Go – Flexible usage-based pricing with email support.
• Growth – Includes E‑Commerce support, email support, and overage capability for growing businesses.
• Pro – Enterprise-grade features with multi‑user support, priority support, and white‑labelled emails.

You can view your current subscription via Billing → Manage Subscription, which shows your active plan, billing period and included features. Use Cancel Subscription to stop billing, or upgrade to higher-tier packages as your business grows.

Balance and Add Credit

The Balance page shows your available credit (for overage fees) and a ledger of credit transactions.

Add Credit

1. Click Add Credit. Enter the amount and select a payment method:
   • Xpay (USDT TRC20) – redirects to the Xpay portal where you can complete the cryptocurrency payment.
   • PayPal – redirects to PayPal's SDK for processing.
   • Other Payment Method – opens a support form where you may arrange offline payment (e.g., bank transfer, cheque deposit). The operations team manually adds the credit after verifying the payment.
2. Check the box agreeing that credits will pay current and future dues.
3. Follow the external instructions to finish the payment. On returning, your balance will update.

Typical Workflow

Use the following steps to sell a program to a customer:

1. Create a Program and add a version under Operations → Programs.
2. Create a Product linked to that program under E‑Commerce → Products.
3. (Optional) Add a Referee and Referral Code if you wish to offer discounts.
4. Add a Customer under E‑Commerce → Customers.
5. Create an Order for the customer in Orders. Select the product, apply any referral code and confirm the order. The order enters Draft status.
6. Confirm the Order via the blue check icon on the order page. The status becomes Pending Payment.
7. Record Payment in Payments. Provide the order code, amount and provider details. Once payments cover the total, the order status becomes Paid and licences are generated automatically by the backend job (runs hourly).
8. Monitor Licences and Overage Usage in Operations → Licences and Settings → Billing.

Orders can be cancelled before payment or within 24 hours after payment (status changes to Refunded). There is no delete function; cancelling is the only way to void an order or referral.

Frequently Asked Questions

SDK Overview

CheckMyLicense provides Software Development Kits (SDKs) to simplify the integration of license verification into your applications. These SDKs handle all the complexity of encryption, API communication, and response parsing, allowing you to implement robust license protection with just a few lines of code.

Key Features

• Easy Integration – Add license verification with minimal code changes
• Secure Encryption – HMAC-SHA256 encryption for data signatures
• Offline Support – Cached offline tokens for verification without network access
• Program Configuration – Dynamic feature management via server-side configuration
• Detailed Error Handling – Clear error messages for troubleshooting

Available SDKs

To download the available SDKs, please visit your organization page: Available SDK section.

• MQL5 SDK (MetaTrader) – ✅ Production-Ready - Add license verification to MetaTrader 4 or 5 EA and indicators.
• Python SDK v3 – ✅ Production-Ready - Command-line tool and library with offline tokens, program configuration, and HMAC-SHA256 authentication.

MQL5

The MQL5 SDK enables seamless license verification for MetaTrader 5 Expert Advisors, Indicators, and Scripts. Protect your trading tools with enterprise-grade license management.

Installation

Prerequisites

• MetaTrader platform installed
• MetaEditor installed
• Active CheckMyLicense organization account
• Your organization's API Key and Secret (found in Settings → Organization)

Installation Steps

1. Download the SDK
2. Extract Files

   The SDK package contains two files:

   • CheckMyLicense.mqh – The reusable SDK library
   • SHA26.mqh – The reusable component for SHA-256 hashing
   • CheckMyLicense.mq5 – Example implementation script
3. Copy to MetaTrader Directory

   Copy CheckMyLicense.mqh and SHA26.mqh to your MetaTrader 5 Include folder:

   C:\Users\YourUsername\AppData\Roaming\MetaQuotes\Terminal\[TerminalID]\MQL5\Include\

4. Allow WebRequest URL

   In MetaTrader 5, go to Tools → Options → Expert Advisors and add the CheckMyLicense API URL to the list of allowed URLs:

   https://vwqretlvkrravzguxydw.functions.eu-west-2.nhost.run/v1

Quick Start

Basic Implementation

Add license verification to your Expert Advisor, Indicator, or Script:

1. Define Input Parameters

input string InpEmail = "";    // User's email
input string InpLicence = ""; // License key

2. Verify License OnInit for Expert Advisors

int OnInit()
{
    if(!CheckMyLicense(InpEmail, InpLicence))
    {
        Print("License verification failed!");
        return INIT_FAILED;
    }
    
    Print("License verified successfully!");
    return INIT_SUCCEEDED;
}

3. Verify License OnStart for Scripts

void OnStart()
{
    if(!CheckMyLicense(InpEmail, InpLicence))
    {
        Print("License verification failed!");
        return;
    }
    
    // Your script logic here
    Print("Running licensed script...");
}

Examples

Complete Expert Advisor Example

Here's a complete example of an Expert Advisor with license verification:

//+------------------------------------------------------------------+
//|                                            LicensedEA.mq5 |
//|                                  Copyright 2025, Your Company |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Your Company"
#property link      "https://www.yourwebsite.com"
#property version   "1.00"

string name = "Your Program Name"
#include "CheckMyLicense.mqh"

// Input parameters
input string InpEmail = "";              // Email
input string InpLicence = "";            // License Key
input double InpLotSize = 0.01;          // Lot Size
input int    InpMagicNumber = 12345;     // Magic Number

//+------------------------------------------------------------------+
//| Expert initialization function                                     |
//+------------------------------------------------------------------+
int OnInit()
{
    // Verify license first
    if(!CheckMyLicense(InpEmail, InpLicence))
    {
        Alert("License verification failed! EA will not run.");
        return INIT_FAILED;
    }
    
    Print("License verified! EA starting...");
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert tick function                                              |
//+------------------------------------------------------------------+
void OnTick()
{
    // Your trading logic here
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    Print("EA stopped. Reason: ", reason);
}

Indicator Example

If you must use an Indicator with license verification, create an EA wrapper that loads the indicator as an embedded resource. This approach requires only license verification on the EA, not the indicator itself:

//+------------------------------------------------------------------+
//|                         CustomIndicatorWrapper.mq5 |
//|  EA that attaches a custom licensed indicator to the chart      |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Your Company"
#property link      "https://www.yourwebsite.com"
#property version   "1.0"

string name = "Licensed Indicator Wrapper"
#include "CheckMyLicense.mqh"

// Embed your custom indicator as a resource
#resource "CustomIndicator.ex5"

// Resource reference for iCustom
#define CUSTOM_INDICATOR "::CustomIndicator.ex5"

// Mirror indicator inputs to match your custom indicator parameters
input int    InpPeriod            = 14;       // MA Period
input int    InpShift             = 0;        // Shift
input bool   InpShowSignal        = true;     // Show Signal Line

// License input
input string InpEmail = "";
input string InpLicence = "";

// Internal
int g_ind_handle = INVALID_HANDLE;
int ext_reason = 0;

//+------------------------------------------------------------------+
//| Helper: Remove indicator from chart if present                   |
//+------------------------------------------------------------------+
void RemoveIndicator()
{
    if(g_ind_handle != INVALID_HANDLE)
    {
        // Find and remove any indicator with matching name
        int total = (int)ChartIndicatorsTotal(0, 0);
        for(int i = total - 1; i >= 0; --i)
        {
            string name = ChartIndicatorName(0, 0, i);
            if(StringFind(name, "CustomIndicator") >= 0)
                ChartIndicatorDelete(0, 0, name);
        }
        IndicatorRelease(g_ind_handle);
        g_ind_handle = INVALID_HANDLE;
    }
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    // Verify license first
    if(ext_reason != 3) // Skip on EA reload (reason 3)
    {
        if(!CheckMyLicense(InpEmail, InpLicence))
        {
            Alert("License verification failed! EA will not run.");
            return INIT_PARAMETERS_INCORRECT;
        }
    }

    // Ensure any previous instance is removed
    RemoveIndicator();

    // Create indicator handle with your custom parameters
    g_ind_handle = iCustom(
        _Symbol,
        _Period,
        CUSTOM_INDICATOR,
        InpPeriod,
        InpShift,
        InpShowSignal
    );

    if(g_ind_handle == INVALID_HANDLE)
    {
        PrintFormat("Failed to create indicator handle. Error=%d", GetLastError());
        return INIT_FAILED;
    }

    // Add indicator to chart
    if(!ChartIndicatorAdd(0, 0, g_ind_handle))
    {
        PrintFormat("ChartIndicatorAdd failed. Error=%d", GetLastError());
        IndicatorRelease(g_ind_handle);
        g_ind_handle = INVALID_HANDLE;
        return INIT_FAILED;
    }

    Print("License verified! Custom indicator attached to chart.");
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    RemoveIndicator();
    if(reason == 3)
    {
        ext_reason = 3; // Track EA reload
    }
}

//+------------------------------------------------------------------+
//| Expert tick function (no trading logic needed)                   |
//+------------------------------------------------------------------+
void OnTick()
{
    // Wrapper runs silently; indicator handles all logic
}

Understanding Error Codes

The SDK uses specific error codes to help diagnose issues during license verification:

Testing Your Implementation

1. Compile – Compile your MQL5 file in MetaEditor (F7)
2. Attach to Chart – Drag your EA/Indicator to a chart
3. Enter Credentials – Input your email and license key in the parameters dialog
4. Check Logs – Open the Experts tab to see verification results
5. Verify Activation – Check your CheckMyLicense dashboard for the new activation

Python SDK v3

The Python SDK v3 provides a command-line tool and library for integrating CheckMyLicense verification into Python applications. It handles HMAC-SHA256 authentication, request signing, offline token caching, and program configuration management automatically.

Key Features

• Protocol v3 Support – Default v3 with program configuration; backward compatible with v1/v2
• Program Configuration Access – Global PROGRAM_CONFIGURATION variable for runtime feature management
• Offline Token Caching – Automatic token caching to ~/.cml_offline/ for offline verification
• Command-Line Interface – Verify licenses directly from terminal or scripts
• Server Signature Verification – Built-in validation of server responses
• Flexible Integration – Use as CLI tool or import as Python module

What's New in v3

• Program Configuration – Server returns program-specific settings in response
• Offline Tokens – Cached tokens include configuration for offline use (7-day validity)
• Enhanced Security – v3 offline tokens include configuration in signature to prevent tampering
• Version Selection – Choose protocol version with --v flag (default: 3)

Installation

Prerequisites

• Python 3.7 or higher
• requests library for HTTP calls
• cryptography library for token validation
• Active CheckMyLicense organization account
• Your organization's API ID and API Secret (from Settings → Organization)

Installation Steps

1. Install Dependencies

   pip install requests cryptography

2. Download the SDK

   Download the Python SDK v3 from your organization page (Available SDK section).

3. Extract the File

   The SDK package contains a single file:

   • CheckMyLicenseOnline.py – The CLI tool and library
4. Verify Installation

   python CheckMyLicenseOnline.py --help

Quick Start

Online Verification with Configuration (v3)

Verify a license and retrieve program configuration:

python CheckMyLicenseOnline.py \
  --api-id a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d \
  --api-secret YOUR_API_SECRET \
  --endpoint "https://vwqretlvkrravzguxydw.functions.eu-west-2.nhost.run/v1" \
  --program "My Python Application" \
  --license aBcD1234eFgH5678-iJkL9012-mNoP3456-qRsT7890-uVwXyZ12 \
  --email user@example.com \
  --v 3 \
  --show-config

Example Output

License verified successfully!
Validity: 2026-12-31 23:59:59
Activations: 2/5
Offline token saved to ~/.cml_offline/aBcD1234eFgH5678-iJkL9012-mNoP3456-qRsT7890-uVwXyZ12.json

Program Configuration:
{
  "max_devices": 5,
  "advanced_features": true,
  "api_rate_limit": 1000,
  "custom_branding": "Premium"
}

Offline Verification

Use cached offline token for verification without network access:

python CheckMyLicenseOnline.py \
  --program "My Python Application" \
  --license aBcD1234eFgH5678-iJkL9012-mNoP3456-qRsT7890-uVwXyZ12 \
  --offline \
  --show-config

Offline Output

Using offline token (expires: 2026-02-12 15:30:00)
License verified successfully (offline mode)

Program Configuration:
{
  "max_devices": 5,
  "advanced_features": true
}

Command-Line Parameters

Protocol Versions

Examples

Programmatic Integration - Basic

Import and use the SDK in your Python application with v3 configuration access:

import sys
from CheckMyLicenseOnline import verify_license, PROGRAM_CONFIGURATION

def main():
    # Verify license
    result = verify_license(
        api_id="your-api-id",
        api_secret="your-secret",
        endpoint="https://your-endpoint",
        program="My Python Application",
        license_key="user-license-key",
        email="user@example.com",
        version=3
    )
    
    if not result['success']:
        print(f"License verification failed: {result['message']}")
        sys.exit(1)
    
    print("License verified successfully!")
    print(f"Valid until: {result['validity']}")
    print(f"Activations: {result['used']}/{result['limit']}")
    
    # Access program configuration
    max_devices = PROGRAM_CONFIGURATION.get('max_devices', 1)
    features_enabled = PROGRAM_CONFIGURATION.get('advanced_features', False)
    
    print(f"Max devices allowed: {max_devices}")
    print(f"Advanced features: {'enabled' if features_enabled else 'disabled'}")
    
    # Your application logic here
    run_application(features_enabled)

if __name__ == "__main__":
    main()

Offline-First Approach

Try offline verification first, then fall back to online if needed:

from CheckMyLicenseOnline import verify_license, verify_offline, PROGRAM_CONFIGURATION

def verify_with_fallback(license_key, **online_params):
    """Try offline verification first, fall back to online"""
    
    # Try offline verification
    offline_result = verify_offline(
        program=online_params['program'],
        license_key=license_key
    )
    
    if offline_result['success']:
        print("Verified using cached offline token")
        return offline_result
    
    # Fall back to online verification
    print("Offline token unavailable, verifying online...")
    online_result = verify_license(
        **online_params,
        license_key=license_key
    )
    
    return online_result

# Usage
result = verify_with_fallback(
    license_key="user-license",
    api_id="your-api-id",
    api_secret="your-secret",
    endpoint="https://your-endpoint",
    program="My App",
    email="user@example.com",
    version=3
)

Configuration-Driven Features

Use program configuration to enable/disable features dynamically:

from CheckMyLicenseOnline import verify_license, PROGRAM_CONFIGURATION

def check_license_and_configure():
    result = verify_license(
        api_id="your-api-id",
        api_secret="your-secret",
        endpoint="https://your-endpoint",
        program="Professional CAD Tool",
        license_key=user_license,
        email=user_email,
        version=3
    )
    
    if not result['success']:
        raise Exception(f"License invalid: {result['message']}")
    
    # Extract configuration
    config = PROGRAM_CONFIGURATION
    
    # Apply configuration to application settings
    app_config = {
        'max_projects': config.get('max_projects', 5),
        'export_formats': config.get('export_formats', ['pdf']),
        'cloud_sync': config.get('cloud_sync_enabled', False),
        'plugin_access': config.get('plugins', []),
        'render_quality': config.get('render_quality', 'standard')
    }
    
    return app_config

# Initialize application
try:
    settings = check_license_and_configure()
    print(f"Application configured: {settings}")
    launch_application(settings)
except Exception as e:
    print(f"Startup failed: {e}")
    sys.exit(1)

Response Data Structure

{
  "status": "success",
  "message": "License verified successfully",
  "validity": 1735689600,
  "limit": 5,
  "used": 2,
  "program_configuration": {
    "max_devices": 5,
    "advanced_features": true,
    "api_rate_limit": 1000,
    "custom_setting": "value"
  },
  "offline_token": "eyJwcm9ncmF...",
  "offline_expires_at": 1739462400
}

{
  "program_name": "My Python Application",
  "license_uuid": "550e8400-e29b-41d4-a716-446655440000",
  "expires_at": 1739462400,
  "target_ids": "device-123,device-456",
  "configuration": {
    "max_devices": 5,
    "advanced_features": true
  },
  "sig": "a1b2c3d4e5f6..."
}

Desktop Application Pattern

Complete license manager class for desktop applications:

class LicenseManager:
    def __init__(self, app_name, api_credentials):
        self.app_name = app_name
        self.api_creds = api_credentials
        self.config = {}
        
    def activate(self, license_key, email):
        """Activate application with license"""
        from CheckMyLicenseOnline import verify_license, PROGRAM_CONFIGURATION
        
        result = verify_license(
            api_id=self.api_creds['id'],
            api_secret=self.api_creds['secret'],
            endpoint=self.api_creds['endpoint'],
            program=self.app_name,
            license_key=license_key,
            email=email,
            version=3
        )
        
        if result['success']:
            self.config = PROGRAM_CONFIGURATION.copy()
            return True, "Activation successful"
        
        return False, result.get('message', 'Activation failed')
    
    def get_feature_access(self, feature_name):
        """Check if feature is enabled via configuration"""
        features = self.config.get('enabled_features', [])
        return feature_name in features
    
    def get_resource_limit(self, resource_name):
        """Get resource limit from configuration"""
        limits = self.config.get('resource_limits', {})
        return limits.get(resource_name, 0)

# Usage
license_mgr = LicenseManager(
    "Professional Video Editor",
    {'id': 'api-id', 'secret': 'api-secret', 'endpoint': 'https://...'}
)

success, message = license_mgr.activate(user_license, user_email)
if success:
    if license_mgr.get_feature_access('4k_export'):
        enable_4k_export()
    
    max_projects = license_mgr.get_resource_limit('max_projects')
    configure_project_limit(max_projects)

Migration from v2 to v3

v3 is backward compatible. Simply update the version parameter:

# Old (v2)
result = verify_license(..., version=2)

# New (v3) - explicit
result = verify_license(..., version=3)

# New (v3) - implicit (default)
result = verify_license(...)  # Uses v3 by default

# Access configuration after v3 verification
from CheckMyLicenseOnline import PROGRAM_CONFIGURATION
config = PROGRAM_CONFIGURATION
max_users = config.get('max_users', 1)