Turn your Tauri app into a real business with licensing

Tauri tutorial: Adding a desktop app license key

Here's the actual code. This Tauri tutorial walks through the complete setup, and you can use it as a reference for your own Tauri app examples.

Step 1: Install the packages

In your Tauri project directory:

# Add the Tauri plugin (Rust side)
cargo add tauri-plugin-licenseseat --manifest-path src-tauri/Cargo.toml

# Add the frontend bindings (JavaScript/TypeScript)
npm add @licenseseat/tauri-plugin

Step 2: Configure the plugin

Add your API credentials to src-tauri/tauri.conf.json:

{
  "plugins": {
    "licenseseat": {
      "apiKey": "ls_live_your_api_key_here",
      "productSlug": "your-product-slug",
      "autoValidateInterval": 3600,
      "heartbeatInterval": 300,
      "offlineFallbackMode": "allow_offline",
      "maxOfflineDays": 7,
      "telemetryEnabled": true,
      "debug": false
    }
  }
}

What these settings do:

• apiKey: Your LicenseSeat API key (get it from your dashboard)
• productSlug: Identifies which product this app belongs to
• autoValidateInterval: Recheck the license every hour (3600 seconds)
• heartbeatInterval: Send a ping every 5 minutes for real-time seat tracking
• offlineFallbackMode: How to handle offline scenarios (network_only, allow_offline, or offline_first)
• maxOfflineDays: Grace period for offline use (7 days recommended)
• telemetryEnabled: Collect anonymous usage stats (OS, version, locale)
• debug: Enable console logging for development

Step 3: Register the plugin

In src-tauri/src/main.rs:

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_licenseseat::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

That's it for the Rust side. The plugin handles:

• Secure license storage in the system keychain
• Automatic device fingerprinting
• Background validation and heartbeats
• Offline artifact caching (the current Rust/Tauri SDK still uses signed offline tokens today)

Step 4: Add permissions

In src-tauri/capabilities/default.json, add the plugin permissions:

{
  "identifier": "default",
  "windows": ["main"],
  "permissions": [
    "core:default",
    "licenseseat:default"
  ]
}

Step 5: Frontend integration

Now wire up the UI. Here's a complete example:

import {
  activate,
  getStatus,
  hasEntitlement,
  deactivate
} from '@licenseseat/tauri-plugin';

// Check license status on app startup
async function checkLicense(): Promise<boolean> {
  try {
    const status = await getStatus();

    if (status.status === 'active') {
      return true; // Licensed, show full app
    }

    if (status.status === 'not_activated') {
      return false; // Not licensed, show activation UI
    }

    if (status.status === 'expired') {
      return false; // Expired, show renewal prompt
    }

    // Handle suspended state
    return false;
  } catch (error) {
    console.error('License check failed:', error);
    return false;
  }
}

// When user submits their license key
async function activateLicense(licenseKey: string): Promise<{
  success: boolean;
  license?: { deviceId: string; planKey: string };
  error?: string;
}> {
  try {
    const license = await activate(licenseKey);

    return {
      success: true,
      license: {
        deviceId: license.deviceId,
        planKey: license.planKey
      }
    };
  } catch (error: any) {
    // Error is a string message from the backend
    const message = typeof error === 'string' ? error : (error.message || 'Activation failed');

    if (message.includes('limit')) {
      return {
        success: false,
        error: 'This license is already active on too many devices. Deactivate another device first.'
      };
    }

    if (message.includes('expired')) {
      return {
        success: false,
        error: 'This license has expired. Please renew your subscription.'
      };
    }

    if (message.includes('invalid')) {
      return {
        success: false,
        error: 'Invalid license key. Please check and try again.'
      };
    }

    if (message.includes('network')) {
      return {
        success: false,
        error: 'Network error. Please check your connection and try again.'
      };
    }

    return {
      success: false,
      error: message
    };
  }
}

// Check if user has access to a specific feature
async function canUseProFeature(): Promise<boolean> {
  return await hasEntitlement('pro-features');
}

// Deactivate this device (frees up a seat)
async function deactivateDevice(): Promise<void> {
  await deactivate();
  // Show activation UI again
}

Example: License activation component (React)

import { useState } from 'react';
import { activate, getStatus } from '@licenseseat/tauri-plugin';

export function LicenseActivation({ onActivated }: { onActivated: () => void }) {
  const [licenseKey, setLicenseKey] = useState('');
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(false);

  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    setLoading(true);
    setError(null);

    try {
      await activate(licenseKey.trim());
      onActivated();
    } catch (err: any) {
      // Error is a string from the backend
      setError(typeof err === 'string' ? err : (err.message || 'Activation failed'));
    } finally {
      setLoading(false);
    }
  }

  return (
    <div className="license-activation">
      <h2>Enter your license key</h2>
      <p>You can find your license key in the email you received after purchase.</p>

      <form onSubmit={handleSubmit}>
        <input
          type="text"
          value={licenseKey}
          onChange={(e) => setLicenseKey(e.target.value)}
          placeholder="LS25-XXXX-XXXX"
          disabled={loading}
        />

        <button type="submit" disabled={loading || !licenseKey.trim()}>
          {loading ? 'Activating...' : 'Activate'}
        </button>
      </form>

      {error && <p className="error">{error}</p>}

      <p className="help">
        Don't have a license? <a href="https://your-store.com">Buy now</a>
      </p>
    </div>
  );
}

Feature gating with entitlements

Use entitlements for tiers (Free vs Pro) or time-limited access. The most common pattern: an updates entitlement that expires after 1 year. Customers keep the app forever but need to renew for new versions.

import { hasEntitlement, checkEntitlement } from '@licenseseat/tauri-plugin';

// Check if user can receive updates (common for perpetual licenses)
if (await hasEntitlement('updates')) {
  checkForUpdates();
} else {
  showRenewalPrompt(); // "Renew to get the latest features"
}

// Feature tier check
if (await hasEntitlement('pro-features')) {
  enableProFeatures();
}

// Detailed check with reason
const result = await checkEntitlement('cloud-sync');
if (result.active) {
  enableCloudSync();
} else {
  // result.reason tells you why: 'not_found', 'expired', 'no_license'
  showUpgradePrompt(result.reason);
}