SOFTWARE LICENSING, CONNECTED

Any source.
Any runtime.
One truth.

Connect the commercial stack you already use to the rights your software enforces. From the first sale to the next renewal. Online or off.

Request private beta access See how it works

Private beta · Desktop, CLI, plugins & on-prem

FROM COMMERCIAL RIGHTS TO SOFTWARE

01 / COMMERCIAL RIGHTOne agreement. Rights defined.

llicenoSOFTWARE LICENSE

Made for your
next big thing.

PRODUCTStudio / Pro

LICENSE TYPESigned · Ed25519

YOUR SOFTWARE. YOUR RULES.

License verified.Inside your app. Even offline.

LOCAL

ILLUSTRATIVE FLOW · DEMONSTRATION DATA

A natural fit for
the way you ship.

Desktop apps

CLI & agents

Plugins & on-prem

01 / LESS GLUE CODE. MORE PRODUCT.

Many ways to sell.
One model of access.

An entitlement defines what a customer may use. Liceno is being built to keep those rights consistent across commercial systems and software runtimes.

Connect anything.

Map subscriptions, purchases and contracts into one software entitlement model. Keep provider-specific rules out of your application.

COMMERCE-NEUTRAL RIGHTS

Prove anywhere.

Turn the same rights into signed credentials and runtime checks. Define access for connected, intermittent and offline environments.

ONE MODEL, PORTABLE PROOF

Stay correct.

Reconcile renewals, refunds and plan changes against commercial state. Account for duplicate events, retries and credentials already in circulation.

LIFECYCLE, RECONCILED

02 / PORTABLE PROOF, MADE TANGIBLE

Go offline.
Stay licensed.

A signed license carries a snapshot of software rights. Your app can check its signature locally. Generate a sample, alter its payload, then verify it again.

01 Signature checked locally

02 No production data involved

03 No account needed to explore

Interactive concept using browser Ed25519.
This sample does not call the Liceno SDK or a payment provider.

studio.app / license playgroundLOCAL DEMO

Your next great app.

Let's unlock what it can do.

PRO

SIGNED DEMO LICENSENot generated yet

A temporary key pair is created in this browser. Sample data only.

High-resolution exportsThe feature your customer paid for.

Locked

Generate a sample to try local verification.

PUBLIC KEY VERIFICATIONEd25519 ↗

03 / CONNECTED FROM SALE TO SOFTWARE

Your whole ecosystem.
One thread of rights.

Connect an upgrade to paid features,
a team contract to seats, and a renewal
to continued access.

ONE UPGRADE. FIVE CLEAR HANDOFFS.

A customer buys Pro.
Here’s who does what.

Illustrative beta workflow

CUSTOMER

Your customer

Chooses & buys

The person using your software.

COMMERCE

Your checkout

Handles the sale

Billing, contracts or a marketplace.

RIGHTS

liceno.

Keeps rights in sync

Your plans become software access.

RUNTIME

Your software

Checks & unlocks

Desktop, CLI, plugin or on-prem.

Customer → Checkout
Upgrade to Pro
Your checkout handles payment and the commercial agreement.
Checkout → Liceno
Confirm the purchase
Liceno applies your policy: Pro features, device allowance and license lifetime.
Software → Liceno
Request current rights
When connected, your software retrieves or refreshes the customer’s license.
Liceno → Software
Deliver a signed license
Portable proof of the features, limits and expiry your policy allows.
Software → Customer
Make Pro available
Your software verifies the license and unlocks the paid features.

One purchase. The right access. Your checkout owns the sale. Liceno maintains the rights. Your software enforces them.

And when the connection drops? Your software can verify a signed license locally until its expiry. Renewals and refunds reach offline software through refresh or expiry.

Where does your stack fit?

Commercial sources

Stripe, Paddle and Lemon Squeezy are initial connection priorities. Lago, internal contracts and cloud marketplaces are exploration paths: Azure first, AWS later.

Software runtimes

Desktop apps, plugins, CLIs, agents, on-prem products and appliances. We’ll scope the licensing and offline requirements around your evaluation.

The surrounding tools

Exploring rights context for GrowthBook and LaunchDarkly, plus events for CRM and analytics. These tools keep their own rollout and relationship roles.

What that means for your customers.

Three example policies you could define for your own software.

01 / AFTER A PURCHASE

Unlock the paid features.

A customer upgrades a desktop editor to Pro.

You define: Pro includes high-resolution exports and batch processing.
Your app applies: The new features become available when it receives the updated rights.

02 / ON A NEW DEVICE

Allow two devices. Manage the third.

A customer installs your plugin on another computer.

You define: Two active devices per license, with a deactivation and transfer policy.
Your app applies: Check the allowance before activating another device; guide the customer to free a slot.

03 / WHEN THE NETWORK DROPS

Keep working, with a clear limit.

A customer takes your field tool offline.

You define: A signed license valid for seven days between refreshes.
Your app applies: Check access locally until expiry. Renewals and refunds take effect through refresh or expiry.

Illustrative customer policies. Device counts and durations are examples for your product, not Liceno plan limits. Bring your shared-seat, usage or maintenance requirements to a private beta conversation.

Private beta · An illustrative licensing workflow, not a promise of a ready-made connector. We’ll scope the integrations and runtime support around your evaluation.

A plan changes. The rights follow. Reconcile the new commercial state, update the entitlement and apply it in the software according to its connection and refresh policy.

Let’s connect your stack

04 / CONTROL IS A FEATURE

Your product.
Your customers.
Your choice.

Keep commercial changes from becoming rewrites of your application. Define the features, limits and license lifetime your customer receives, then decide how your software enforces them.

Provider-independent software rights

Features, seats, devices & usage policies

Explicit offline lifetimes & refresh rules

Explore the product principles

THE PRODUCT DIRECTION

Control, made concrete.

Separate rights from providers. One canonical entitlement model, with signed credentials as portable projections of those rights.

Keep lifecycle changes consistent. Reconcile authoritative commercial state across upgrades, renewals, refunds and event retries.

Know the offline trade-offs. Local public-key verification, bounded token lifetimes and an explicit refresh policy.

The application source is private today. A Fair Source server and permissive client libraries are the intended publication direction, subject to final review. These principles describe the product direction, not a promise of current availability.

05 / YOUR PRIVATE BETA EVALUATION

Let’s get your licensing
working together.

Private beta for teams building software beyond their own cloud.
Bring your stack, your runtime and the customer journey you want to simplify.

FOR INSTALLED SOFTWARE

Your next release.

Desktop apps, CLIs and plugins.
Licensing that fits how you ship.

Connect your stackTell us where commercial rights begin

Map products and plans to software features
Define device, seat and usage policies
Plan for intermittent and offline operation

Discuss your product

FOR B2B SOFTWARE VENDORS

Your next customer.

On-prem, agents and appliances.
Rights beyond your own SaaS.

Map the hard partsExplore your deployment requirements

Connect contracts to enforceable rights
Work through renewals and lifecycle changes
Discuss marketplace and air-gap requirements

Discuss your use case

Request private beta access. We’ll work with you to scope an evaluation around your software, integrations and deployment needs.

Tell us about your product through the private beta form.

A FEW GOOD QUESTIONS

The details
that matter.

Clear answers.
Thoughtful trade-offs.

What does private beta mean?

It’s an opportunity to evaluate Liceno around your own software and help shape the workflows that matter to your team. We’ll define a focused use case together, from the commercial agreement to the access your customer needs in the application.

Who is the private beta for?

Independent software vendors building desktop apps, CLIs, plugins, on-prem products, agents or appliances. It’s especially relevant when you sell through several channels, need offline access or spend too much time keeping software rights aligned with renewals and plan changes.

What does Liceno actually do?

Liceno is a software licensing platform in private beta for independent software vendors. It is designed to turn commercial rights from billing systems, contracts and marketplaces into one software entitlement model, then enforce those rights where the software runs. A signed license is one portable proof of those rights. The private beta starts with your product and the licensing workflow you want to improve.

Can licenses really be verified offline?

Yes. An application with a trusted public key can check a signed license locally. Expiry and offline policy still apply; signature verification alone does not check current commercial state. The playground demonstrates local verification with a temporary browser-generated key pair, not the Liceno SDK.

What happens after a refund or a plan change?

The intended model reconciles authoritative commercial state into updated software rights, including when events are duplicated or arrive out of order. A completely offline application cannot learn about a refund immediately. Credential lifetime, refresh rules and reconnection determine when updated rights reach it.

Does Liceno replace billing or marketplace tools?

Your billing provider or merchant of record keeps its payment, invoicing and tax responsibilities. Marketplace tools keep managing listings and offers. Liceno focuses on the last mile from commercial agreements to enforceable software rights. Marketplace integration paths are currently being explored.

Is Liceno open source or available to self-host?

The application source is currently private. The planned direction is a Fair Source server and permissively licensed client libraries, subject to final licensing and package review. Public source, self-hosting availability and deployment terms are not yet announced. Tell us about your deployment needs when requesting beta access.

How can I join the private beta?

Tell us about your product, where you sell it and where your customers run it. We’ll discuss the licensing workflow you want to improve and scope a beta evaluation together, including integration needs and commercial terms. We’ll also share documentation relevant to your project, with no automatic newsletter. Request private beta access ↗

MAKE ROOM FOR WHAT YOU DO BEST

Your next release
is waiting.

Bring your product to the private beta. Let’s shape your licensing workflow together.

Request private beta access

Any source.Any runtime.One truth.

Many ways to sell.One model of access.