Build Licensed Software
in Minutes

using ScaleGate.Licensing.SDK;

// In your App.xaml.cs or Program.cs
try
{
    var client = await LicenseClient
        .Create("YOUR_APP_ID", "XXXX-XXXX-XXXX-XXXX")
        .WithApiUrl("https://your-tenant.scalegate.io")
        .WithOfflineValidation(true)
        .WithGracePeriod(days: 7)
        .WithAutoRevalidation(intervalMinutes: 30)
        .BuildAndActivateAsync();

    if (client.Status == LicenseStatus.Active)
    {
        // License is valid - launch your app
        Console.WriteLine($"Licensed to: {client.LicenseInfo.CustomerName}");
        Console.WriteLine($"Expires: {client.LicenseInfo.ExpiresAt:d}");
    }
}
catch (LicenseActivationException ex)
{
    // Handle activation failure
    MessageBox.Show($"Activation failed: {ex.Message}");
}
catch (LicenseExpiredException ex)
{
    // Prompt user to renew
    MessageBox.Show($"License expired on {ex.ExpiredAt:d}. Please renew.");
}

var result = await client.ActivateAsync();

switch (result.Status)
{
    case LicenseStatus.Active:
        // Activation succeeded
        Console.WriteLine($"Activated for {result.CustomerName}");
        break;

    case LicenseStatus.DeviceLimitReached:
        // User has too many devices
        Console.WriteLine("Deactivate another device first.");
        break;

    case LicenseStatus.Expired:
        // Key has expired
        Console.WriteLine($"Expired on {result.ExpiresAt:d}");
        break;

    case LicenseStatus.Revoked:
        // Key was revoked by admin
        Console.WriteLine("This license has been revoked.");
        break;

    case LicenseStatus.Invalid:
        // Key not found or malformed
        Console.WriteLine("Invalid license key.");
        break;
}

var validation = await client.ValidateAsync();

if (validation.IsValid)
{
    // Good to go
    Console.WriteLine($"Valid until {validation.ExpiresAt:d}");
    Console.WriteLine($"Features: {string.Join(", ", validation.Features)}");
}
else
{
    // Check validation.Status for the specific reason
    HandleLicenseFailure(validation.Status, validation.Message);
}

var renewal = await client.RenewAsync();

if (renewal.Success)
{
    Console.WriteLine($"Renewed! New expiry: {renewal.ExpiresAt:d}");
}
else
{
    Console.WriteLine($"Renewal failed: {renewal.Message}");
}

var status = client.Status;       // LicenseStatus enum (cached)
var info = client.LicenseInfo;     // Full license details

statusLabel.Text = status switch
{
    LicenseStatus.Active       => "Licensed",
    LicenseStatus.GracePeriod  => $"Offline grace ({info.GraceDaysRemaining}d left)",
    LicenseStatus.Expired      => "Expired - please renew",
    _                           => "Unlicensed"
};

var client = await LicenseClient
    .Create("YOUR_APP_ID", licenseKey)
    .WithApiUrl("https://acme.scalegate.io")
    .WithOfflineValidation(true)
    .WithGracePeriod(days: 7)
    .BuildAndActivateAsync();

// Later, check if running in offline mode
if (client.Status == LicenseStatus.GracePeriod)
{
    var daysLeft = client.LicenseInfo.GraceDaysRemaining;
    ShowBanner($"Offline mode: {daysLeft} days remaining. Connect to revalidate.");
}

// 1. Check for updates
var update = await client.CheckForUpdateAsync(currentVersion: "1.2.0");

if (update.IsAvailable)
{
    Console.WriteLine($"Version {update.LatestVersion} available");
    Console.WriteLine($"Release notes: {update.ReleaseNotes}");

    // 2. Download with progress
    var filePath = await client.DownloadUpdateAsync(
        update,
        progress: (percent, bytesReceived, totalBytes) =>
        {
            progressBar.Value = percent;
            statusLabel.Text = $"Downloading... {percent}%";
        }
    );

    // 3. Apply and restart
    var applied = await client.ApplyUpdateAsync(filePath, restartApp: true);
}

// Status change event
client.StatusChanged += (sender, args) =>
{
    Console.WriteLine($"Status: {args.OldStatus} -> {args.NewStatus}");

    if (args.NewStatus == LicenseStatus.Expired)
        ShowRenewalDialog();
};

// Revalidation event (fires after each auto-revalidation check)
client.Revalidated += (sender, args) =>
{
    if (!args.Success)
        Console.WriteLine($"Revalidation failed: {args.Message}");
};

// Grace period warning
client.GracePeriodWarning += (sender, args) =>
{
    ShowBanner($"Offline for {args.DaysElapsed} days. {args.DaysRemaining} days left.");
};

// Update available event
client.UpdateAvailable += (sender, args) =>
{
    ShowUpdatePrompt(args.LatestVersion, args.ReleaseNotes);
};

using System.Windows;
using ScaleGate.Licensing.SDK;

namespace MyApp;

public partial class MainWindow : Window
{
    private LicenseClient? _license;

    public MainWindow()
    {
        InitializeComponent();
        Loaded += async (_, _) => await InitializeLicenseAsync();
    }

    private async Task InitializeLicenseAsync()
    {
        var key = LoadSavedKey() ?? await ShowKeyEntryDialogAsync();
        if (string.IsNullOrEmpty(key)) { Close(); return; }

        try
        {
            _license = await LicenseClient
                .Create("app_xxxxxxxxxxxx", key)
                .WithApiUrl("https://acme.scalegate.io")
                .WithOfflineValidation(true)
                .WithGracePeriod(days: 7)
                .WithAutoRevalidation(intervalMinutes: 60)
                .BuildAndActivateAsync();

            // Wire up events
            _license.StatusChanged += OnStatusChanged;
            _license.GracePeriodWarning += OnGraceWarning;
            _license.UpdateAvailable += OnUpdateAvailable;

            HandleStatus(_license.Status);
            SaveKey(key);
        }
        catch (LicenseActivationException ex)
        {
            MessageBox.Show($"Activation failed: {ex.Message}",
                "License Error", MessageBoxButton.OK, MessageBoxImage.Error);
            Close();
        }
    }

    private void HandleStatus(LicenseStatus status)
    {
        switch (status)
        {
            case LicenseStatus.Active:
                StatusBar.Text = $"Licensed to {_license!.LicenseInfo.CustomerName}";
                MainContent.IsEnabled = true;
                break;
            case LicenseStatus.GracePeriod:
                StatusBar.Text = "Offline mode - connect to revalidate";
                MainContent.IsEnabled = true;
                break;
            case LicenseStatus.Expired:
                StatusBar.Text = "License expired";
                MainContent.IsEnabled = false;
                ShowRenewalPrompt();
                break;
            default:
                StatusBar.Text = "Unlicensed";
                MainContent.IsEnabled = false;
                break;
        }
    }

    private void OnStatusChanged(object? s, LicenseStatusChangedArgs e)
        => Dispatcher.Invoke(() => HandleStatus(e.NewStatus));

    private void OnGraceWarning(object? s, GracePeriodArgs e)
        => Dispatcher.Invoke(() =>
            ShowBanner($"{e.DaysRemaining} days of offline access remaining"));

    private void OnUpdateAvailable(object? s, UpdateAvailableArgs e)
        => Dispatcher.Invoke(() =>
            ShowUpdateDialog(e.LatestVersion, e.ReleaseNotes));
}

import { useState, useEffect } from 'react';
import { ScaleGate } from '@scalegate/licensing-web-sdk';

export function useLicense(licenseKey: string) {
  const [status, setStatus] = useState<'loading' | 'active' | 'expired' | 'invalid'>('loading');
  const [features, setFeatures] = useState<string[]>([]);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const sg = new ScaleGate({
      appId: 'YOUR_APP_ID',
      apiUrl: 'https://acme.scalegate.io',
      heartbeatInterval: 300, // seconds
    });

    sg.initialise(licenseKey)
      .then((result) => {
        setStatus(result.status);
        setFeatures(result.features || []);
      })
      .catch((err) => {
        setStatus('invalid');
        setError(err.message);
      });

    return () => sg.destroy();
  }, [licenseKey]);

  return { status, features, error };
}

// Usage in a component:
function App() {
  const { status, features } = useLicense('XXXX-XXXX-XXXX-XXXX');

  if (status === 'loading') return <Spinner />;
  if (status !== 'active') return <PayWall />;

  return (
    <div>
      <h1>Welcome!</h1>
      {features.includes('pro-charts') && <ProCharts />}
    </div>
  );
}

import { ScaleGateServer } from '@scalegate/licensing-web-sdk/server';
import { NextResponse } from 'next/server';

const sg = new ScaleGateServer({
  appId: process.env.SCALEGATE_APP_ID!,
  apiKey: process.env.SCALEGATE_API_KEY!,
  apiUrl: process.env.SCALEGATE_API_URL!,
});

export async function POST(req: Request) {
  const { licenseKey } = await req.json();

  const result = await sg.validate(licenseKey, {
    domain: req.headers.get('origin') || undefined,
  });

  if (result.status !== 'active') {
    return NextResponse.json(
      { error: 'Invalid license', status: result.status },
      { status: 403 }
    );
  }

  return NextResponse.json({
    valid: true,
    features: result.features,
    expiresAt: result.expiresAt,
  });
}

import { ref, onMounted, onUnmounted } from 'vue';
import { ScaleGate } from '@scalegate/licensing-web-sdk';

export function useLicense(licenseKey: string) {
  const status = ref('loading');
  const features = ref<string[]>([]);
  let sg: ScaleGate;

  onMounted(async () => {
    sg = new ScaleGate({
      appId: 'YOUR_APP_ID',
      apiUrl: 'https://acme.scalegate.io',
    });
    const result = await sg.initialise(licenseKey);
    status.value = result.status;
    features.value = result.features || [];
  });

  onUnmounted(() => sg?.destroy());

  return { status, features };
}

<script src="https://cdn.scalegate.io/sdk/web/latest/scalegate.min.js"></script>
<script>
  const sg = new ScaleGate.Client({
    appId: 'YOUR_APP_ID',
    apiUrl: 'https://acme.scalegate.io',
  });

  sg.initialise('XXXX-XXXX-XXXX-XXXX')
    .then(function(result) {
      if (result.status === 'active') {
        document.getElementById('app').style.display = 'block';
      } else {
        document.getElementById('paywall').style.display = 'block';
      }
    });
</script>

import express from 'express';
import { ScaleGateServer } from '@scalegate/licensing-web-sdk/server';

const sg = new ScaleGateServer({
  appId: process.env.SCALEGATE_APP_ID!,
  apiKey: process.env.SCALEGATE_API_KEY!,
  apiUrl: process.env.SCALEGATE_API_URL!,
});

// Middleware that validates license on every request
export const requireLicense = async (req, res, next) => {
  const key = req.headers['x-license-key'];
  if (!key) return res.status(401).json({ error: 'License key required' });

  const result = await sg.validate(key, { domain: req.hostname });

  if (result.status !== 'active') {
    return res.status(403).json({ error: 'License invalid', status: result.status });
  }

  req.license = result;
  next();
};

// Usage
const app = express();
app.use('/api', requireLicense);
app.get('/api/data', (req, res) => {
  res.json({ data: 'protected content', features: req.license.features });
});

const result = await sg.initialise('XXXX-XXXX-XXXX-XXXX');
// result: { status, features, customerName, expiresAt, sessionId }

const result = await sg.validate('XXXX-XXXX-XXXX-XXXX');
// result: { valid, status, features, expiresAt, message }

const features = await sg.checkFeatures('XXXX-XXXX-XXXX-XXXX');
// features: { enabled: ['pro-charts', 'export-pdf'], plan: 'professional' }

// Heartbeat is automatic when heartbeatInterval > 0
// Manual heartbeat:
const hb = await sg.heartbeat('XXXX-XXXX-XXXX-XXXX');
// hb: { alive: true, status: 'active' }

import { useLicense } from './useLicense';

function Dashboard() {
  const { status, features } = useLicense(userLicenseKey);

  const hasAdvancedAnalytics = features.includes('advanced-analytics');
  const hasExportPdf = features.includes('export-pdf');
  const hasWhiteLabel = features.includes('white-label');

  return (
    <div>
      <BasicDashboard />

      {hasAdvancedAnalytics ? (
        <AnalyticsPanel />
      ) : (
        <UpgradeCard feature="Advanced Analytics" />
      )}

      {hasExportPdf && <ExportButton format="pdf" />}

      {hasWhiteLabel && <BrandingSettings />}
    </div>
  );
}

{
  "licenseKey": "XXXX-XXXX-XXXX-XXXX",
  "deviceFingerprint": "hw_abc123...",
  "deviceName": "John's Workstation",
  "appVersion": "1.2.0"
}

{
  "status": "active",
  "customerName": "Acme Corp",
  "customerEmail": "admin@acme.com",
  "expiresAt": "2027-01-15T00:00:00Z",
  "features": ["pro-charts", "export-pdf"],
  "maxDevices": 5,
  "activeDevices": 2,
  "message": "Activation successful"
}

{
  "licenseKey": "XXXX-XXXX-XXXX-XXXX",
  "deviceFingerprint": "hw_abc123..."
}

{
  "valid": true,
  "status": "active",
  "features": ["pro-charts", "export-pdf"],
  "expiresAt": "2027-01-15T00:00:00Z",
  "message": "License is valid"
}

{
  "updateAvailable": true,
  "latestVersion": "2.0.1",
  "downloadUrl": "https://acme.scalegate.io/dl/myapp-2.0.1.exe",
  "releaseNotes": "Bug fixes and performance improvements",
  "fileSize": 15728640,
  "isMandatory": false
}

{
  "licenseKey": "XXXX-XXXX-XXXX-XXXX",
  "domain": "myapp.example.com"
}

{
  "status": "active",
  "sessionId": "sess_xxxxxxxxxxxxxxxx",
  "customerName": "Acme Corp",
  "features": ["pro-charts", "export-pdf"],
  "expiresAt": "2027-01-15T00:00:00Z"
}

{
  "licenseKey": "XXXX-XXXX-XXXX-XXXX",
  "domain": "myapp.example.com"
}

{
  "valid": true,
  "status": "active",
  "features": ["pro-charts", "export-pdf"],
  "expiresAt": "2027-01-15T00:00:00Z"
}

{
  "licenseKey": "XXXX-XXXX-XXXX-XXXX"
}

{
  "enabled": ["pro-charts", "export-pdf", "advanced-analytics"],
  "plan": "professional"
}

{
  "alive": true,
  "status": "active"
}