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.

### 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.

### Payment channels you control

BTCPay Server on your own server manages bitcoin and lightning payments. Funds land in your wallet without intermediaries.

### 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

10 years as a fitness coach. Built RPE-based programming software because off-the-shelf apps were gym-membership specific and lacking in functionality.

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 over a weekend. Two weeks later 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

   In the admin UI, open Settings → Payment providers → Connect BTCPay. 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 base32-encoded (RFC 4648, no padding). 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.payload.expiresAt)

    // Cargo.toml
    // keysat-licensing-client = "0.3"

    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/keysat-client-go"

    payload, err := keysat.ParseAndVerify(licenseKey, ISSUER_PEM)
    if err != nil { log.Fatal(err) }
    fmt.Printf("licensed for %x, expires %d\n",
      payload.ProductID, 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.

Example prompt

Install Keysat in one click on your Start9, or have your agent clone the repo and launch it. Then hand off the rest:

“Review the Keysat docs on GitHub and integrate Keysat licensing into my app. Require a Pro license for my paid features (CSV export, scheduled reports, and the public API), and connect it to my BTCPay Server.”
Agent integration guide →
Pricing

## Three tiers. Free forever for solo creators.

Every Keysat instance ships at a highly functional Creator tier; pay only when you outgrow it.

Creator
Freeforever

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
100k 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
250k sats/ year

Perpetual license + direct one-on-one support, for creators who want Keysat to keep getting better.

- Everything in Pro
- Perpetual license (one-time, never renews)
- Direct one-on-one support
- “Patron” badge in your admin dashboard
- Listed on the Patrons page on keysat.xyz
- Early access to release-candidate builds

Install

## One click on Start9, or run it from source.

Keysat is yours to self-host either way: run the packaged service on your Start9, or clone the repo and run the daemon on any Linux box you control.

Recommended

### Install on Start9

One click from the StartOS marketplace. StartOS manages the BTCPay dependency, networking, and backups for you.

https://registry.keysat.xyz

StartOS dashboard → Marketplace → Add → paste the URL. Or sideload `keysat.s9pk` from GitHub releases.

Want more than the Creator tier?

Buy a license →
From source

### Run it yourself

Prefer your own host, or want an agent to provision it? Clone and run the daemon on any Linux box or VPS:

1. `git clone` github.com/keysat-xyz/keysat.
2. Set `.env` (admin key + your BTCPay), then `cargo run --release`.

Runs free at the Creator tier (5 products, 5 policies each). Buy a license to lift the caps and add recurring billing.

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), billed annually. Patron is everything in Pro, sold as a one-time perpetual license instead of an annual subscription, plus direct one-on-one support and a public supporter badge. You’re funding development. See the tier cards 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.