If you sell desktop software, you need licensing. That is not a controversial statement. What is controversial—or at least quietly painful—is how most teams end up handling it. Some build a bespoke system from scratch: a database table for license keys, a validation endpoint, a crude admin page, and weeks of engineering time that could have gone toward the product itself. Others bolt on a third-party API that solves the technical problem but leaves you staring at someone else’s dashboard, someone else’s pricing model, and someone else’s idea of what “enough features” means.
Chiave is a hosted multi-tenant licensing dashboard from Wigley Studios. It handles the infrastructure—license generation, activation tracking, Stripe billing, encrypted tenant secrets, and audit trails—so you can focus on the software people are actually paying for. This article walks through what it does, how it is built, and where it sits relative to doing it yourself or using alternatives like Keygen or Gumroad.
What “Hosted” Means
Chiave runs on Wigley Studios infrastructure. You do not deploy a server, manage a database, or configure Stripe webhooks. You sign up, create your products, and start issuing licenses. Your customers validate against our API; your dashboard lives at chiave.wigleystudios.com. The engineering cost on your side is a single API call in your application’s startup sequence.
The Problem Chiave Solves
Building licensing from scratch is deceptively complex. The happy path—generate a key, check it on launch—takes a weekend. The real work starts after that: machine fingerprinting so licenses are not shared freely, activation limits so a single-seat license stays single-seat, grace periods for offline use so your customer’s laptop does not brick on a plane, webhook handling for Stripe so subscriptions actually create licenses, and an admin interface so you can see who is using what without running SQL queries by hand.
Most indie developers and small studios discover these requirements one at a time, usually when a customer emails to complain. By the time the licensing system is “done,” it has consumed weeks of engineering and created a maintenance surface that never stops growing. Every Stripe API change, every edge case in machine fingerprinting, every timezone bug in expiration logic becomes your problem forever.
Chiave absorbs that surface. The dashboard, the API, the webhook handling, the encryption—all maintained by Wigley Studios. Your engineering team writes one integration: a license check on app startup. Everything else is configuration in the dashboard.
Core Capabilities
License Generation and Validation
Create products and product versions in your dashboard. Issue license keys manually or automatically via Stripe checkout integration. Each license tracks its type (perpetual, subscription, trial), activation count, expiration date, and status. Your application calls a single validation endpoint at startup; the response tells it whether to proceed, prompt for a key, or show an expiration notice.
Machine-Level Activation Management
Every activation records a machine fingerprint. You define how many activations a license allows—one for a personal license, unlimited for a site license, anything in between. The dashboard shows exactly which machines are active, when they last validated, and whether any have gone dormant. Deactivation is one click when a customer replaces a computer or exceeds their limit.
Stripe Integration
Chiave connects to your Stripe account via encrypted API keys stored with Fernet encryption at rest. When a customer completes a Stripe checkout for your product, a webhook triggers license creation automatically. Subscription renewals extend the license; cancellations update the status. You do not write webhook handlers; Chiave processes them and logs the events in your audit trail.
Encrypted Tenant Secrets
Your Stripe keys, SMTP credentials, and other sensitive configuration are encrypted with Fernet before storage. They are never logged, never exposed in API responses, and never visible in the dashboard after initial entry. Multi-tenant isolation ensures that your data is logically separated from every other Chiave customer’s data at the middleware layer—every query is scoped to your tenant ID.
Audit Trail
Every license creation, activation, deactivation, status change, and webhook event is logged with timestamps, actor identification, and before/after state. The audit log is your paper trail for support disputes, compliance reviews, and the inevitable “what happened to this customer’s license?” question at 11 PM on a Friday.
Multi-Tenant Architecture
Chiave is built as a multi-tenant SaaS from the ground up, not a single-tenant tool that was retrofitted. Each tenant (your company) gets isolated data, isolated settings, and isolated Stripe configuration. Middleware enforces tenant boundaries on every database query—there is no code path that can accidentally cross tenant lines.
That architecture matters because licensing data is sensitive. Your customer list, activation patterns, and revenue data should not be one misconfigured JOIN away from another company’s dashboard. Chiave treats tenant isolation as a security invariant, not a feature flag.
For teams curious about how multi-tenant systems are built in practice, we explored the engineering patterns and tradeoffs in our insights article on the state of software licensing in 2026. The short version: tenant-scoped middleware, encrypted secrets, and advisory locking for concurrent operations are table stakes, not luxuries.
Pricing
Starter
- Up to 500 licenses
- Up to 100 customers
- 1 product
- Machine-level activations
- Stripe integration
- Audit trail
- Encrypted secrets
Unlimited
- Unlimited licenses
- Unlimited customers
- Unlimited products
- Machine-level activations
- Stripe integration
- Audit trail
- Encrypted secrets
Starter is designed for indie developers and small studios shipping one product with a manageable customer base. Unlimited is for companies with multiple products, larger customer counts, or growth trajectories that make per-unit limits annoying. Both tiers include the same security and integration features—the difference is scale, not capability.
Chiave vs. Building It Yourself
If you are a backend engineer, you can build a licensing system. The question is whether you should. A competent implementation takes two to four weeks of focused engineering: database schema, API endpoints, webhook handlers, admin UI, machine fingerprinting logic, and edge cases like clock skew and offline grace periods. Then it needs maintenance every time Stripe changes their API, every time you add a product tier, and every time a customer finds a way to share a key you did not anticipate.
Chiave costs $49.99/month at the Starter tier. That is less than a single day of developer time at most rates. The tradeoff is control: you own the dashboard and the data model when you build it yourself, but you also own every bug, every migration, and every 2 AM support ticket that turns out to be a licensing edge case.
For companies where licensing is the product—where the differentiation is in the enforcement logic itself—building custom makes sense. For everyone else, hosted infrastructure lets you ship the features your customers actually care about.
Chiave vs. Keygen, Gumroad, and LemonSqueezy
Keygen is the closest comparison: a serious licensing API with machine-level tracking. Keygen is developer-first and API-driven, which is a strength if your team prefers raw API calls over a dashboard. Chiave prioritizes the dashboard experience: you manage licenses, customers, and products through a visual interface without needing to memorize endpoint paths. Both handle activation tracking and Stripe; the difference is workflow preference.
Gumroad and LemonSqueezy are payment platforms with basic license key delivery. They generate a key when someone buys your product, but they do not track activations, enforce machine limits, or provide an admin dashboard for ongoing license management. If your needs stop at “send a key after checkout,” those platforms work. If you need to know which machines are running your software and revoke access when a subscription lapses, you need something built for licensing, not payments with a key field attached.
Choosing the Right Tool
Payment platforms (Gumroad, LemonSqueezy): best when you sell downloads and do not need activation tracking. Licensing APIs (Keygen): best when your team prefers code-first integration. Hosted dashboards (Chiave): best when you want visual management, encrypted secrets, and audit trails without building infrastructure.
Integration: One API Call
On the application side, Chiave integration is a single HTTPS request during your app’s startup sequence. Your application sends the license key and a machine fingerprint; the API responds with the license status, expiration date, and whether the activation is valid. The fingerprint can be derived from hardware identifiers your platform provides—WMI on Windows, system_profiler on macOS, or any deterministic combination your installer controls.
The validation response is designed for simple branching: if valid, proceed; if expired, show a renewal prompt; if the activation limit is exceeded, show a deactivation prompt. You do not parse complex JSON structures or implement retry logic for edge cases. The API is built to return clear, actionable status codes that map directly to UI states your application already needs.
Offline grace periods are configurable per product. If your customers work in environments with intermittent connectivity, you set a grace window—typically 7 to 30 days—during which the application accepts a cached validation result. When connectivity returns, the next validation syncs the latest status. This is handled on the API side; your application caches the last successful response and checks the timestamp.
Who Chiave Is For
Chiave is built for software companies that sell desktop applications and need real licensing infrastructure without building it. That includes indie developers shipping a first commercial product, small studios with one or two tools in the market, and growing teams that have outgrown a spreadsheet of license keys emailed manually after Stripe checkout.
It is not built for SaaS products (you do not need license keys if your product is a web app), open-source projects (different distribution model entirely), or companies whose licensing requirements are so specialized that off-the-shelf infrastructure cannot accommodate them. For everyone between “I need a key system” and “I need to build my own key system,” Chiave is the answer that lets you stay focused on the software your customers are paying for.
If you are evaluating options, start with the Chiave product page for the full feature list and signup flow. If you want the broader landscape of how licensing has evolved and where hosted solutions fit, our article on why indie developers are rethinking DIY licensing covers the market context. And if you are already building with Wigley Studios tools—PromptUI, the UI Kit Generator, or Developer Labs—Chiave is the same infrastructure, the same team, and the same commitment to tools that respect your time.