Quick start

Dashboard workflow (vendor side)

Think of LicenPro as a closed loop: you define what you sell in the dashboard, you ship signed artifacts to customers, and the .NET SDK in your app proves those artifacts against your public key and (optionally) your hosted API. The usual sequence is:

1. Organization & product — create a product under your tenant; everything else hangs off that product.
2. Releases & files — attach versions, binaries, or metadata so licenses and updates can target a specific release line.
3. RSA keys — generate a key pair per product before issuing licenses; only the public key ever leaves LicenPro toward your application.
4. Licenses — choose a model (perpetual, trial, subscription, floating, node-locked), set limits and entitlements, then export license.bin and the license key.
5. Sessions & activations — optional but recommended for floating seats, compliance, and support; the SDK can register sessions while validating.
6. Automation — use the REST API or webhooks when provisioning or billing systems should create or retire licenses without manual clicks.

The sections below walk the same path in more detail, ending with SDK bootstrap so your shipped binaries stay aligned with what you configured online.

1. Account and organization

Sign in or register at app.licenpro.tech. You work inside an organization; products and licenses belong to that tenant. Invite teammates from organization settings when you outgrow a single operator.

2. Dashboard: first product

In the app shell, open Products, then Create product. The product is the anchor for RSA keys, releases, entitlements, and every license you generate. See Create your first product for field-level detail.

3. Dashboard: RSA keys (mandatory before licenses)

Each product has its own signing identity. From the product workspace, open Settings (or keys section), generate an RSA key pair, and copy the public key into your application configuration. The private key stays in LicenPro only; your desktop or server app must never embed it. Full walkthrough: RSA keys.

4. Dashboard: first license and artifacts

Create a license for the product (type, expiry, seats, etc.). After saving, download or distribute:

• license.bin — signed license payload consumed by the SDK
• The license key string shown in the dashboard (customer enters it once during activation flows)
• The product public key (PEM or Base64, depending on how you export it from settings)

Step-by-step: Generate your first license. License models (perpetual, trial, subscription, floating, node-locked) are covered under License models in the sidebar.

5. SDK configuration (before any validation)

The SDK resolves settings in a predictable order:

1. If you call SdkConfiguration.Initialize(...) explicitly, that wins.
2. Otherwise the first existing file in the app directory is loaded: licenpro.settings.json, then appsettings.json (optionally with a nested LicenPro section).
3. If nothing is found, defaults apply (including a production-style API base — override for self-hosted or staging).

// Typical explicit bootstrap (any host)
using LicenPro.Models.Utils;
using LicenPro.SDK;

var settings = new SdkSettings {
    // Must be an absolute URL ending with /api
    ServerBaseEndpoint = "https://licenpro.runasp.net/api"
};
SdkConfiguration.Initialize(settings);

6. Desktop bootstrap: settings + pending updates

For WinForms, WPF, or other desktop hosts, call SdkBootstrap.OnApplicationStartup() once at process entry (before Application.Run). It ensures default JSON settings are loaded and applies any staged product update from a previous run (pairs with the update APIs described in the .NET SDK page).

using LicenPro.SDK.AppHosting;

// WinForms Program.cs (example)
ApplicationConfiguration.Initialize();
SdkBootstrap.OnApplicationStartup();
Application.Run(new MainForm());

7. Validate a license in code

The primary integration surface is LicenseClient with LicenseClientOptions: paths to license.bin, public key, license key, optional expected type, optional product id for update eligibility, and optional expiry-warning tuning. Successful validation can populate an on-disk license cache so the next launch can use LicenseClient.TryAutoValidateAsync without re-reading the bin from UI.

Authoritative API details, status codes, cache helpers, subscription expiry notices, and license-aware updates: .NET SDK.

8. Optional: sessions, activations, webhooks

When you connect a session from the SDK, the dashboard Sessions and Activations views reflect real usage — useful for floating licenses, compliance, and support. Webhooks notify your backend about license lifecycle events outside the client.

Sessions & activations · Webhooks · REST API reference · Hosted API base (/api on your deployment)