Unauthorized usage, shared license keys, cloned environments, and expired licenses still running in production are among the most common sources of unrecovered software revenue.
LicenseSpring gives you the enforcement infrastructure to stop these at every layer with device-level binding, VM and container detection, cryptographic license validation, and entitlement controls that work across cloud, desktop, on-premise, and offline deployments.
ISO 27001
Trusted by global software vendors
Developer-first APIs & SDKsRevenue leakage rarely comes from a single source. Vendors lose recoverable revenue across multiple vectors simultaneously, often without visibility into where or how it's happening.
Common sources LicenseSpring is built to address:
Shared license keys used across multiple users or installations
Virtual machine cloning and container duplication bypassing activation limits
Unauthorized installations across devices beyond the licensed count
Expired or unpaid licenses that remain active due to insufficient enforcement
Offline and air-gapped deployments operating without any license validation
Decompiled or reverse-engineered applications with licensing logic stripped out
Debugger-based attacks that extract embedded API secrets to spoof valid licenses
LicenseSpring provides multiple enforcement layers designed to stop both opportunistic and technically sophisticated license abuse.
Node-locked licenses are bound to specific hardware using device fingerprints, preventing software from being copied or activated across machines beyond the licensed count.
LicenseSpring generates an immutable hardware signature on activation, combining device identifiers with license-specific values that cannot be reproduced by key generators or spoofed by unauthorized clients.
Hardware ID and CPU/MAC address fingerprinting
Node-locked license enforcement
Device activation limits
Immutable hardware signature verification on every local license check
Virtualization and containerization create environments where license bypasses scale easily. LicenseSpring detects these behaviors at the environment level before they become a revenue problem.
VM cloning detection
Virtual environment fingerprinting
Container instance validation
Prevention of duplicate activations across cloned environments
LicenseSpring verifies licenses through cryptographic mechanisms that prevent tampering, modification, and replay attacks.
The License API returns a signed payload on every activation and check, signed by a private key held securely on the LicenseSpring backend, ensuring that neither the license data nor the server response can be forged.
Online license validation with signed API responses
Offline license files with cryptographic signature verification
Response payload signature validation (Response Signature v2)
Clock tamper detection—the SDK throws an exception if timestamp manipulation is detected
Time-based license verification
Strict limits on how many users or devices can access software at once enforced at the license level, not just the application layer.
Maximum device activation limits
Concurrent user and session limits
Floating license pool management
Seat-based license enforcement
License enforcement is only as strong as the application protecting it. LicenseSpring supports vendors in hardening their software against the reverse engineering and debugging techniques most commonly used to bypass licensing.
For C++ applications, the SDK offers compile-time encryption of embedded API secrets, decrypting them only at runtime, reducing the window in which secrets can be extracted by an attached debugger. SDK binaries targeting Windows are signed with an RSA-4096 certificate, and the C++ SDK verifies signatures of dynamically loaded libraries including the VM detection and hardware ID generator modules.
For Java applications, LicenseSpring provides a sample project demonstrating integration with ProGuard for bytecode obfuscation, making decompiled class files non-human-readable while preserving full application functionality. The LicenseSpring Java SDK includes a pre-installed public key certificate that validates the digital signature on every server response, confirming both the authenticity and integrity of licensing data in transit.
Supported hardening approaches by environment:
Compile-time secret encryption, ASLR compiler flags (/DYNAMICBASE /HIGHENTROPYVA on Windows; -fPIE -pie on Linux/macOS), symbol visibility controls, signed SDK binaries
ProGuard bytecode obfuscation, server-response signature verification via pre-installed public key certificate, OAuth authentication for API key rotation
Telemetry-based detection of suspicious hardware/device identifiers logged through online monitoring, supporting legal action against crackers without abruptly killing processes
License compliance requires visibility, not just enforcement. LicenseSpring gives vendors centralized control and monitoring across all active licenses, so unusual behavior is detected and addressed before it compounds.
With LicenseSpring, vendors can:
Track license activations and usage across customers
Monitor device associations per license
Detect anomalous or suspicious license behavior
Enforce license expiration and renewal policies automatically
Disable or revoke licenses remotely when necessary
License enforcement needs to work everywhere your software runs, not just in environments with reliable internet access.
LicenseSpring can be integrated quickly into your product to start enforcing licensing policies.
Discover how feature flags improve software flexibility, control, and safer releases in this complete guide.
Read More →
Explore alternatives to LicenseSpring for software licensing in LicenseSpring's blog post. Discover other licensing solutions and their features.
Read More →
Explore LicenseSpring's glossary entry on floating licenses. Learn about the concept and benefits of floating licenses in software licensing.
Read More →
