Build legally-grounded apps. Ship without the legal queue.
One API call tells you whether your use of licensed IP is allowed, warns you when you are close to a limit, routes edge cases to the rights holder for review, and blocks what is genuinely off-limits. Free to start. Scale with your success.
From browsing to shipped in one afternoon
No licensing lawyer. No enterprise negotiation. No months-long wait. The loop that used to take a legal team now takes a single developer session.
Browse licensable IP
Search the catalog by category, use case, or rights holder. Each property shows its tier structure upfront — fan-noncommercial, hobby-commercial, studio — so you know before you apply whether your project fits.
Apply in minutes
Fill out a short application: describe your app, expected audience size, revenue range, and distribution channels. Most fan and educational applications get an auto-decision in under 60 seconds.
Receive a scoped token
Your approved grant issues a license token scoped to the specific IP property, use cases, and limits you applied for. The token is shown once — store it in your environment as LICENSE_OS_TOKEN.
Call one API
Call POST /api/v1/license/check before each generation. The deterministic engine checks your hard limits in milliseconds; an AI classifier runs brand-safety on top. You get back a clear four-state decision.
Run postflight on output
Pass the generated asset back through postflight — the API logs the output hash against your audit record, issues a LicenseOS-signed provenance record (C2PA-aligned), and confirms the output stays inside the allowed scope.
Ship with attribution + limits
Embed the requiredAttribution string in your UI. Monitor your monthly quota. If the rights holder updates their policy or revokes your grant, the next check call tells you immediately.
Ten lines. One clear answer.
The SDK wraps preflight and postflight in a single import. The deterministic engine checks hard limits first — expiry, commercial thresholds, distribution channel allow/deny lists — in milliseconds, with no LLM involved. An AI classifier then evaluates brand-safety on top. Anything ambiguous or high-risk escalates to human review; it never silently passes.
Response shape
// Decision returned by /api/v1/license/check
{
"ok": true,
"approved": true,
"decision": "allow", // allow | warn | require_review | block
"riskScore": 8, // 0-100
"requiredAttribution": "Moonberry Grove characters © Ember Arts. Used under license.",
"usageLimits": { "monthlyGenerations": 500, "maxMonthlyRevenueCents": null },
"licenseTier": "fan-noncommercial",
"flags": [],
"requiredChanges": [],
"humanReviewRequired": false,
"policyVersion": 3,
"auditId": "clx8f2z0k000108l7g3hn2p4q",
"receipt": { "v": "1", "ipProperty": "moonberry-grove", "decision": "allow" },
"receiptSignature": "losr1:..." // signed, verifiable at /verify
}import { LicenseOS } from "@licenseos/sdk";
const client = new LicenseOS({ apiKey: process.env.LICENSE_OS_API_KEY });
// PREFLIGHT — before you call your image/video provider.
// Your free starter grant is non-commercial — so this is the call that clears on copy-paste.
const pre = await client.checkLicense({
ipPropertyId: "moonberry-grove",
useCase: "noncommercial_fan",
prompt: "Momo the Moon Fox baking cookies in a cozy kitchen",
outputType: "image",
distributionChannel: "web",
commercialIntent: false,
});
if (pre.decision === "block") {
throw new Error(pre.rationale);
}
if (pre.decision === "require_review") {
// pause — the rights holder will respond from their review queue
return;
}
// approved — generate the image
const image = await openai.images.generate({ prompt });
// POSTFLIGHT — review the actual output (the method is reviewOutput)
const post = await client.reviewOutput({
ipPropertyId: "moonberry-grove",
outputType: "image",
promptUsed: prompt,
imageDescription: "Momo baking cookies in a cozy kitchen",
});
// pre.receiptSignature / post.receiptSignature → signed proof you cleared it (verify at /verify)
// pre.requiredAttribution → embed in your UIPreflight and postflight — why both
A single preflight call tells you whether to proceed. The postflight call closes the loop — it logs the actual output against the audit record and catches drift between the approved prompt and the generated result. Together they create the enforceable compliance artifact.
| Phase | When | What it checks | Why it matters | Output |
|---|---|---|---|---|
| Preflight | Before calling your provider | Validates the prompt and intent against the license policy | Prevents wasted generation spend on uses that will be blocked. Gives you a decision_id to correlate with the output. | ALLOW / WARN / REQUIRE_REVIEW / BLOCK |
| Postflight | After receiving the generated asset | Logs the output hash, issues a LicenseOS-signed provenance record (C2PA-aligned), and confirms the result matches the allowed scope | Creates the enforceable audit record. Catches cases where the output drifted outside the approved scope (character likeness, brand elements). | Recorded in audit log — flags raised if out-of-scope |
How it fits into your generation pipeline
Always know your status
Every decision, quota update, and policy change is surfaced in your developer dashboard and via webhook — so you are never caught by a limit your app did not see coming.
Live quota
Monthly generation count vs. your tier limit, with a reset date — so you can warn users before they hit the wall.
Attribution string
The exact credit line the rights holder requires, versioned with the policy. Embed it in every output surface.
Flags and violations
Any output flagged by the AI classifier or postflight check appears in your dashboard and in the audit trail.
Royalty accrual
If your tier carries a revenue share, usage events accrue in the royalty log automatically — no self-reporting.
Webhooks for real-time policy changes
Subscribe to license.revoked, policy.updated, usage.flagged, and application.decided events. Payloads are HMAC-signed so you can verify authenticity before acting. If a rights holder revokes your grant, the webhook fires and the next checkLicense call returns BLOCK immediately — no polling required.
Built for every scale of creator
The same API works whether you are building a game-jam prototype, a fan art generator, or a low-volume commercial product. Pricing follows your success.
Fan sites, personal generators, tribute apps. Free tier covers most uses — just embed the attribution string.
0 revenue required
Classroom tools, learning apps, student projects. Non-commercial educational uses auto-approve on most properties.
Auto-approve on most IP
Game jams, mods, hobby games. Apply for the indie-game channel and ship with provenance built in.
Indie-game channel
Print-on-demand, Etsy, Shopify. Each SKU is checked against the merch tier before you list, with a signed receipt as evidence the use was cleared.
Per-SKU compliance check
Demo for investors or a hackathon submission. Use the test-mode API key — decisions are real but royalties are waived.
Test-mode API key
AI image, video, or chat apps that use licensed characters or worlds. The audit log is your compliance artifact for app stores and brand partners.
Signed provenance included
UGC platforms that want to offer licensed creation. Call the API per generation; the audit trail covers you if a user abuses the IP.
Per-generation audit
Apps making under a defined revenue threshold. Revenue-indexed pricing means you pay a fair rate for your actual scale.
Revenue-indexed tier
Non-commercial, attribution required. Up to 500 generations per month on the fan tier. No credit card.
- Full preflight + postflight API
- Audit log included
- Attribution string auto-generated
- Webhook events
Low-volume commercial uses. Micro-fees per asset or a flat monthly subscription depending on the rights holder tier.
- Everything in free
- Commercial distribution channel
- Revenue-indexed pricing
- Royalty accrual log
No minimum guarantee. Revenue share replaces upfront advances. Scales with your product, not against it.
- Everything in hobby
- No minimum guarantee
- Auto-settled royalties via Stripe
- Human review SLA
Deterministic hard-rule engine
Commercial limits, expiry, and channel restrictions are enforced by a pure TypeScript policy engine — no LLM, no ambiguity. The AI classifier runs only on top of a hard-rule pass, and can only narrow, never loosen, the result.
Immutable audit trail
Every decision, output hash, and policy version is appended to a hash-chained audit log. Tampering with any past row breaks every subsequent hash. Show the audit ID to an app store, a rights holder, or your own legal counsel.
Instant revocation propagation
If a rights holder revokes your grant, the token is invalidated within seconds. The next checkLicense call returns BLOCK. No stale caches. No silent failures. Both parties see it in the shared audit log.
Build the app you could not license before.
Free to start. No enterprise negotiation. No minimum guarantee. Get an API key, run a preflight call, and ship with a real compliance record.
Demo uses fictional Moonberry Grove IP. Real catalog requires rights-holder participation.