Migrate from Cryptlex to Licentric

• You want license keys + Stripe billing in one product with zero webhook glue code.
• You ship AI agents and need per-agent token budgets, identity, or MCP auth.
• You ship in containers (Docker, Kubernetes) and want native logical-ID fingerprinting instead of hardware-only fingerprints that break in containers.
• You want a free tier large enough for a real product launch (100 active licenses vs Cryptlex's 10 activations).
• You're cost-sensitive at scale — Licentric's paid tiers start at $5/mo vs Cryptlex's $100/mo Startup tier at comparable volume.
• You want a built-in end-user self-service portal (magic-link auth) on every tier.
• You want offline files signed with Ed25519 (FIPS 186-5, deterministic, 64-byte signatures).
• You want compliance scaffolding for the EU AI Act (phased enforcement starting August 2026).

• Customer email + status preserved. status=active stays active; suspended stays suspended; revoked remains revoked (terminal-state guarded).
• Expiry + activation allowance preserved. The Cryptlex expiry maps to license.expiresAt and the per-license activation allowance maps to maxActivations on the imported record (confirm whether your export column is the cap or the used count before importing).
• Metadata preserved. Any per-license JSON metadata you carry across is stored verbatim on the Licentric license.metadata field.
• Customers get a NEW Licentric-format key. Unlike a same-key swap, the generic import generates a fresh Licentric key per record and emails it to the customer with an activation link — your old Cryptlex key hash is retained only on metadata.migratedFromOldKeyHash for idempotent re-runs, never returned in plaintext.
• Audit history export — hold Cryptlex's activity logs as a CSV alongside Licentric's new append-only audit trail. We do not import historical Cryptlex audit rows into Licentric (separate retention contracts); export them once at cutover and archive.

Cryptlex's primary integration is the native, compiled LexActivator library — not a REST SDK. So the “before” below is the actual LexActivator C# call shape (verified against docs.cryptlex.com and cryptlex/lexactivator-dotnet), and the “after” is the Licentric REST SDK extracted from the published source (sdks/python/licentric/client.py and sdks/typescript/src/client.ts).

Before — Cryptlex (C#)

// BEFORE — Cryptlex LexActivator (native compiled library; C#)
// Verified against docs.cryptlex.com + github.com/cryptlex/lexactivator-dotnet
LexActivator.SetProductData("PASTE_CONTENT_OF_PRODUCT.DAT_FILE");
LexActivator.SetProductId("PASTE_PRODUCT_ID", LexActivator.PermissionFlags.LA_USER);
LexActivator.SetLicenseKey(productKey);
int status = LexActivator.ActivateLicense();           // hits /v3/activations
bool isValid = status == LexStatusCodes.LA_OK;
// On subsequent runs you verify locally with IsLicenseGenuine():
//   int s = LexActivator.IsLicenseGenuine();  // LA_OK == genuinely activated

After — Licentric (Python)

# AFTER — Licentric Python SDK (sdks/python/licentric, verified against client.py)
from licentric import Licentric

client = Licentric(api_key="lk_live_your_key_here")
result = client.validate(
    key=license_key,
    fingerprint=client.fingerprint(),
)
is_valid = result.valid  # ValidationResult with .code, .license, .machine

After — Licentric (TypeScript)

// AFTER — Licentric TypeScript SDK (sdks/typescript, verified against client.ts)
import { Licentric, fingerprint } from "@licentric/sdk";

const client = new Licentric({ apiKey: "lk_live_your_key_here" });
const result = await client.validate({
  key: licenseKey,
  fingerprint: await fingerprint(),
});
const isValid = result.valid;

Because the generic importer issues a NEW Licentric key per record and emails each customer, you do NOT want a blind run. Always dryRun: true first: it validates every record, the plan mappings, and the duplicate check, and returns the would-be result WITHOUT persisting anything or sending a single email. Inspect that preview, fix any unmapped plans, then commit.

The mapping and import flow are the same the in-product migration guide ships — a single source of truth so this page never drifts from the canonical sample. Cryptlex is one of its listed CSV-export supported platforms.

The migration is reversible until you cancel Cryptlex. Because the import generates new keys rather than swapping them in place, the cleanest safety net is to keep both systems live during a 30-day window:

1. Hold your Cryptlex account in read-only for 30 days after cutover — your old keys still validate there.
2. Export licenses from Licentric (Dashboard → Settings → Export Data, or GET /api/v1/licenses?limit=200 cursor-paginated) if you need the new-key records back.
3. If Licentric doesn't fit, point your application's validation back at LexActivator (your Cryptlex keys were never deactivated) and stop sending activation emails.
4. Cancel your Licentric subscription via the customer portal. No long-term contract; month-to-month.