C# / .NET Desktop

using UnifiedLicensing.Full;

var config = new UnifiedLicenseConfig
{
    VendorApiKey = "ul_your_api_key",
    ProductKey   = "your-product-key",
    BaseUrl      = "https://api.unifiedlicensing.com/api/v1"
};

var manager = new UnifiedLicenseManager(config);

var result = await manager.ValidateLicenseAsync("XXXX-XXXX-XXXX-XXXX");

if (result.Valid)
{
    Console.WriteLine("Welcome aboard! Tier: " + result.LicenseInfo?.Tier);
}

dotnet add package System.Net.Http
dotnet add package Newtonsoft.Json

using UnifiedLicensing.Full;

public static class AppSetup
{
    // One manager for the whole app. Reuse it.
    public static readonly UnifiedLicenseManager Manager = new(
        new UnifiedLicenseConfig
        {
            // Required
            VendorApiKey = "ul_your_api_key",
            ProductKey   = "your-product-key",

            // Always set this explicitly
            BaseUrl = "https://api.unifiedlicensing.com/api/v1",

            // Behaviour (all optional)
            OfflineMode          = true,
            BackgroundValidation = true,
            Encryption           = true,
            HardwareBinding      = HardwareBindingMode.Loose
        });
}

using System;
using System.Threading.Tasks;
using UnifiedLicensing.Full;

public class LicensingService
{
    public async Task<bool> UnlockAppAsync(string licenseKey)
    {
        try
        {
            var result = await AppSetup.Manager.ValidateLicenseAsync(licenseKey);

            if (result.Valid)
            {
                // Where did the answer come from?
                if (result.Cached)
                    Console.WriteLine("Validated from local cache.");

                if (result.InGracePeriod)
                {
                    var daysLeft = TimeSpan.FromMilliseconds(result.GraceRemaining).Days;
                    Console.WriteLine($"Working offline. Grace period: {daysLeft} day(s) left.");
                }

                if (result.Stale)
                    Console.WriteLine("Warning: " + result.Warning);

                // All the license details live here
                var info = result.LicenseInfo;
                Console.WriteLine($"Tier:       {info?.Tier}");
                Console.WriteLine($"Expires:    {info?.ExpiryDate}");
                Console.WriteLine($"Seats used: {info?.CurrentActivations}/{info?.MaxActivations}");

                EnableProFeatures(info);
                return true;
            }

            // Not valid. Tell the user why, plainly.
            Console.WriteLine("Invalid license: " + result.Error);
            Console.WriteLine("Error code:      " + result.ErrorCode);

            if (result.RequiresOnline)
                Console.WriteLine("Connect to the internet and try again.");

            return false;
        }
        catch (Exception ex)
        {
            // Network blew up, storage failed, whatever.
            Console.WriteLine("Validation error: " + ex.Message);
            return false;
        }
    }

    private void EnableProFeatures(LicenseData info)
    {
        // Unlock your features here, optionally gated by tier:
        // if (info?.Tier == "Professional") { ... }
    }
}

manager.OnLicenseRevoked   += (s, r) => LockApp("Your license was revoked.");
manager.OnLicenseExpired   += (s, r) => LockApp("Your license expired. Please renew.");
manager.OnQuotaExceeded    += (s, r) => ShowUpgradeBanner(r.UpgradeUrl);
manager.OnValidationFailed += (s, ex) => Logger.Warn(ex);
manager.OnCacheUsed        += (s, r) => Logger.Info("Offline validation used.");

using System;
using System.Drawing;
using System.Windows.Forms;
using UnifiedLicensing.Full;

namespace MyLicensedApp
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new ActivationForm());
        }
    }

    public class ActivationForm : Form
    {
        private readonly UnifiedLicenseManager _manager;
        private TextBox _keyBox;
        private Button _goButton;
        private Label _status;

        public ActivationForm()
        {
            _manager = new UnifiedLicenseManager(new UnifiedLicenseConfig
            {
                VendorApiKey = "ul_your_api_key",
                ProductKey   = "your-product-key",
                BaseUrl      = "https://api.unifiedlicensing.com/api/v1"
            });

            Text = "My App - Activate";
            Size = new Size(540, 220);
            FormBorderStyle = FormBorderStyle.FixedDialog;
            MaximizeBox = false;
            StartPosition = FormStartPosition.CenterScreen;

            var prompt = new Label
            {
                Text = "Enter your license key:",
                Location = new Point(20, 18),
                AutoSize = true
            };

            _keyBox = new TextBox
            {
                Location = new Point(20, 44),
                Width = 360
            };

            _goButton = new Button
            {
                Text = "Activate",
                Location = new Point(392, 42),
                Width = 106
            };
            _goButton.Click += OnActivateClick;

            _status = new Label
            {
                Location = new Point(20, 92),
                AutoSize = true,
                ForeColor = Color.DimGray
            };

            Controls.Add(prompt);
            Controls.Add(_keyBox);
            Controls.Add(_goButton);
            Controls.Add(_status);

            AcceptButton = _goButton;
        }

        private async void OnActivateClick(object sender, EventArgs e)
        {
            var key = _keyBox.Text.Trim();
            if (key.Length == 0)
            {
                _status.ForeColor = Color.DimGray;
                _status.Text = "Please enter a license key.";
                return;
            }

            _goButton.Enabled = false;
            _status.ForeColor = Color.DimGray;
            _status.Text = "Validating...";

            try
            {
                var result = await _manager.ValidateLicenseAsync(key);

                if (result.Valid)
                {
                    _status.ForeColor = Color.ForestGreen;
                    _status.Text = result.Cached
                        ? "Activated (offline cache). Welcome back!"
                        : "Activated. Thanks for buying My App!";

                    // Launch your real main window here, then close this one:
                    // Hide();
                    // new MainForm().Show();
                    // Close();
                }
                else
                {
                    _status.ForeColor = Color.Firebrick;
                    _status.Text = "Activation failed: " + (result.Error ?? "Unknown error");

                    if (result.QuotaExceeded && !string.IsNullOrEmpty(result.UpgradeUrl))
                        MessageBox.Show("Validation quota reached. Upgrade: " + result.UpgradeUrl);
                }
            }
            catch (Exception ex)
            {
                _status.ForeColor = Color.Firebrick;
                _status.Text = "Something went wrong: " + ex.Message;
            }
            finally
            {
                _goButton.Enabled = true;
            }
        }
    }
}

<Window x:Class="MyLicensedApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="My App - Activate"
        Height="210" Width="500"
        WindowStartupLocation="CenterScreen"
        ResizeMode="NoResize">
    <StackPanel Margin="24">
        <TextBlock Text="Enter your license key:"
                   FontSize="14"
                   Foreground="#EFEAE0"/>

        <StackPanel Orientation="Horizontal" Margin="0,12,0,0">
            <TextBox x:Name="KeyBox"
                     Width="300"
                     Padding="6,5"/>
            <Button x:Name="GoButton"
                    Content="Activate"
                    Padding="16,5"
                    Margin="12,0,0,0"
                    Click="OnActivateClick"/>
        </StackPanel>

        <TextBlock x:Name="StatusText"
                   Margin="0,16,0,0"
                   Foreground="#A9B2C3"
                   TextWrapping="Wrap"/>
    </StackPanel>
</Window>

using System;
using System.Windows;
using System.Windows.Media;
using UnifiedLicensing.Full;

namespace MyLicensedApp
{
    public partial class MainWindow : Window
    {
        private readonly UnifiedLicenseManager _manager = new(
            new UnifiedLicenseConfig
            {
                VendorApiKey = "ul_your_api_key",
                ProductKey   = "your-product-key",
                BaseUrl      = "https://api.unifiedlicensing.com/api/v1"
            });

        public MainWindow()
        {
            InitializeComponent();
            KeyBox.Focus();
        }

        private async void OnActivateClick(object sender, RoutedEventArgs e)
        {
            var key = KeyBox.Text.Trim();
            if (key.Length == 0)
            {
                StatusText.Text = "Please enter a license key.";
                return;
            }

            GoButton.IsEnabled = false;
            StatusText.Text = "Validating...";

            try
            {
                var result = await _manager.ValidateLicenseAsync(key);

                if (result.Valid)
                {
                    StatusText.Foreground = Brushes.LightGreen;
                    StatusText.Text = "Activated. Tier: " + (result.LicenseInfo?.Tier ?? "Standard");

                    // Open your main window, close this one:
                    // new ShellWindow().Show();
                    // Close();
                }
                else
                {
                    StatusText.Foreground = Brushes.IndianRed;
                    StatusText.Text = "Activation failed: "
                        + (result.Error ?? "Unknown error")
                        + (result.RequiresOnline ? " (connect to the internet)" : "");
                }
            }
            catch (Exception ex)
            {
                StatusText.Foreground = Brushes.IndianRed;
                StatusText.Text = "Something went wrong: " + ex.Message;
            }
            finally
            {
                GoButton.IsEnabled = true;
            }
        }
    }
}

dotnet new console -n MyLicensedCli
cd MyLicensedCli
# drop UnifiedLicensing.DotNet.v4.0-Full.cs into the folder

using System;
using System.Threading.Tasks;
using UnifiedLicensing.Full;

var config = new UnifiedLicenseConfig
{
    VendorApiKey = "ul_your_api_key",
    ProductKey   = "your-product-key",
    BaseUrl      = "https://api.unifiedlicensing.com/api/v1"
};

var manager = new UnifiedLicenseManager(config);

Console.Write("Enter your license key: ");
var key = (Console.ReadLine() ?? "").Trim();

Console.WriteLine("Validating...");
var result = await manager.ValidateLicenseAsync(key);

if (!result.Valid)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine("Invalid license: " + result.Error);
    if (result.RequiresOnline)
        Console.WriteLine("Connect to the internet and try again.");
    Console.ResetColor();
    return 1;
}

if (result.Cached)
    Console.WriteLine("(validated from offline cache)");

if (result.InGracePeriod)
{
    var days = TimeSpan.FromMilliseconds(result.GraceRemaining).Days;
    Console.WriteLine($"(grace period active, {days} day(s) remaining)");
}

Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("License OK. Tier: " + (result.LicenseInfo?.Tier ?? "Standard"));
Console.ResetColor();

// TODO: your actual app starts here
return 0;

// Decide your own policy for stale results:
var result = await manager.ValidateLicenseAsync(key);

if (result.Valid && result.GracePeriodExpired)
{
    // Still let them work, but nag politely:
    banner.Show("Couldn't reach the license server for a while. " +
                "Reconnect soon to keep verifying your license.");
}

using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class LicenseApi
{
    private static readonly HttpClient Http = new HttpClient();
    private const string Base = "https://api.unifiedlicensing.com/api/v1";

    private readonly string _apiKey;
    private readonly string _productKey;

    public LicenseApi(string apiKey, string productKey)
    {
        _apiKey = apiKey;
        _productKey = productKey;
    }

    private async Task<JsonDocument> PostAsync(string path, object payload)
    {
        var json = JsonSerializer.Serialize(payload);
        using var content = new StringContent(json, Encoding.UTF8, "application/json");

        using var response = await Http.PostAsync(Base + path, content);
        response.EnsureSuccessStatusCode();

        var stream = await response.Content.ReadAsStreamAsync();
        return await JsonDocument.ParseAsync(stream);
    }

    // POST /start-trial
    public Task<JsonDocument> StartTrialAsync(string machineId) =>
        PostAsync("/start-trial", new
        {
            api_key     = _apiKey,
            product_key = _productKey,
            machine_id  = machineId,
            platform    = "desktop"
        });

    // POST /check-trial
    public Task<JsonDocument> CheckTrialAsync(string trialToken, string machineId) =>
        PostAsync("/check-trial", new
        {
            api_key     = _apiKey,
            product_key = _productKey,
            trial_token = trialToken,
            machine_id  = machineId,
            platform    = "desktop"
        });

    // POST /heartbeat
    public Task<JsonDocument> HeartbeatAsync(string licenseKey, string machineId) =>
        PostAsync("/heartbeat", new
        {
            api_key      = _apiKey,
            product_key  = _productKey,
            license_key  = licenseKey,
            machine_id   = machineId,
            platform     = "desktop"
        });
}

var api = new LicenseApi("ul_your_api_key", "your-product-key");
var machineId = UnifiedLicensing.Full.HardwareFingerprint.Generate();

// ---- First launch: begin the trial -------------------
var started = await api.StartTrialAsync(machineId);
string trialToken = started.RootElement.GetProperty("trial_token").GetString();
// Save trialToken somewhere durable (encrypted settings, etc.)

// ---- Every launch after that: check it ---------------
var status = await api.CheckTrialAsync(trialToken, machineId);
int daysLeft = status.RootElement.GetProperty("days_remaining").GetInt32();

if (daysLeft <= 0)
{
    Console.WriteLine("Trial finished. Time to buy!");
    // show purchase screen...
}

private System.Windows.Forms.Timer _heartbeat;
private LicenseApi _api;
private string _licenseKey;
private string _machineId;

private void StartHeartbeat()
{
    _heartbeat = new System.Windows.Forms.Timer { Interval = 15 * 60 * 1000 }; // 15 min
    _heartbeat.Tick += async (s, e) =>
    {
        try
        {
            var reply = await _api.HeartbeatAsync(_licenseKey, _machineId);
            // Inspect the reply; lock the app if the license went invalid.
        }
        catch (HttpRequestException)
        {
            // Offline. No drama - retry on the next tick.
        }
    };
    _heartbeat.Start();
}

var config = new UnifiedLicenseConfig
{
    VendorApiKey = "ul_your_api_key",
    ProductKey   = "your-product-key",
    BaseUrl      = "https://api.unifiedlicensing.com/api/v1",
    HardwareBinding = HardwareBindingMode.Loose   // recommended
};

var result = await manager.ValidateLicenseAsync(key);

if (!result.Valid && result.ErrorCode == "HARDWARE_MISMATCH")
{
    MessageBox.Show(
        "This license is already active on another computer.\n" +
        "Contact support to move your activation.",
        "License in use",
        MessageBoxButtons.OK,
        MessageBoxIcon.Warning);
}