Licensing is one of those problems that looks simple until you build it. You need key generation, activation tracking, machine fingerprinting, expiration logic, grace periods, a dashboard for support staff, and — eventually — Stripe integration so purchases actually produce keys without manual intervention. Most teams either bolt together a brittle in-house solution or adopt an API-only platform that still requires significant frontend work. Chiave (Italian for “key”) takes the other path: a hosted, dashboard-first licensing platform where you manage keys, customers, and products from a browser, and your application validates licenses through a straightforward REST API.
This guide walks through the practical workflow: subscribing, onboarding, creating your first product and licenses, integrating validation into your app, connecting Stripe for automation, and using the audit trail to stay informed. If you want the product-level overview and positioning, start with the Chiave product introduction.
What Chiave Replaces (and Why That Matters)
Before Chiave, Wigley Studios offered Admin Pro — a self-hosted licensing server you deployed on your own infrastructure. It worked, but it meant maintaining a database, patching a server, configuring HTTPS, and debugging edge cases around concurrent activations. Chiave eliminates that operational surface entirely. You subscribe, complete an onboarding wizard, and start issuing keys within minutes. The infrastructure, encryption (Fernet for tenant secrets at rest), multi-tenant isolation, and uptime are handled for you.
That shift matters most for small studios and solo developers who ship desktop or mobile software. Licensing shouldn’t consume the same engineering hours as the product itself. Chiave lets you treat it as a service: configure your rules, call the API, and focus on building the thing people actually pay for.
Hosted, Not Self-Hosted
Chiave runs at chiave.wigleystudios.com. There is no on-premise version. Your application communicates with Chiave’s public API to validate, activate, and deactivate licenses — one HTTPS call per operation. Multi-tenant architecture means each customer account is fully isolated at the middleware level.
Getting Started: Subscribe and Onboard
Chiave offers two tiers. Starter ($49.99/month or $499.99/year) covers up to 500 licenses, 100 customers, and 1 product — enough for most indie developers and small studios shipping a single application. Unlimited ($99.99/month or $999.99/year) removes all caps and adds Stripe webhook automation, custom email configuration, and white-label branding.
After subscribing, the onboarding wizard walks you through three steps:
- Company profile. Enter your studio or company name, which appears in the dashboard and any customer-facing communications.
- Stripe connection (optional at this stage). Link your Stripe account so Chiave can listen for purchase events. Unlimited-tier subscribers can configure webhook automation later if they prefer to start manually.
- First product. Define your software product — name, version, and basic activation rules (maximum machines per license, grace period duration for offline validation).
Once onboarding completes, you land on the dashboard with an empty license table and a product ready to receive keys.
Creating and Managing License Keys
Licenses in Chiave carry three types: perpetual (no expiration), subscription (tied to a billing cycle), and trial (time-limited evaluation). Each license tracks its status, activation count, machine fingerprints, creation date, and the customer it belongs to.
From the dashboard you can:
- Generate keys individually or in batches, assigning them to an existing customer or leaving them unassigned for later distribution.
- Set activation limits per license — for example, allow a key to activate on up to three machines simultaneously.
- Revoke or suspend a key instantly, which takes effect the next time the application calls the validation endpoint.
- View activation history for any key: which machines activated, when, and from which IPs.
Customer records aggregate all licenses belonging to a single buyer, giving support staff a single view of purchase history, active keys, and activation status without switching between Stripe and a spreadsheet.
Trial Licenses as Onboarding
Use trial-type licenses as your free evaluation path. Set a duration that gives prospective customers enough time to explore your software meaningfully — typically 14 or 30 days. When the trial expires, the validation endpoint returns an expired status, and your app can prompt for a purchase. No separate trial infrastructure required.
Integrating License Validation Into Your Application
Chiave exposes three public REST endpoints under /api/v1/{tenant-slug}/licenses/. No SDK is required — any language that can send an HTTPS POST request works.
| Endpoint | Purpose | Key Fields |
|---|---|---|
/validate |
Check whether a license key is valid, active, and within its activation limit | Returns validity, status, license type, expiration, activation count, can_activate |
/activate |
Register a machine against a license key | Accepts license_key, machine_id, optional machine_name |
/deactivate |
Remove a machine from a license key’s activation list | Accepts license_key, machine_id |
A typical integration pattern in a desktop application:
- On first launch, prompt the user for a license key.
- Call
/validatewith the key. If valid andcan_activateis true, call/activatewith a machine fingerprint (hardware ID, MAC address hash, or similar). - Cache the activation result locally with a timestamp. On subsequent launches, re-validate periodically (daily or weekly) rather than on every startup.
- If the user switches machines, call
/deactivateon the old machine first, or let them manage activations through your app’s settings.
Chiave supports offline grace periods configured per product. If your user’s machine can’t reach the API (airplane mode, restricted network), the cached validation remains valid for the grace window you defined — typically a few days to a week. After that, the application should require a successful validation to continue.
Automating License Issuance With Stripe
Manual key generation works for small volumes, but most growing businesses want purchases to produce keys automatically. On the Unlimited tier, Chiave supports Stripe webhook automation: when a customer completes a checkout, Stripe fires a webhook to Chiave, which generates a license, associates it with the customer, and (with custom email configured) sends the key directly to the buyer.
The setup involves three pieces:
- Stripe API keys in Chiave’s settings — your publishable and secret keys connect the accounts.
- Webhook secret — Chiave verifies every incoming webhook signature to prevent spoofed events.
- Product mapping — link your Stripe product/price IDs to the corresponding Chiave product so the system knows which type of license to generate for each purchase.
Once configured, the pipeline is fully automatic: Stripe handles payment, Chiave handles license creation, and your application validates the key the customer receives. Subscription renewals and cancellations flow through the same webhook channel, keeping license status synchronized with billing status without any manual intervention.
Audit Trail
Every action in Chiave — key generation, activation, revocation, settings changes, webhook events — is logged with timestamps and IP addresses. The audit trail is accessible from the dashboard and designed to answer support questions quickly: “When was this key activated? From where? By whom?” Both tiers include full audit logging; the difference between Starter and Unlimited is scale and automation, not visibility.
Where Chiave Fits in the Wigley Studios Ecosystem
Chiave is one piece of a broader product line. If you’re building the software that needs licensing, you might also use Developer Labs (free browser tools for API contracts, design tokens, and mock data), PromptUI for generating UI components from text descriptions, the UI Kit Generator and UI Kit Packs for production-ready component libraries, or PicSift for desktop photo deduplication. Chiave sits at the distribution end of that pipeline: you build the product, then use Chiave to control who can run it and under what terms.
For teams evaluating Chiave against other platforms, the Chiave vs. Keygen comparison breaks down the differences in approach, pricing, and feature scope.