Licensing your software
Optional licensing for paid software on Windows, macOS, Linux, and Android.
6ortal handles purchases and issues licenses. You add activation to your software, rebuild, and test it. You can also sell without licensing.
Setup
Open licensing setup.
Enable licensing in the upload form. Your draft is saved and setup opens separately. Choose your installation allowance and permanent or timed access. Keep using that draft, even if you rename your app.
Add activation to your software.
Copy integration instructions for your coding assistant, or use the developer reference below. Both follow the same checklist. The ZIP in your workspace includes the SDK, configuration, reference interface, example and tests. No sign-in sharing.
Node.js / Electron can use our client. Other stacks, including Android, need API integration. Configuration alone does not add activation.
Test, then submit.
Attach your candidate privately in Licensing setup. Test that exact file, clean up test activation, then submit it. Rebuild only if needed, then retest.
Approve your app's code in this draft's “Activate & test” section, not the buyer activation page. No purchase or public listing is required.
Activation screens
One action to begin, automatic unlock after verification. Settings and recovery stay separate. Use this reference with your own branding.
Display preview only. The ZIP includes these screens and a main-process example using the real SDK. Its tests do not replace testing your own software.
One purchase covers every platform on your listing, including platforms you add later. Buyers share one license and installation allowance across all of them.
Activation settings and limits
Device activation: buyers approve each installation through their account. Choose one to ten installations. One-time activation is the default for new listings; timed offline access of one to thirty days is optional. Existing listings retain their settings.
Key-only verification: the older integration checks a purchase key but does not enforce installation limits or issue offline certificates. It is an alternative to device activation, not an extra step buyers must complete.
Offline access: permanent activations have no recurring expiry and cannot be withdrawn remotely while offline. Timed activations can keep working until expiry or an earlier successful check. Refunds and revocations block new activations; releasing a device slot does not erase its offline access.
Licensing discourages sharing but cannot make an app impossible to modify or prevent copied installation credentials from being used. You retain ownership of your software and can publish without licensing.
Publishing checklist
- Locked, then unlocked: invalid activation cannot unlock paid features; valid activation can. Test the actual engine or background service, not just the screen.
- Still works tomorrow: close, reopen, and update the app. Activation should remain intact. Disconnect the internet and check the offline policy you chose.
- Limits and recovery: test the shared device allowance and an activation failure. Keep files safe and allow saving or export. Show the buyer how to recover.
- Copied data and storage: try another OS user/computer and unavailable protected storage. No silent unlock or plaintext fallback. Check each platform you ship.
- Ready to ship: each platform build has your saved production identifier and verified public keys. Remove test mode and bypasses. Production must reject practice certificates.
- Clear before purchase: explain activation and offline requirements in your listing. Link buyers to the activation guide.
Draft setup issues real certificates for your chosen policy, including permanent activation. Only the draft owner can approve them. The seven-day test authorization window is separate from certificate expiry. Never bundle testing credentials. Clean up local test activation after testing the packaged app; releasing a slot cannot erase a permanent offline certificate.
After certificate collection, confirm your app unlocked. The kit's TEST-CHECKLIST.md uses the same checks as setup, with developer details in ACCEPTANCE.md. Server observations, automated tests and your app results remain separate. Test the exact attached installer before submitting it; a pillar checks that build independently.
Requirements for every platform
> Integration requirements
Use the same production app identifier in every platform build, but a separate private key for each installation. Windows, macOS, Linux, and Android installations share the buyer's device allowance.
Store installation credentials with platform-appropriate protected storage. Electron needs an available secure storage backend; native desktop and Android apps need their own secure storage implementation. Never silently fall back to a plain-text private key.
> Device activation, v1
- Enable licensing for your paid app. Choose its device allowance and offline period in your publisher settings.
- Your software creates an Ed25519 key pair for that installation. Keep the private key in the operating system's protected storage.
- The app displays a short code. The buyer signs in at 6ortal.com/license/activate, checks the app and device, and approves it.
- The app receives a signed certificate. Verify its signature, app, installation, and access type before granting access. Check expiry only for timed certificates.
- For one-time activation, verify locally without a renewal timer. For timed access, the client refreshes automatically and uses the last valid certificate during a temporary outage.
The defaults are three installations and one-time activation. The policy value licenseOfflineDays = 0 means no recurring expiry; values 1 to 30 select timed offline access. Existing listings are not automatically converted. Device transfers are limited over a rolling seven days; buyers can ask support for a reset.
Buyers open Account > Apps & activity > Purchases, then the app's License & devices. A device released online may still hold a working offline certificate. Permanent certificates do not expire, and previously granted permanent activations remain permanent even after a policy change. Timed certificates keep their signed expiry until a successful refresh. Never describe remote release as erasing access from an offline machine.
Node.js / Electron: use the client
For Windows, macOS, and Linux apps with a Node.js runtime. The client handles signatures, activation, and offline access. In Electron, use the main process, not the renderer. This file is not an Android or browser client.
Download Node.js / Electron clientThis is an integration outline, not a complete runnable app. Implement yourSecureStore using protected storage and showActivationCode using your own interface. Wire access failures to a recovery screen. Never unlock the app unconditionally after an error.
import { SixortalLicense } from './6ortal-license.mjs'
const licensing = new SixortalLicense({
appSlug: 'your-app-slug',
trustedKeys: { 'key-id': 'PINNED_PUBLIC_KEY_PEM' },
storage: {
load: () => yourSecureStore.read(),
save: state => yourSecureStore.write(state),
},
})
// Show the code and official URL in your own activation UI.
await licensing.activate('My laptop', showActivationCode)
// Call at launch and before licensed operations.
// Permanent certificates are checked locally, with no renewal calls.
const entitlement = await licensing.access()
// Enable licensed functionality only after this succeeds.For a practice build, use environment: 'test' and the configuration from your practice project. The default is production. Use separate storage per app and environment. await licensing.access({ forceRefresh: true }) requests an explicit online check for revocation testing; a temporary outage can still use a valid cached certificate. Do not schedule forced checks for one-time activation. An explicit successful check can withdraw revoked access; ordinary permanent access makes no network request.
Pin the public signing keys when building your app. Get them from the signing-key endpoint through a trusted release process. Future keys can be published ahead of a signing-key rotation. Do not automatically trust whichever key an online response supplies. Never embed our private signing key or a pillar credential.
Implement the protected-storage adapter for each operating system you ship. The client does not choose or configure it for you.
Other desktop stacks / Android: use the API
For native Windows, macOS, or Linux apps, and Android apps. Use your stack's HTTPS and Ed25519 libraries to implement the protocol below. This includes C#, C++, Python, Rust, Swift, Kotlin, and Java; 6ortal does not currently provide clients for them.
The process is the same on every platform: create an installation key, request activation, show the buyer a code, then verify and securely store the signed certificate. Use the shared requirements above for storage and access checks.
Pin production public keys from the signing-key endpoint in your release. Never trust keys supplied by an unverified response or embed a private server key.
| POST /api/license/v1/ | JSON body |
|---|---|
| requests | appSlug, publicKey (Ed25519 SPKI PEM), deviceName, timestamp, nonce, signature |
| token | deviceCode, signature |
| refresh | activationId, timestamp (Unix seconds), nonce, signature |
| deactivate | activationId, timestamp, nonce, signature |
Sign the UTF-8 string 6ortal-license:v1:claim:DEVICE_CODE for token polling. For refresh or deactivation sign 6ortal-license:v1:ACTION:ACTIVATION_ID:TIMESTAMP:NONCE. Signatures use Ed25519 and base64url without padding. Nonces are 24 random bytes encoded as base64url; never reuse them. Timestamps must be within five minutes of server time.
For a new request, sign 6ortal-license:v1:request: followed by the compact JSON array [appSlug, trimmedDeviceName, timestamp, nonce], using JSON.stringify semantics: UTF-8, no extra whitespace or optional Unicode escaping. Use the nonce and timestamp rules above. Older unsigned clients remain compatible with stricter request limits; new integrations must sign.
Requests expire after ten minutes. The SDK securely retains an unexpired code across restarts. Keep one activation coordinator per installation. A replacement signed request cancels earlier unapproved requests, not approved activations. Never log or bundle pending requests. Poll no faster than the returned interval, initially five seconds. HTTP 202 means approval is pending. Respect HTTP 429 and Retry-After; HTTP 503 is a temporary service failure, not a revoked license.
Certificates contain keyId, payload, and signature. Decode the bounded base64url JSON only to select the certificate version, then verify its Ed25519 signature before trusting any claim. Timed v1 certificates use 6ortal-license:v1:PAYLOAD; permanent v2 certificates use 6ortal-license:v2:PAYLOAD. Enforce version, issuer, pinned keyId, appSlug, deviceKeyHash, and issuedAt. Version 1 requires a numeric expiry within thirty days of issue. Version 2 requires access: "permanent" and expiresAt: null, and is production-only. Do not treat a missing expiry as permanent. Request and proof endpoints remain v1. The device hash is SHA-256 of the canonical Ed25519 SPKI PEM, not a hardware identifier.
Test endpoints are under /api/license/test/v1/, use the project ID as appSlug, and sign certificates and device proofs with the distinct 6ortal-license:test:v1 prefix. Test claims include environment: "test". Never accept that prefix or environment in a production verifier. Test activation is approved only by the publisher who owns the project.
Existing key-only integrations
POST /api/license/verify
{ "key": "ABCD-EFGH-JKMN-PQRS", "appSlug": "your-app-slug" }
{ "valid": true }
{ "valid": false, "reason": "not_found" }
{ "valid": false, "reason": "revoked" }
{ "valid": false, "reason": "rate_limited" }
// HTTP 503:
{ "valid": false, "reason": "temporarily_unavailable" }This endpoint remains available for existing integrations. New licensed submissions and updates must use device activation so a pillar can check the submitted build. Key-only verification has no device cap or signed offline certificate; changing listing settings does not upgrade the software.
Handle errors and outages
Refunds, disputes, and administrative revocation stop new online access. Permanent copies have no recurring check or expiry, so they cannot learn about revocation while offline. Timed copies can keep working until expiry or an earlier successful check. A device or clock problem should lead to a useful recovery message, not deleted work. Preserve users' files and allow export even when licensed functionality is locked.
Plan for key rotation and for 6ortal being unavailable. Ship new trusted public keys before we begin signing with them. Keep trusted verification keys needed by issued permanent certificates in future app releases. A permanent activation continues locally during service outages, but new installations still need online approval. Never promise immediate offline revocation.
Integration help: . Include your app, the step, and the error, never passwords or private keys. For buyers, share the activation guide.
