Payment is not access.
Authorize before compute.
Licenzy is the runtime between commercial state and AI execution. It confirms entitlements, checks credits, and authorizes every call before compute is spent — then records the evidence to keep commercial state and execution aligned.
A successful payment is not the same as valid application access.
Between the moment a customer pays and the moment your model runs, commercial state and application state fall out of sync. That gap is where revenue leaks and margin quietly deteriorates.
“Stripe says the payment succeeded. Is access actually synchronized?”
A confirmed charge is not a valid entitlement. State drifts silently between systems.
“How much compute am I giving away on retries?”
Failed and duplicated executions burn margin without producing billable outcomes.
“Why do two customers on the same plan produce opposite margins?”
Usage is consumed without attribution, so profitability becomes a guess.
One controlled path from payment to compute.
Every AI execution passes through the same runtime pipeline. State is confirmed, access is authorized before any compute is spent, and the outcome becomes evidence you can reconcile.
- Commercial statepayment confirmed
- Entitlementssynchronized
- Creditsbalance available
- Authorizationapprove / deny
- ExecutionAI runs
- Usageconsumed safely
- Audit & ledgerrecorded
A single system for commercially correct execution.
Not a billing tool bolted onto your app. A coherent set of runtime modules that share one state model, one ledger and one authorization boundary.
Runtime authorization
Approve or deny every request before compute begins, based on live entitlement and balance state.
Entitlements
Translate confirmed commercial state into reliable, revocable application access.
Credits & balances
Prepaid and included usage tracked atomically, so limits are enforced without race conditions.
Usage consumption
Meter execution against the right subject, product and mode with exact attribution.
Retry-safe charging
Idempotent consumption ensures retries never double-charge or leak free compute.
Payment synchronization
Verified Stripe events reconcile commercial state into Runtime entitlements, so access follows the resulting Runtime decision.
Audit & ledger
Every authorization and consumption event is recorded as reconcilable, traceable evidence.
Reconciliation
Close the loop between commercial truth and runtime truth, continuously and provably.
Show it. Don’t claim it.
Reliability isn’t a marketing word — it’s a record. Every authorization, consumption and synchronization event is written to an append-only ledger you can inspect, reconcile and trust.
- access.checkcus_9f2c41—granted
- usage.consumecus_9f2c411 unitrecorded
- usage.consumecus_51ba0eretrydeduped
- access.checkcus_77de12—denied
- entitlement.synccus_51ba0e+2,000synced
Economic intelligence is what we're building toward.
ProfitLens is Licenzy's future economic-intelligence direction, built on the Runtime evidence foundation. This preview shows what we're building toward, not a current production capability.
- Foundation
- Operational Runtime evidence from Health and events
- Direction
- Interpret patterns across monetized execution
- Outcome
- Explore future economic intelligence for operators
- Status
- In development — not a current production capability
Two calls stand between payment and compute.
Check access before you run the model. Consume usage after. Everything else — entitlements, credits, synchronization, audit — is handled by the runtime.
- Authorize before compute is spent
- Idempotent consumption, safe on retries
- Test and live modes, cleanly separated
// Keep the Runtime API key on your server.
const headers = {
Authorization: "Bearer " + process.env.LICENZY_API_KEY,
"Content-Type": "application/json",
};
// Authorize before compute — mode comes from the API key.
const accessResponse = await fetch(
"https://api.licenzy.app/v1/access/check",
{
method: "POST",
headers,
body: JSON.stringify({ subject_ref: "customer_123" }),
},
);
const access = await accessResponse.json();
if (!access.allowed) return deny(); // no compute spent
const result = await runModel(input);
// Consume customer entitlement usage with a stable retry key.
await fetch("https://api.licenzy.app/v1/usage/consume", {
method: "POST",
headers: { ...headers, "Idempotency-Key": requestId },
body: JSON.stringify({ subject_ref: "customer_123", units: 1 }),
});Commercially correct AI execution
starts before the model runs.
Put a runtime between payment and compute. Authorize with confidence, meter safely, and keep every execution aligned with commercial state.