Software licensing for independent creators

# Self-hosted licensing for software creators.

Keysat is a self-hosted licensing server. Buyers pay you for the software you create, and their license can be verified offline. Your licensing key, customer list, and payment rails all live on your hardware — no SaaS, no middleman, no platform risk.

Install Keysat → See how it works
Runs on Start9 Pays via BTCPay Verifies offline
₿
— Certificate of License —

#### Sample Product

Issued under default policy · single seat · 1 year
License key
KS-9F2A-7C41-XK22-6D8E
Issued
2026-04-22
Expires
2027-04-22
Ed25519 · mz7q8r4t1v…h3k2pXq9wL · ✓ verified offline
What this enables

## A complete sell-your-software stack, sovereign end-to-end.

Keysat is the licensing layer. Your hardware holds the keys and controls payment rails. No third party can mint, revoke, or read your sales records.

### Bitcoin payments, your store

BTCPay Server on your own Start9 takes the payment. Lightning settles in seconds. Funds land in your wallet — no intermediary holds them.

### You own the signing key

The Ed25519 keypair lives on your hardware. Every license is signed by it. There's no third party who could mint or revoke licenses.

### Offline verification

Your software verifies licenses against an embedded public key. No network call. Customer apps work even if your Keysat goes offline.

### Sell however you want

One-time purchases for the whole app. Free / paid splits. Trials. Recurring renewals. Time-limited licenses, multi-seat licenses, comp keys for press. The licensing layer is a primitive — you decide the business model.

### Discount & comp codes

Percent-off, fixed-sats-off, or free-license codes (no payment required). Run launch promos, comp keys for press, track partner campaigns.

### SDKs in your language

Rust, TypeScript, Python, Go — wire-compatible offline verifiers. Five lines of code in your app and you're verifying real signatures.

Real creators can now build real software

## Empowering the next generation of software creators.

AI software tools now allow specialists to finally ship the tools they’ve always wanted for themselves, without needing any coding background. Keysat is the licensing layer that lets them get paid for what they made.

Photo placeholder
Save a photoreal portrait at:
assets/case-marisol.jpg
Solo CPA

### Marisol Vargas

12 years specializing in small-business tax. Built her own software because the existing tools didn’t fit her workflow.

SchedulCalc

Schedule C + 1099 reconciler for solo accountants. Replaces a $1,200/yr software stack with one focused tool.

> “I worked with bloated tax software for twelve years. With AI I built one that fits how I actually think — in three months, on weekends. Now Keysat lets me sell it to the other solo CPAs who were stuck with the same bad tools.”

Photo placeholder
Save a photoreal portrait at:
assets/case-tomas.jpg
Powerlifting coach

### Tomas Kovac

12 years in the gym. Built RPE-based programming software because off-the-shelf apps assume gym-membership-app generic.

BarbellTracker

RPE-based programming and autoregulation for one-on-one coaches. Built around how strength athletes actually train.

> “I knew exactly what coaches needed because I was the coach. AI handled the engineering — I handled the design. Now Keysat lets me sell it to the other coaches who recognize how it should actually work.”

Photo placeholder
Save a photoreal portrait at:
assets/case-hana.jpg
Homeschooling mom

### Hana Brennan

Three kids, three different curriculum tracks. Built her own week-planner because every existing tool assumed one student.

SeasonsOfLearning

Multi-grade week planner for homeschool families with kids on different tracks. Mixes curricula across ages.

> “I sketched the workflow on a notepad in October. By January my kids’ school days were running on it. Now Keysat lets me sell it to the other homeschool families who were trying to bend single-student tools to fit their week.”

Illustrative examples of the kinds of creators Keysat is built for. Real Keysat creators — come be one of them.
How it works

## Five steps, end to end.

From install to first sale in an afternoon. No cloud account to create, no API keys to copy.

1. 01

   ### Install on your Start9

   One click from `registry.keysat.xyz` in the StartOS marketplace. (Sideload the `.s9pk` directly if you prefer.)

2. 02

   ### Connect BTCPay

   One click in the StartOS Actions tab. Authorize once on BTCPay's consent page; Keysat registers a webhook automatically.

3. 03

   ### Define products + policies

   Declare a product, set its price in sats, define a policy (duration, seat cap, trial, entitlements).

4. 04

   ### Embed your public key

   Copy your Keysat public key into your app. Add the SDK. Five lines of code verifies a signature at startup.

5. 05

   ### Share your purchase URL

   Buyers hit your public URL, pay for your software, and get a signed license that can be verified offline.

For developers and AI agents

### Five lines, in the language you or your AI agents already write.

Keysat licenses are Ed25519-signed and Crockford base32-encoded. Verification is pure-function — no network, no daemon, no shared state. Hand the docs to your coding agent and tell it to wire licensing into your software; the integration is small enough to fit in one prompt.

- Wire-compatible across SDKs (TypeScript, Rust, Python, Go)
- Public key embedded at compile time
- Returns product, policy, expiry, entitlements
- Source-available — agents can read the verifier source directly

npm install @keysat/licensing-client

    import { Verifier, PublicKey } from '@keysat/licensing-client'

    const verifier = new Verifier(
      PublicKey.fromPem(ISSUER_PEM)
    )

    const ok = verifier.verify(licenseKeyFromUser)
    console.log('licensed:', ok.productId, ok.expires)

    // Cargo.toml
    // licensing-client = "0.1"

    use licensing_client::{Verifier, PublicKeyPem};

    let pk = PublicKeyPem::from_str(ISSUER_PEM)?;
    let verifier = Verifier::new(pk);
    let ok = verifier.verify(&license_key)?;
    println!("licensed: {}", ok.product_id);

    from keysat_licensing_client import Verifier, PublicKey

    verifier = Verifier(PublicKey.from_pem(ISSUER_PEM))
    ok = verifier.verify(license_key_from_user)

    print("licensed for", ok.product_id)

    import keysat "github.com/keysat-xyz/licensing-client-go"

    payload, err := keysat.ParseAndVerify(licenseKey, ISSUER_PEM)
    if err != nil { log.Fatal(err) }
    fmt.Printf("licensed for %s, expires %s\n",
      payload.ProductSlug, payload.ExpiresAt)

Agent-friendly

## Built so you can hand operations to an AI agent.

Keysat issues, monetizes, and manages licenses through a clean self-service admin UI. It also exposes every operator action through a documented HTTP API with bounded-scope credentials — so if you'd rather have an agent do the day-to-day work, you can give it the keys safely.

OpenAPI 3.1

### Discovery built in

`GET /v1/openapi.json` returns a curated, stable spec. Drop the URL into Claude (Code or Computer Use), an OpenAI Custom GPT, or Perplexity’s Comet agent browser — the agent learns the endpoints automatically.

Scoped API keys

### Least-privilege by design

Generate a key, pick a role (read-only, license-issuer, support, or full-admin), hand it to the agent. Revoke in 30 seconds without rotating your master credential. Operator-only actions stay behind the master key.

Stable error codes + webhooks

### React, don't poll

HMAC-signed event deliveries on every license / invoice / subscription state change. Every error response carries a stable machine-readable code (`tier_cap`, `not_found`, `license_revoked`) so agents branch deterministically.

Agent integration guide →
Sovereign by default

## Everything stays on your hardware.

Migrate Start9 boxes — Keysat goes with you. If the Keysat project disappears tomorrow, your already-issued licenses keep verifying: the public key is embedded in your software, the private key is on your machine.

### What you keep

On your Start9, in your normal backups.

- Signing keypair
- Customer email · npub list
- Sale records
- Audit log
- BTCPay invoice history
- Webhook subscribers
- Bitcoin (your wallet)

Backed up automatically by StartOS as part of your normal backup routine.

### Or accept fiat, on your terms

Coming soon: opt-in card payments via Zaprite.

If your customers prefer paying with credit cards over Bitcoin, you’ll be able to plug Zaprite into Keysat as an alternative payment provider. Same Keysat license-issuance flow, but the payment can come through Stripe-via-Zaprite for cards or any of Zaprite’s Bitcoin rails (BTCPay, Strike, Unchained). Trades off some sovereignty — cards mean Stripe KYC and customer PII flowing through Zaprite — in exchange for a much wider addressable audience.

Keysat stays sovereign-by-default. Card payments are something you opt into per Keysat install if your business needs them. Shipping in v0.3.

Source-available license · pay your operator-style trade-offs deliberately, never by default.

Pricing

## Three tiers. Free forever for solo creators.

Keysat’s gating happens at the operator’s self-license, not at the buyer’s. Every Keysat instance ships at Creator (free); pay only when you outgrow it.

Creator
Free forever

Solo creator selling one-time or perpetual licenses for a focused catalog.

- Up to 5 products
- Up to 5 tiers per product
- Up to 10 active discount codes
- BTCPay (Bitcoin / Lightning) payments
- All 4 SDKs · full wire format
- Webhooks, audit log, recovery, analytics opt-in

Pro
250k sats/ year

For creators monetizing seriously — multiple products, subscriptions, both Bitcoin and card buyers.

- Unlimited products, tiers, and codes
- Recurring subscriptions · trials, grace, auto-renew
- Zaprite payment gateway — cards, Apple Pay, bank transfers, plus Bitcoin
- In-place tier upgrades (proration handled)
- Everything in Creator

Patron
500k sats/ year

Honest supporter tier. Same features as Pro; you’re funding Keysat’s development.

- Everything in Pro
- “Patron” badge in your admin dashboard
- Listed on the Patrons page on keysat.xyz
- Early access to release-candidate builds
- Direct support line

No fake feature gates: Patron is feature-identical to Pro. Pricing is a flat annual fee — we don’t take a percentage of your sales.

Install

## From the marketplace, or sideload directly.

Either path leaves you in the same place: a running Keysat on your Start9, ready to connect BTCPay.

Recommended

### From the marketplace

Add the Keysat marketplace to your Start9, then click Install.

https://registry.keysat.xyz

StartOS dashboard → Marketplace → Add → paste the URL.

Then activate your license:

Buy a license →
Alternative

### Sideload

If you'd rather not add the marketplace:

1. Download `keysat_x86_64.s9pk`.
2. StartOS dashboard → Sideload → drag the file in.
3. Click Install.

Common questions

## What people ask.

### What happens if Keysat the project disappears?

Your software keeps working. The public key is embedded in your app at compile time, and offline verification doesn't depend on us. The wire format is documented; you can reimplement the verifier in any language in an afternoon.

### Can I do free or comped licenses?

Yes. Define a discount code with type `free_license` and the buyer redeems it at checkout without paying. Useful for press, beta testers, partners, and giveaways.

### What’s the difference between the three tiers?

Creator is free forever, capped at 5 products / 5 policies per product / 10 active discount codes — plenty for a solo creator selling one-time or perpetual licenses. Pro lifts every cap and unlocks recurring subscriptions plus the Zaprite payment gateway (cards, Apple Pay, bank transfers, in addition to Bitcoin). Patron is Pro with a public supporter badge; same features, you’re funding development. See the tier comparison above for the full breakdown.

### Do I have to use Bitcoin?

BTCPay (Bitcoin / Lightning) is the default and available on every tier. On Pro or Patron you can additionally connect Zaprite, which adds card / Apple Pay / bank transfer / more — with payments still landing in your wallet. Pick whichever your buyers prefer; you can switch the active provider at any time.