# Keysat — Bitcoin-native self-hosted licensing service for software creators
Keysat is a Bitcoin-native, self-hosted licensing service for software creators. Runs on Start9. Pays in Bitcoin or fiat. Verifies offline. You own the signing key, the customer list, and the payment rails.

Software licensing for independent creators

# Bitcoin-native self-hosted licensing service for software creators.

Buyers pay in Bitcoin via your own BTCPay. Your software verifies signed keys offline. You own the signing key, the customer list, and the payment rails — no SaaS, no middleman, no platform risk.

Keysat empowers independent software creators to monetize any software they choose to sell — fully open source, free/paid versions, or fully closed source. The licensing layer is agnostic to your decision.

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. BTCPay handles payments. Your hardware holds the keys. 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 — wire-compatible offline verifiers. Five lines of code in your app and you're verifying real signatures.

Real creators, real software

## Built by experts in their craft, not coders.

Empowering the next generation of software creators. The people who actually know the work — accountants, trainers, teachers, builders — can finally ship the tool they’ve always wanted, because AI handed them the keyboard. 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.”

42active licenses
$99/yrper seat
8 mo.since launch
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.”

87active coaches
20k sats/moper seat
14 mo.since launch
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 200 other families use it too.”

208families
$48/yrper family
11 mo.since launch
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. BTCPay comes bundled as a dependency. (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 in Bitcoin, get a signed license. Their copy of your software boots up licensed.

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

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 a Custom GPT, OpenAI Assistant, LangChain, or Claude Code — 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.

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` from GitHub releases.
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 about subscriptions?

v0.1 issues fixed-duration licenses (e.g. 1 year) with offline expiry. True recurring billing — auto-renew without buyer interaction — lands in v0.3 alongside license-tier upgrades, volume packs, and Zaprite card payments.