What you run, and what you control
A self-hosted installation is the same Carcha Seal server that runs the hosted service, with one vendor: yours. You run it with Docker on a host you choose, and everything the licensing depends on stays with you.
| Part | Who holds it | What it means |
|---|---|---|
| Signing key | You | Your own Ed25519 key signs every lease your customers' apps verify. It is generated on your server and never leaves it. Keep it: your apps trust its public half. |
| Database and customer data | You | Licenses, devices, activations and customer records live in your MySQL. Use the MySQL the image brings, or point it at a server you already run. |
| Admin key and console | You | The admin API and the console answer only to a key you set. The server issues, renews and revokes entirely on your host. |
| The server image | Carcha Labs, licensed to you | A private container image. Your account is granted access and pulls it with your own token; the right to run it comes from the agreement. |
| Server license file | Carcha Labs issues, you load | A signed file, exchanged like a Sentinel Master license, that lets the server issue. Renewed by file, with no call home. |
There is no runtime connection to Carcha Labs. The server does not phone home to issue a license, and a self-hosted server never serves the public Carcha Seal website or sign-up.
What is in the package
To stand a server up you need Docker with Compose, about 1 GB of memory, and two files from Carcha Labs: a docker-compose.yml and an environment template. From those you run:
- The license server and admin console. One container image holds the activation API, the admin API and the React console, served on
127.0.0.1:4000. You put a reverse proxy that terminates HTTPS in front of it. - A database. MySQL 8.4 runs in its own container and volume, TLS only. Or set
DATABASE_URLto a MySQL 8.0+ server you already operate. - Your secrets, set once. A MySQL password, an admin key, and your own
LICENSE_SIGNING_KEY. You pull the image afterdocker loginto the private registry, copy the environment template, and bring it up withdocker compose up -d. - Backups and upgrades. A backup tool writes a checked, consistent copy; a new version is a change of image tag followed by
docker compose pull, and the server upgrades its own tables.
What your customers install is separate: the Carcha Seal SDK for Electron and Node.js, .NET or C++, embedded in your application. Each one verifies a lease offline against your public key.
Licensing the server, by file
The server itself carries a license, on the model of Thales Sentinel LDK-EMS on premises, where license generation works only while the vendor's Master license is present and that license is renewed by a C2V → V2C file exchange.
- In the console, open Server license and download a request file. It identifies that one installation.
- Send it to Carcha Labs and load the license file you get back. The status shows the customer name, the end date and the renewal date.
- Before the renewal date, send a new request file and load the new license. The exchange is files; the server needs no connection to Carcha Labs.
A license is bound to one server, by a hash of its installation id and the host machine. A new installation runs a 14-day evaluation. After that, without a valid license, the server keeps serving your existing customers — check-ins, deactivations and the console's views — but stops issuing new activations, licenses and products until it is licensed again.
You are never stranded: the perpetual fallback
A licensing server you do not control is a risk a serious buyer weighs: what happens to your business if the vendor disappears. Carcha Seal answers it the way JetBrains answers it for its tools, with a perpetual fallback.
After 12 consecutive months of a self-hosted subscription, every license file issued to your server carries a perpetual fallback. Past its end or renewal date, such a file keeps the server issuing licenses on the version it runs — instead of stopping — even if the subscription ends or Carcha Labs stops operating. The signature and the server binding still hold: a file for another server, from another key, or edited, does not work. New releases still come through your image access, which is part of the subscription; the fallback covers the version you already run.
Signing keys and rotation
Your signing key is an Ed25519 key your server holds. Your apps ship only its public half and verify leases against it offline, so the key never has to travel. Its working life is one to three years, following NIST SP 800-57.
Rotation does not strand installed apps, because the next key is published before it signs anything. The order is: the next key's public half is added to a release of your app, that release goes out, and only then does the server start signing with the next key. During the change an app trusts both the current and the previous key, so leases signed before and after the rotation both verify.
The one honest limit: fully retiring a key — refusing everything it ever signed, as you would after a suspected leak — needs an app release that drops it. That is true of every system that verifies offline, where the trust lives in the installed app; the published-next-key mechanism is what makes a planned rotation invisible to installed apps and a forced one a single release.
Security and operations
- HTTPS in front. The server publishes on loopback only; you terminate TLS with nginx, Caddy, Apache, Traefik or a Cloudflare Tunnel. It reads the real client address from the proxy you trust, so rate limits and the sign-in lockout count the right host.
- Encrypted database link. The bundled MySQL accepts TLS connections only, and the server checks its certificate against the CA MySQL generated.
- Limits and lockout. Client requests are rate limited; ten wrong admin keys from one address lock it out for the window. Keys are stored hashed; the admin key is compared in constant time.
- Backups you can verify. The backup tool writes a consistent copy and can verify and restore it; a restore on the same host keeps the server license.
- Tested end to end. Each release is run against the published SDKs on Windows and macOS: node-locked and floating licenses, offline activation by file, feature decryption, key replacement, tamper detection and the access-control checks.
How this compares
Most licensing vendors offer some form of on-premises or self-hosted server, but usually only on an enterprise tier and contract. With Carcha Seal, running the whole server yourself — your signing key, your database, offline by file — is available under a written agreement without an enterprise plan. The row-by-row detail, checked against each vendor's own current documentation, is on the comparison pages.
Carcha Seal vs Cryptlex · vs LicenseSpring · How offline verification works · What an entitlement holds
Questions
Does a self-hosted server call home?
No. It issues and verifies licenses with no connection to Carcha Labs. Its own license is renewed by a file you exchange, and it never serves the public website or sign-up. You pull the image and new versions from a private registry.
Who holds the signing key?
You do. It is generated on your server, never leaves it, and signs the leases your apps verify. You rotate it yourself from the console.
What happens if Carcha Labs stops operating?
After 12 consecutive months of subscription your license file carries a perpetual fallback, so the server keeps issuing on the version it runs. You are not locked out of your own licensing.
Can we use our own database?
Yes. Point the server at a MySQL 8.0+ server you already run over TLS, or use the MySQL 8.4 the image brings.
How do customers with no internet activate?
By exchanging a file. A machine that never reaches the server activates and renews with a request file and a license file, and verifies the lease offline. See offline license verification.
Sources
What a self-hosted Carcha Seal server does is taken from its server code and documentation, checked on 11 November 2026. The key lifecycle follows published standards.