Overview

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

• Operations – programs and licenses.
• E‑Commerce – products, whitelists, 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 manage versions, click the eye icon next to any program to open its detail page, then use Add Version or click any row in the versions table to view it.

Program Versions

Each program can have multiple versions. The versions table shows each version's number, created date, status (Released or Draft) and title. Clicking a row opens the version in view mode.

Creating or Editing a Version

Click Add Version or the edit icon on an existing version. The form contains the following fields:

• Version Number — the release identifier (e.g. 1.3.0). The form suggests the next logical version based on existing versions for the same program.
• Release Title — a short headline for the release (e.g. “Performance & Stability Update”). This is used as the email subject when the version is released to licence holders.
• Release Email Body — a rich Markdown editor. Use headings, bold text, bullet lists, links, and more to compose the notification email your licence holders will receive. A live preview pane on the right of the editor renders the formatted output as you type, so you can verify the layout before saving.
• Program File / Link — choose one of two modes via the toggle:
  • Upload File — pick a local file; it is stored in secure cloud storage and a download URL is saved automatically. If the version already has a file, uploading a new one replaces it.
  • Share Link — paste an external URL (e.g. a download page or CDN link). No file is uploaded; the URL is saved directly as the version's link.

Version Status

Every version starts with a Draft status. A version becomes Released only when the Release button is used to send the release notification email (see below). The status is read-only and cannot be changed manually — it reflects whether the release email has been dispatched.

Releasing a Version

When viewing a version that is still in Draft status, a green Release button appears in the modal footer. Clicking it:

1. Sends a formatted release notification email to every active licence holder of the program, using the Release Title as the subject and the rendered Release Email Body as the HTML content.
2. Marks the version as Released — the status badge updates immediately in both the modal and the versions table.
3. Displays a summary showing how many emails were sent and, if any, how many failed with reasons.

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. You are automatically taken to the licence detail page where you can copy the key, send it by email, and configure Access Rules — see Access Rules below for details.

Access Rules

Access rules let you restrict which activations are accepted for a licence. Each rule combines up to three criteria — Type, Target ID, and Target Host — into a single row. An incoming activation is accepted when it matches all non-empty fields within at least one rule.

• Type — the activation type, e.g. live or demo. Leave blank to match any type.
• Target ID — a specific account number, machine ID, or other unique identifier. Leave blank to match any target ID.
• Target Host — a server name or hostname, e.g. UltimaMarkets-Live 1. Leave blank to match any host.

Rules are managed exclusively from the licence detail page (Licences → select a licence). Use + Add Rule to create a rule, the toggle icon on each row to activate or deactivate it individually, and the delete icon to remove it permanently.

The Specific Rules toggle at the top of the Access Rules table acts as a master switch. When it is OFF, all rules are ignored and every activation attempt is accepted (subject to limit and expiry). Turning it ON enforces the rule set. The toggle can be flipped at any time without deleting the rules.

In the edit modal you can toggle individual rules Active / Inactive, but adding or removing rules must be done from the licence detail page.

License Management

After creation, the licence status and Activations Deletable flag can be edited from the edit modal. Access rules are managed from the licence detail page. Each licence 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 deploy the open-source CML Activations Web SDK on your own website. The starter includes the My Activations API flow, email verification, and Cloudflare Turnstile.

Linked Product

When a licence is linked to a product (i.e. its product_id is set), the licence detail page shows a Linked Product row in the info panel displaying the product name.

To remove the link, click the unlink icon (broken chain) next to the product name. A confirmation dialog is shown before the change is applied. Once confirmed, product_id is set to null and the row disappears from the Inactive Licenses tab on the Whitelist page.

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 Price. The product automatically uses the organisation's e-commerce currency.
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. Enable Whitelist Rules if this product should enforce whitelist-based activation restrictions. When checked, a chip selector appears — choose which Whitelists to attach to this product. Licences generated from this product will inherit those whitelist rules.
6. Write a description for storefront display.
7. Click Create. The product appears with actions to view, edit or delete.

Sales Channels

Sales channels define the catalogs used by your storefronts. Each channel has a stable slug, public links, geographic availability, and an ordered selection of products. The protected Portal channel records orders created manually in this dashboard.

1. Open Sales Channels under E-Commerce and select Create channel.
2. Set the channel identity and public links. Keep a new channel inactive while configuring it.
3. Choose All countries or select allowed countries from the database-backed continent groups.
4. Map products, choose which are visible, set their display order, and optionally choose one visible Default product per program. Multiple non-default products under the same program are allowed.
5. Save, then use Preview catalog with an allowed and restricted country before activating the channel.

Customer and organization countries use ISO 3166-1 alpha-2 codes from the database. Older free-text country values remain visible until a standard country is selected during editing.

Storefronts read the explicit default flag; they must not infer it from a product title, price, validity, or position. Program codes are required and unique within the organization. A program code becomes locked after the program is first published to an external sales channel because integrations such as Trade't store it as cmlProgramCode.

Whitelist

Whitelists are reusable collections of activation rules that can be attached to one or more products. Instead of setting access rules on every individual licence, you define the allowed activation criteria once in a whitelist and attach it to the relevant products. When an order generates a licence, the whitelist rules are applied to restrict which activations are accepted.

Create a Whitelist

1. Navigate to Whitelist (under E‑Commerce) and click Add Whitelist.
2. Enter a Name for the whitelist (e.g. “Live Accounts Only” or “VIP Servers”).
3. Click Save. The whitelist appears in the table showing its name, item count and creation date.

Manage Whitelist Items

Click any whitelist row to open its detail page. Each whitelist contains a table of items — individual rules that define which activations are permitted.

1. Click Add Item (or the inline form above the table).
2. Fill in any combination of the three criteria:
   • Type — activation type, e.g. live or demo. Leave blank to match any type.
   • Target ID — account number or machine identifier. Leave blank to match any ID.
   • Target Host — server or hostname, e.g. UltimaMarkets-Live 1. Leave blank to match any host.
3. Click the check button to save the item. It appears in the table immediately.
4. Use the toggle icon to activate or deactivate individual items without deleting them.
5. Use the delete icon to permanently remove an item.

Bulk Add or Update Whitelist Items

Open a whitelist's detail page and click Bulk add/update above the Items table. Each operation accepts up to 50 rows. Choose the method that matches your data:

Excel file

1. Choose Excel file and click Download Excel template. Always use the downloaded template rather than changing its columns.
2. Enter one item per row. target_id is required; type, target_host and active are optional. Set active to true or false.
3. Keep the workbook as a single .xlsx worksheet no larger than 2 MB. The required columns are target_id, type, target_host and active. Use plain values only; formulas are not accepted.
4. Upload the completed workbook. Existing items are matched by Target ID. Nonblank optional cells update the matching item; blank optional cells keep its current values. This version does not clear an existing field through Excel.

Quick list

1. Choose Quick list, then select whether your pasted values represent Target ID, Type or Target host / Server ID.
2. Paste up to 50 comma-separated or newline-separated values.
3. Quick List creates missing values only. A value already present in the whitelist remains unchanged.
4. Be careful when importing only a Type or Target Host: the other rule fields stay blank, creating a wildcard that can match any value in those fields.

Review and run

1. Click Review preview and verify the displayed rows and any wildcard warning.
2. Check the confirmation box, then click Confirm and run.
3. Review the summary of inserted, updated, unchanged and rejected rows. Click Download results for the complete row-by-row report.
4. If you safely retry the same input, existing values are updated or reported as unchanged rather than inserted again.

Attach a Whitelist to a Product

Open the Product edit modal, enable Whitelist Rules, then click the whitelist name chips that should apply. Multiple whitelists can be attached. The rules from all attached whitelists are combined — an activation is accepted if it matches any active item in any of the attached whitelists.

Refresh Licenses

After updating a whitelist's items, click the Refresh Licenses button (the circular arrow icon) on any row in the Whitelist Lists table. This enqueues a background job that propagates the latest whitelist rules to all licences linked to the products that use this whitelist.

• The job runs asynchronously — a confirmation notification shows how many licences were enqueued and how many were skipped because a job was already pending or running.
• If you click the button a second time while the previous job is still running, the server deduplicates and skips those licences. Once the worker finishes, a fresh job can be triggered again.

Inactive Licenses Tab

The Whitelist page has two tabs: Whitelist Lists (the main list of whitelists) and Inactive Licenses. The Inactive Licenses tab shows all licences that are currently inactive and are linked to a product, expanded one row per access rule so each Target ID / Target Host pair is visible individually.

Columns shown: Product, Customer, Created, Target ID, Target Host, and an eye icon to navigate directly to the licence detail page.

Adding Inactive License Rules to a Whitelist

Use this workflow to bulk-populate a whitelist directly from your customers' existing licence access rules:

1. Open the Inactive Licenses tab.
2. Check the rows whose Target ID / Target Host you want to add. Use the header checkbox to select all visible rows at once.
3. Click Add to List (N) — a modal appears listing all your whitelists.
4. Select the target whitelist from the dropdown and click Add to Whitelist.
5. The portal checks for duplicates and inserts only new entries. A summary notification confirms the result:
   • X added — new items inserted successfully.
   • Y already exist — skipped because the same Target ID is already in the whitelist.
   • Z errored — individual items that failed to insert.
6. After a successful add, the Refresh Licenses job is triggered automatically for the chosen whitelist.

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 (all required).
3. Optionally select the Type (Individual or Business), enter the Postal Code, Country, Phone, State, Address and Tax ID.
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.

Each referral code also has a Type which controls the commission model:

• Affiliate — the referee refers customers and earns a commission from you on paid orders. Set a Commission Rate % (what the referee earns) and optionally a Cost Rate % (your operating cost, deducted before commission is calculated). Formula: commission = (order amount − cost) × commission rate.
• Reseller — the partner sells on your behalf and owes you the full order amount. Commission rate is not applicable; set it to 0.
• Sub-Affiliate — a two-party arrangement where the referee (the parent) has recruited a sub-affiliate partner (the child). The referee earns the full commission from you as usual, but a portion of it (Parent Share %) is reserved for the parent referee to pass on to the child. Set a Commission Rate %, Cost Rate % and Parent Share %. The parent share is an absolute percentage of the net amount — not a percentage of the commission.

Commission Formula

For Affiliate codes, commission is calculated on Paid orders only:

cost        = original_amount × (cost_rate ÷ 100)
net         = final_amount − cost
commission  = net × (commission_rate ÷ 100)

Set Cost Rate to 0 if you do not want to deduct operating costs before calculating commission. Cancelled and refunded orders always show $0 commission.

Example A — Affiliate with cost deduction

Contract: 20% discount to customer, 10% commission to referee, 20% cost rate. Product listed at $100.

Customer pays  = $100 − 20%          = $80.00  (final_amount)
Cost           = $100 × 20%          = $20.00
Net            = $80.00 − $20.00     = $60.00
Commission     = $60.00 × 10%        = $6.00   ← you owe the referee

Example B — Affiliate, no cost deduction

Contract: 15% discount to customer, 15% commission to referee, 0% cost rate. Product listed at $200.

Customer pays  = $200 − 15%          = $170.00 (final_amount)
Cost           = $200 × 0%           = $0.00
Net            = $170.00 − $0.00     = $170.00
Commission     = $170.00 × 15%       = $25.50  ← you owe the referee

Example C — Reseller code

Contract: 30% discount, commission rate 0% (reseller type). Product listed at $100.

Customer pays  = $100 − 30%          = $70.00  (final_amount)
Commission     = $0.00               (reseller type — partner owes YOU $70.00)

Sub-Affiliate Commissions

When the referral type is Sub-Affiliate, the commission calculation has an extra split step. You pay the referee (parent) their full commission; the report then shows how much of that commission the parent is expected to pass on to their sub-affiliate partner (child). CheckMyLicense does not process the child payout — you pay the parent, and they settle with the child.

cost           = original_amount × (cost_rate ÷ 100)
net            = final_amount − cost
commission     = net × (commission_rate ÷ 100)   ← total you owe the parent
parent_share   = net × (parent_share_rate ÷ 100) ← parent keeps this
sub_amount     = commission − parent_share        ← parent passes this to the child

Parent Share % is an absolute percentage of the net amount — not a percentage of the commission.

Example D — Sub-Affiliate

Contract: 10% customer discount, 30% commission rate, 20% cost rate, 5% parent share. Product listed at $1,000.

Customer pays  = $1,000 − 10%        = $900.00  (final_amount)
Cost           = $1,000 × 20%        = $200.00
Net            = $900.00 − $200.00   = $700.00
Commission     = $700.00 × 30%       = $210.00  ← you pay this to the parent
Parent share   = $700.00 × 5%        =  $35.00  ← parent keeps this
Sub amount     = $210.00 − $35.00   = $175.00  ← parent passes to the child

Tiered Commission

Both Affiliate and Sub-Affiliate codes support tiered commission. Instead of a single flat rate, you define multiple tiers — each starting at a certain number of paid orders in the current reset window. As the referee accumulates paid orders within the window, the applicable rate advances automatically.

• Switch Commission Model to Tiered when creating or editing a referral code.
• Click Add Tier and set Starts at paid order # and Commission % for each tier. Sub-Affiliate codes also have a Parent Share % per tier.
• Set a Tier Reset period: Weekly (resets every Monday), Monthly, Quarterly, Yearly or Never. With Never, the order count accumulates indefinitely.
• The report always applies the correct tier rate for the window each order fell in — historical orders are not affected when you change the reset period going forward.

Referee Performance Report

The Referee Performance Report gives you a consolidated view of all orders linked to referral codes. Access it by clicking the Report button on the Referees list page.

Filters

• Referee – narrow the report to a single referee or leave blank to include all.
• From / To – date range based on the order's paid date. Leave blank for all dates.
• Status – filter by order status (Paid, Pending, Cancelled, etc.) or leave as All.
• Type – filter by referral type: Affiliate, Sub-Affiliate or Reseller.

Summary Cards

The top row shows aggregated totals for the current filter selection: Total Orders, Total Turnover, Discount Given, Paid, Pending, Cancelled, Refunded, Commission Owed (total commission due to affiliates on paid orders), and Reseller Revenue (total amount resellers owe you on paid orders).

Table Columns

• Referee – the affiliate who owns the referral code. Click to open the referee's detail page.
• Referral Code – the code applied to the order. Click to open the referral detail page.
• Type – Affiliate, Sub-Affiliate or Reseller badge.
• Code Discount – the discount configured on the referral code (percentage or fixed amount).
• Order – the order reference code. Click to open the order detail page.
• Status – current order status.
• Amount – final order amount after discount.
• Order Discount – the actual discount value applied to that order.
• Commission – commission owed to the referee for paid orders (affiliate / sub-affiliate type only). Calculated as: (final amount − cost) × commission rate.
• Parent % / Parent Amt – for Sub-Affiliate codes only: the share of the net amount the parent referee keeps before paying the child. Parent Amt = net × parent share %.
• Sub Amt – for Sub-Affiliate codes only: the amount the parent is expected to pass to the child. Sub Amt = commission − parent amt.
• Paid At – date the order was paid.
• Cancelled Date – date the order was cancelled (if applicable).

Exports

• CSV – downloads all matching rows (up to 2,000) as a spreadsheet-ready file.
• Print / PDF – opens a print-ready page with CheckMyLicense branding. Use your browser's Save as PDF option to export as a PDF.

Customers

Customers are available from Operations → Customers on every package. Open a customer to add a licence directly; the customer email is filled in automatically. Packages with the E-Commerce capability also show the customer's Orders tab and Add Order action.

1. Go to Operations → Customers and click Add Customer.
2. Enter the Email, First Name and Last Name (all required).
3. Optionally select the Type (Individual or Business), enter the Postal Code, Country, Phone, State, Address and Tax ID. Click Create.
4. 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. Optionally enter a Target ID and/or Target Host per line item. When provided, these values are stored in the order item metadata and will be used to pre-populate access rules on the licences generated from that item after payment.
4. Click Create Order. A confirmation modal shows the order code and total. Confirming sets the status to Draft. Open the order details to review.
5. 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

On Growth and Pro, members are added through the administrator-only Team tab. 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. E-Commerce Currency: Choose the organisation's currency for e-commerce activity during registration or from Settings → Organization. The following rules apply:
   • Supported currencies: EUR, USD and GBP.
   • An organisation has one active e-commerce currency. Multi-currency selling and automatic currency conversion are not supported.
   • The administrator can change the currency until the first product or order is created. Creating the first product or order permanently locks the setting.
   • Products, orders, order items, fixed referral discounts, redemptions and payments automatically use and retain the organisation's commerce currency. Percentage referral discounts remain percentages and do not have a currency.
   • This setting applies only to e-commerce. It does not change subscriptions, administrative invoices, balances or other platform billing.
3. 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 (support@checkmylicense.dev) 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 support@checkmylicense.dev. Configure SMTP only if you need emails to come from your own domain for branding purposes.

4. API Keys: Manage your API authentication credentials for server-to-server integrations. You can create up to 5 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, provide a description (e.g., "Production API", "Development API"), and select the scopes that key is allowed to use.
   • Scoped – each key declares exactly what it is allowed to do via one or more scopes (see table below). Keys without a scope cannot call any protected endpoint.
   • 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.

   Available scopes:

   Scope	What it allows
   license:verify	Verify licenses (body-signed — see Encoding & Encryption in the API section)
   license:create	Create new licenses on behalf of the organisation
   license:update	Update existing license status, expiry, and access rules
   ecommerce:read	Read customers and orders
   ecommerce:customers:write	Create and update customers
   ecommerce:customers:verify	Resolve existing checkout customers and verify OTPs
   ecommerce:orders:write	Submit, update, and confirm orders
   ecommerce:orders:cancel	Cancel orders
   ecommerce:payments:record	Record payments against orders
   ecommerce:provider-accounts:write	Look up and bind provider customer references
   ecommerce:payment-sessions:write	Register and transition provider payment sessions
   ecommerce:provider-events:write	Record and reconcile provider events

   Keep your API keys secure and do not share them publicly. Only active keys with the correct scope will authenticate successfully.
5. Team: Growth and Pro administrators can open the Team tab and click Manage Members. Each member entry shows name, email, role, status, and invitation 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.

The administrator-only Email tab is available when the package contains White-labeled Emails. Team and Email settings remain hidden when the package does not include the corresponding capability.

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) – Core licensing for evaluation: 1 program, 2 active licences and 50 API hits per month.
• Pay as you Go – No fixed platform fee; programs, active licences and API usage are metered from the first unit.
• Growth – €39 monthly with 10 programs, 500 active licences, 20K API hits, Team Access and the Commerce & Automation Suite.
• Pro – €110 monthly with 25 programs, 2,500 active licences, 250K API hits and priority support.

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 Operations → 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.

• MQL4 and MQL5 SDKs (MetaTrader) – Supported for independently distributed MT4 and MT5 Expert Advisors. Use the package and example for the target platform, then verify the exact SDK and terminal build before release.
• Python SDK v4 – ✅ Production-Ready - Command-line tool and library with offline tokens, program configuration, and HMAC-SHA256 authentication.
• Node.js SDK – ✅ Production-Ready - Zero-dependency module using only Node built-ins; works with Node 18+ native fetch or falls back to the https module for older versions.

MQL4 and MQL5

The CML SDK supports license verification for independently distributed MetaTrader 4 and MetaTrader 5 Expert Advisors. Follow the package example for your target platform. Indicators require a different design, and WebRequest-based verification does not run in Strategy Tester.

Installation

Prerequisites

• MetaTrader platform installed
• MetaEditor installed
• Active CheckMyLicense organization account
• An approved client credential model for the distributed build. Never embed an organization administrator or commerce secret in a client.
• If the current SDK package requires a shared organization secret in the compiled program, pause release and request a technical integration assessment.

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

Begin with the documented MT5 Expert Advisor integration and verify its credential, cache, retry, and failure behavior before distribution:

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 v4

The Python SDK v4 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 v4 Support – Default v4 with program configuration; backward compatible with v1/v2/v3
• 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 v4

• License Restrictions – Server enforces target ID, target host, and account type restriction lists per license
• Program Configuration – Server returns program-specific settings in response
• Offline Tokens – Cached tokens include configuration for offline use (7-day validity)
• Enhanced Security – v4 offline tokens include configuration in signature to prevent tampering
• Version Selection – Choose protocol version with --v flag (default: 4)

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 v4 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 (v4)

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 4 \
  --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 v4 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=4
    )
    
    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=4
)

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=4
    )
    
    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)

Node.js SDK

The Node.js SDK provides a zero-dependency module for integrating CheckMyLicense verification into Node.js applications. It uses only Node built-ins and supports both modern and legacy Node versions, with built-in offline token caching and program configuration access.

Key Features

• Zero Dependencies – Uses only Node built-ins: crypto, fs, https, os, path
• Broad Compatibility – Uses Node 18+ native fetch or falls back to https module for older versions
• Protocol v4 Support – Program configuration, offline tokens, and license restriction enforcement
• Offline Token Caching – Automatic caching for offline verification without network access
• Server Signature Verification – Built-in validation of server responses
• CommonJS Module – Simple require() integration with no build step needed

What's New in v4

• License Restrictions – Server enforces target ID, target host, and account type restriction lists per license
• Program Configuration – Server returns program-specific settings in the response
• Offline Tokens – Cached tokens include configuration for offline use (7-day validity)
• Enhanced Security – v4 offline tokens include configuration in signature to prevent tampering

Installation

Prerequisites

• Node.js 14 or higher (Node 18+ recommended for native fetch)
• Active CheckMyLicense organization account
• Your organization's API ID and API Secret (from Settings → Organization)

Installation Steps

1. Download the SDK

   Download the Node.js SDK from your organization page (Available SDK section).

2. Extract the File

   The SDK package contains a single file:

   • CheckMyLicenseOnline.js – The SDK module
3. Place in Your Project

   Copy CheckMyLicenseOnline.js into your project directory, then require it directly — nonpm install needed.

4. Verify Installation

   node -e "const { CheckMyLicenseOnline } = require('./CheckMyLicenseOnline'); console.log('SDK loaded');"

Quick Start

Basic Online Verification (v4)

Verify a license and retrieve program configuration in a single call:

const { CheckMyLicenseOnline } = require('./CheckMyLicenseOnline');

const result = await CheckMyLicenseOnline({
  apiId:    'your-api-id',
  apiSecret: 'your-api-secret',
  endpoint: 'https://vwqretlvkrravzguxydw.functions.eu-west-2.nhost.run/v1',
  license:  'user-license-key',
  email:    'user@example.com',
  program:  'My Node Application',
  version:  '4',
});

if (result.success) {
  console.log('License verified:', result.message);
  console.log('Source:', result.source); // 'online' | 'offline'
  console.log('Config:', result.programConfiguration);
} else {
  console.error('Verification failed:', result.message);
  process.exit(1);
}

Offline Verification

Use a cached offline token when no network access is available:

const result = await CheckMyLicenseOnline({
  program: 'My Node Application',
  license: 'user-license-key',
  offline: true,
});

console.log('Source:', result.source); // 'offline'
console.log('Config:', result.programConfiguration);

Function Parameters

Return Value

Examples

Offline-First with Online Fallback

Try the cached offline token first and only contact the server if no valid token exists:

const { CheckMyLicenseOnline } = require('./CheckMyLicenseOnline');

async function verifyLicense(licenseKey, email) {
  // Attempt offline first
  const offline = await CheckMyLicenseOnline({
    program: 'My Node Application',
    license: licenseKey,
    offline: true,
  });

  if (offline.success) {
    console.log('Verified offline');
    return offline;
  }

  // Fall back to online
  console.log('Offline token unavailable, verifying online...');
  return await CheckMyLicenseOnline({
    apiId:     process.env.CML_API_ID,
    apiSecret: process.env.CML_API_SECRET,
    endpoint:  process.env.CML_ENDPOINT,
    license:   licenseKey,
    email,
    program:   'My Node Application',
    version:   '4',
    verifyServerSig: true,
  });
}

const result = await verifyLicense('user-license-key', 'user@example.com');
if (!result.success) {
  console.error(result.message);
  process.exit(1);
}
console.log('Access granted. Config:', result.programConfiguration);

Configuration-Driven Features

Use programConfiguration to gate features at runtime:

const { CheckMyLicenseOnline } = require('./CheckMyLicenseOnline');

async function startApp(licenseKey, email) {
  const result = await CheckMyLicenseOnline({
    apiId:     process.env.CML_API_ID,
    apiSecret: process.env.CML_API_SECRET,
    endpoint:  process.env.CML_ENDPOINT,
    license:   licenseKey,
    email,
    program:   'Professional Node App',
    version:   '4',
  });

  if (!result.success) {
    throw new Error(`License invalid: ${result.message}`);
  }

  const config = result.programConfiguration ?? {};

  return {
    maxUsers:        config.max_users        ?? 1,
    advancedFeatures: config.advanced_features ?? false,
    apiRateLimit:    config.api_rate_limit    ?? 100,
  };
}

const appConfig = await startApp(userLicense, userEmail);
console.log('App config:', appConfig);

if (appConfig.advancedFeatures) {
  enableAdvancedMode();
}

Express.js Middleware Example

Protect API endpoints with license verification middleware:

const express = require('express');
const { CheckMyLicenseOnline } = require('./CheckMyLicenseOnline');

const app = express();
app.use(express.json());

async function licenseMiddleware(req, res, next) {
  const { license, email } = req.headers;

  if (!license || !email) {
    return res.status(401).json({ error: 'License and email headers required' });
  }

  const result = await CheckMyLicenseOnline({
    apiId:     process.env.CML_API_ID,
    apiSecret: process.env.CML_API_SECRET,
    endpoint:  process.env.CML_ENDPOINT,
    license,
    email,
    program:   'My API Service',
    version:   '4',
  });

  if (!result.success) {
    return res.status(403).json({ error: result.message });
  }

  req.licenseConfig = result.programConfiguration ?? {};
  next();
}

app.get('/api/data', licenseMiddleware, (req, res) => {
  const limit = req.licenseConfig.api_rate_limit ?? 100;
  res.json({ data: 'protected content', rateLimit: limit });
});

app.listen(3000);

Response Data Structure

{
  success: true,
  message: 'License verified successfully',
  source: 'online',
  data: {
    status: 'success',
    validity: 1735689600,
    limit: 5,
    used: 2,
    offline_token: 'eyJwcm9ncmF...',
    offline_expires_at: 1739462400
  },
  programConfiguration: {
    max_users: 5,
    advanced_features: true,
    api_rate_limit: 1000
  }
}

{
  success: false,
  message: 'License not found or expired',
  source: 'online',
  data: null,
  programConfiguration: null
}