If you're shipping software that needs license enforcement — desktop apps, developer tools, SaaS add-ons — you've got two basic choices: build your own licensing server or use a hosted platform. Both Chiave and Keygen.sh exist to eliminate the build-your-own option. They're purpose-built licensing platforms, but they approach the problem from different angles.
The Core Difference
Chiave is a dashboard-first platform designed for software companies that want a visual interface for managing licenses, customers, and activations without writing API integration code. Keygen is an API-first platform designed for developers who want maximum flexibility and are comfortable building their own UI on top of a licensing API.
What Each Platform Does
Chiave is a hosted multi-tenant licensing dashboard built by Wigley Studios. Each tenant (software company) gets an isolated environment with encrypted secrets, Stripe-integrated billing, customer management, product versioning, and machine-level activation tracking. The dashboard handles everything visually — creating products, issuing licenses, monitoring activations, and viewing audit logs — without requiring API calls for day-to-day operations.
Keygen.sh is a licensing and distribution API for software companies. It provides a REST API for creating and validating licenses, managing machines, and distributing software releases. Keygen's strength is its policy engine, which lets you define complex licensing rules (node-locked, floating, concurrent, trial) through API configuration. It includes a web dashboard for monitoring, but the primary interface is the API itself.
Feature Comparison
| Feature | Chiave | Keygen.sh |
|---|---|---|
| Primary Interface | Visual dashboard | REST API (dashboard for monitoring) |
| Multi-Tenancy | Built-in — isolated tenant environments | Account-level isolation (no tenant nesting) |
| Machine-Level Activations | Fingerprint-based tracking | Machine component fingerprinting |
| License Types | Perpetual, subscription, trial | Perpetual, subscription, trial, floating, concurrent, node-locked |
| Policy Engine | Tier-based rules (Starter limits) | Flexible policy definitions via API |
| Stripe Integration | Native — per-tenant encrypted Stripe keys | Webhook-based integration |
| Secret Encryption | Fernet encryption for tenant secrets | Standard API key management |
| Customer Management | Built-in customer portal | User management via API |
| Product Versioning | Version history per product | Release management with channels |
| Audit Trail | Full audit log per tenant | Event logs with webhooks |
| Software Distribution | Not included | Built-in release hosting and auto-updates |
| Self-Hosted Option | Hosted only | Keygen CE (open source, self-hosted) |
| Setup Complexity | Minutes — sign up, configure in dashboard | Hours — API integration required |
Dashboard vs API: The Philosophy Split
This is the fundamental difference and the deciding factor for most teams. Chiave assumes you want to manage licensing through a visual interface. You create products, set up tiers, issue licenses, and monitor activations through the dashboard. Your application only needs to call a validation endpoint to check whether a license key is active and within its activation limit. The complexity lives in the dashboard, not in your code.
Keygen assumes you want to manage licensing through code. Its REST API gives you granular control over every aspect of the licensing lifecycle — creating policies, issuing licenses, validating entitlements, and managing machines. The dashboard exists primarily for monitoring and debugging, not for daily management. If your licensing requirements are complex (floating licenses, concurrent seat limits, feature flags per tier), Keygen's API gives you the flexibility to model them precisely.
Interface Philosophy Verdict
If your team includes non-technical stakeholders who need to issue licenses, manage customers, or review activations, Chiave's dashboard-first approach reduces the bus factor. If your licensing logic is deeply embedded in your application and managed entirely by developers, Keygen's API-first model provides more granular control.
Multi-Tenancy
Chiave's multi-tenant architecture is its strongest differentiator for agencies, studios, and companies that manage licensing for multiple software products or clients. Each tenant gets isolated data, encrypted secrets (Stripe keys, SMTP passwords stored with Fernet encryption), independent settings, and separate audit trails. Tenant isolation is enforced at the middleware level — there's no possibility of cross-tenant data leakage.
Keygen doesn't offer tenant nesting in the same way. Each Keygen account is effectively a single tenant. If you're managing licenses for multiple distinct products or clients, you'd need separate Keygen accounts or build your own tenant layer on top of the API. For a single software product, this isn't a limitation. For a studio shipping multiple products, it adds overhead.
Stripe Integration
Chiave's Stripe integration is native and per-tenant. Each tenant configures their own Stripe keys (encrypted at rest), and license provisioning can be linked directly to Stripe checkout events. When a customer completes a purchase, their license is created automatically. This end-to-end flow works out of the box through the dashboard.
Keygen supports Stripe through webhooks, which provides the same functionality but requires more integration work. You set up Stripe webhooks to notify Keygen when payments complete, and Keygen creates or activates licenses accordingly. The result is the same, but the setup path is longer and requires webhook configuration on both sides.
Licensing Flexibility
Keygen wins on licensing model flexibility. Its policy engine supports node-locked licenses, floating licenses (N concurrent activations from a pool), concurrent seat limits, feature entitlements, and custom metadata on every license object. If your product requires complex licensing logic — like allowing 5 simultaneous activations that can be deactivated and re-activated, or different feature sets per license tier — Keygen's policy model can express that.
Chiave covers the most common licensing patterns: perpetual licenses, subscription licenses with expiration, and trial licenses. Machine activation tracking with fingerprinting handles per-device enforcement. For most desktop software, developer tools, and SaaS add-ons, these patterns cover 90% of use cases. But if you need floating licenses or complex entitlement logic, you'd need to build that layer yourself.
Flexibility Verdict
Keygen's policy engine is more powerful and more configurable. If your licensing model is straightforward (perpetual, subscription, or trial with per-machine activation), Chiave handles it natively. If you need floating licenses, concurrent seats, or per-feature entitlements, Keygen provides the building blocks.
Software Distribution
Keygen includes built-in release management and software distribution. You can upload builds, organize them by channel (stable, beta, alpha), and serve downloads through Keygen's infrastructure with license-gated access. This is a genuine value-add for teams that need a combined licensing and distribution platform.
Chiave focuses exclusively on licensing and doesn't include release hosting or distribution features. If you need to distribute software, you'd pair Chiave with a separate hosting solution (your own CDN, GitHub Releases, or a dedicated distribution service). For many teams, especially those using existing CI/CD pipelines, this separation isn't a drawback — but it's worth noting.
Pricing
Chiave
- Starter: $49.99/mo ($499.99/yr)
- Unlimited: $99.99/mo ($999.99/yr)
- Starter: 500 licenses, 100 customers, 1 product
- Unlimited: no limits
- Multi-tenant isolation included
Keygen.sh
- Dev: Free (100 licenses, 25 machines)
- Indie: $49/mo (1,000 licenses)
- Business: $249/mo (unlimited)
- Keygen CE: Free, self-hosted (open source)
- Release distribution included on paid plans
Both platforms use tiered pricing, but the value proposition differs. Chiave's pricing includes multi-tenant infrastructure, Fernet-encrypted secret storage, and a full dashboard UI at every tier. Keygen offers a free development tier and a self-hosted open-source option (Keygen CE), which is compelling for solo developers or early-stage products that want to start without a monthly commitment.
For teams already generating revenue from their software, Chiave's Starter tier at $49.99/mo and Keygen's Indie tier at $49/mo are nearly identical in cost. The decision comes down to which feature set matches your workflow.
When to Use Each Platform
Use Chiave When:
You want a visual dashboard for managing licenses without writing API integration code. You manage multiple products or clients and need multi-tenant isolation. You use Stripe for billing and want native, encrypted payment integration. Your licensing model follows standard patterns (perpetual, subscription, trial) with per-machine activation. You want to be up and running in minutes, not hours.
Use Keygen When:
Your licensing requirements are complex (floating licenses, concurrent seats, feature entitlements). You prefer API-first integration and want to build your own management UI. You need built-in software distribution alongside licensing. You want a free development tier or a self-hosted open-source option. Your team is developer-heavy and comfortable working with REST APIs directly.
The Bottom Line
Chiave and Keygen solve the same core problem — managing software licenses without building your own infrastructure — but they optimize for different users. Chiave is the faster path for teams that want a working licensing system today, managed through a dashboard, with Stripe integration and multi-tenant isolation out of the box. Keygen is the more flexible platform for developers who need to model complex licensing policies and are willing to invest in API integration to get that control.
Neither platform is universally better. The right choice depends on whether your bottleneck is setup speed and operational simplicity (Chiave) or licensing model flexibility and developer control (Keygen).
For a deep dive into Chiave's architecture, read our Chiave product overview. For broader context on the licensing landscape, see our analysis of the state of software licensing in 2026.