Software licensing, without the hand-waving.
Field guides for developers building activation, offline access, payments, and license enforcement. Every article is grounded in a real implementation.
Getting Started: Create Your First Product and License Key
A real, step-by-step walkthrough with real screenshots — from an empty account to a working license key in about five minutes. First in a 5-part series.
Read the walkthroughStart here
Three steps from the core architecture to a working integration and real-world enforcement.
How to Build a License Key System
The real architecture behind a license key system — key format design, why servers should never store plaintext keys, and the lookup mechanism that makes validation fast and safe.
7 min read · video includedIntegrate PermitCore with Your .NET Application in 15 Minutes
Install the SDK, validate and activate license keys in C#, handle offline grace periods, and protect against key sharing — production-ready code.
12 min read · video includedHow to Prevent License Key Sharing
Three real, complementary techniques — node-locking, floating seat limits, and abuse detection — that stop one key from quietly becoming everyone's key.
6 min read · video includedExplore the library
Compare trial expiry, subscription expiry and perpetual fallbackHow to License a WordPress Plugin or Theme: Sites, Staging and Updates
Add license keys to a WordPress plugin: per-site activation, staging exceptions, WP-Cron checks, safe failure and updates only for valid keys.
Hardening an Electron App's License Check: Main Process, Fuses, ASAR Integrity and Signed Tokens
Stop "unpack app.asar, edit one line" cracks: keep your Electron license check in the main process, flip the fuses, enable ASAR integrity, sign tokens.
Open Core and Fair Source: How to Gate Paid Features in Self-Hosted Software with License Keys
Ship a free community edition and a paid one from the same public repo. How license keys gate paid features in open core and Fair Source software.
Your Store, Your Payment Account: Sell Software with Paddle or Lemon Squeezy
Connect your own payment account to a branded software Store. Follow setup, verified payment and license access in the customer’s account.
What Happens to Your Software When a Subscription Ends?
See an expired trial, an ended subscription and a perpetual fallback license from the customer’s side, with a product-scoped Python validation example.
How to Run a License Check at App Startup Without Blocking the Window
Validate software licenses without slowing launch. Use verified offline tokens, background checks and timeouts while honoring expiry and revocation.
Switch Licensing Providers Without Replacing Customer Keys
Plan a licensing-provider migration with existing keys, reviewed imports, device re-enrollment, new client trust and a separate payment cutover.
License and Sell a Python Desktop App
Package a licensed Python desktop app with deliberate device state, signed offline trust and tested payment delivery. Plan PyInstaller or Nuitka releases.
License Error Messages That Help Paying Customers
Design clear license errors for wrong products, device capacity, expiry and outages. Give buyers a recovery path while preserving the entitlement decision.
Perpetual Fallback Licenses: Keep a Version, Renew Updates
Separate perpetual access, maintenance and offline expiry. Design eligible-version delivery and renewal rules using existing license controls.
Sell Your Game Outside Steam: Keys, Downloads and Direct Sales
Sell a game outside Steam with clear choices between Steam keys, itch.io downloads and your own licensed build. Plan payment, delivery and support.
Signing Key Rotation for License Keys: Planned Changes and Compromise Recovery
Rotate license-signing keys with an explicit application trust rollout. Understand old proofs, compromised keys, offline limits and secure export.
Software Licensing in Virtual Machines: Clones, Moves and VDI
Handle cloned VMs, changing device IDs and VDI sessions with clear activation, recovery and offline policies for software licensing in virtual machines.
Team Licenses for Software: Seats, Devices and Self-Service
Sell a team license for software with clear device or concurrent limits, fixed seat packs and controlled self-service reassignment.
How to Monetize an MCP Server with License Keys
Sell access to MCP tools with product-scoped license checks, private client configuration and clear offline, authentication and seat boundaries.
Paddle License Keys: Automate Delivery, Renewals and Refunds
Connect Paddle payments to software license keys. Handle renewals, failed payments, refunds and webhook retries, with a Stripe comparison.
The Cyber Resilience Act for Indie Software Sellers
Plan support periods, security updates and software licenses under the EU Cyber Resilience Act, with verified dates and clear product boundaries.
How to License a Command-Line Tool for CI, Docker and SSH
Add a license key for a CLI tool with non-interactive checks, safe secret input, predictable exit codes and deliberate CI seat policies.
How to Generate License Keys for Your Software (with Code)
Learn how to generate license keys in C#, Python and Node.js, choose random or signed keys, and connect generation to secure validation.
Owned, Not Rented: How to Sell Software Licenses That Survive Server Shutdowns and New Ownership Laws
Software license vs ownership: honest checkout terms, signed offline limits, device transfers, and an end-of-life plan for indie software.
Your Software Got Cracked or Copied: What Indie Developers Can Actually Do
A realistic response plan for cracked apps, leaked keys, keygens, and unauthorized re-uploads: preserve evidence, use the right takedown, revoke precisely, and make the legitimate product more valuable.
Merchant of Record vs Your Own Stripe Account: How to Sell Software Licenses (and Handle VAT)
Merchant of record or your own Stripe account? How each model handles VAT, fees, payouts and license key delivery for indie software sellers.
How to Add a Free Trial to Your Desktop App Without Easy Trial Resets
Build a 14-day software free trial license with server-side expiry, device binding, honest offline limits, and a paid upgrade path that does not require reinstalling.
Introducing PermitCore Store 2.0
A new responsive storefront and Shop Designer for software vendors: editorial merchandising, configurable sections, product galleries, discounts, trials, and secure payment-to-license delivery.
Integrate PermitCore with Your Unity Game in 15 Minutes
Install the Unity SDK, validate and activate license keys, handle offline grace periods, and avoid the exact setup mistakes we hit building this SDK's own demo — including a real 'main thread only' bug.
Announcing the PermitCore Unity SDK
The 8th official PermitCore SDK is live — a zero-dependency Unity 2021.2+ client with native ECDSA offline verification and a single-script demo app, no Canvas or prefab setup required.
Announcing the PermitCore Go SDK
The 7th official PermitCore SDK is live — a zero-dependency Go 1.21+ client with native ECDSA offline verification, a working demo app, and full docs.
Software Licensing APIs Compared: SDKs, Offline and Billing
A factual, sourced roundup of PermitCore, Keygen, Devolens (formerly Cryptolens), and LicenseSpring — what each is actually good for, not a ranked 'winner.'
Software Licensing API: What to Look For
A practical evaluation checklist for picking a software licensing API — the questions worth asking about key security, offline support, seat enforcement, and vendor lock-in.
How to Transfer a Software License to a New Computer
The real deactivate-then-reactivate flow that lets a customer move a node-locked license to a new machine themselves, without a support ticket.
What Happens If a License Server Goes Down?
Three real layers that decide what happens to a customer's app during an outage — automatic offline fallback, deliberate signed offline tokens, and the self-hosted continuity path for a total shutdown.
Software Licensing for Desktop Applications
What's actually different about licensing a desktop app versus a web service — trial periods, node-locking to a specific machine, surviving reinstalls, and working without a constant connection.
How to Build a License Key System
The real architecture behind a license key system — key format design, why servers should never store plaintext keys, and the lookup mechanism that makes validation fast and safe.
Perpetual License vs Subscription License: Which Should You Sell?
The real tradeoffs between selling a license that never expires and one that renews — revenue shape, maintenance obligations, and how to configure either (or both) for the same product.
When to Revoke a License After a Failed Payment
How Store subscriptions renew the same key, keep access during payment grace, expire at the grace deadline, and revoke when the subscription ends.
Why MAC Addresses Are Bad Hardware IDs
MAC addresses are spoofable, multi-valued, randomized by modern OSes, and unstable inside VMs and containers — why they're a poor foundation for device-locked licensing, and what works instead.
Usage-Based / Metered Software Licensing Explained
How metered licensing actually works end to end — recording usage events against a license key, per-tenant event configuration, and how usage flows into real Stripe billing.
How to Implement Feature-Based Licensing
How to gate individual features by license tier instead of just validating a key — the real FeaturesJson field, the API response shape, and the SDK's HasFeature() check.
Build vs Buy: Should You Build Your Own Software Licensing System?
What actually goes into a production license server — activation races, offline verification, RLS, abuse detection — and what it honestly costs to build versus buy.
PermitCore vs Keygen, Cryptolens, LicenseSpring, and Cryptlex
A factual, dated comparison of five licensing platforms — including Store and checkout workflows, self-hosting, SDK coverage, and where each option is stronger.
How to Prevent License Key Sharing
Three real, complementary techniques — node-locking, floating seat limits, and abuse detection — that stop one key from quietly becoming everyone's key.
Offline License Validation in C#: Verifying Signed Tokens Without a Server
The real ECDSA P-256 signature check from PermitCore's .NET SDK, the token format, and what a signed token can and can't protect against.
Software Licensing with Stripe: How the Checkout-to-License Flow Actually Works
A real walkthrough of how PermitCore turns a Stripe checkout into a working license key automatically — the webhook flow, your own Stripe account, and 0% commission.
Setting Up a License Store: Selling Keys Directly to Customers
Add a product, choose Stripe, Paddle or Lemon Squeezy, and get a real checkout page that issues license keys automatically.
Node-Locked vs. Floating Licenses: Which One Do You Need?
A practical, example-driven comparison of the two license models, and how to configure each.
Offline Grace Mode: Keeping Your App Working Without a Connection
Signed cache tokens, how many grace days to allow, and the honest limits of what offline verification can and can't stop.
Activating a License on a Device: How Hardware IDs Work
What actually happens when a customer's app calls activate() — hardware fingerprinting, activation limits, and reactivation on the same device.
Getting Started: Create Your First Product and License Key
A real, step-by-step walkthrough with real screenshots — from an empty account to a working license key in about five minutes. First in a 5-part series.
Zero-Knowledge Storage: Scope, Limits and Recovery
Learn where browser passphrase encryption protects stored license material, why validation and Store delivery involve server access, and how optional escrow changes recovery.
License Key Distribution: The 5 Models Every Software Vendor Should Know
Perpetual, subscription, floating, node-locked, metered — each model solves a different problem and creates different support headaches.
Integrate PermitCore with Your .NET Application in 15 Minutes
Install the SDK, validate and activate license keys in C#, handle offline grace periods, and protect against key sharing — production-ready code.