Keysat — Bitcoin-native self-hosted licensing service for software creators

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.

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

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

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.

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.)
02
Connect BTCPay
One click in the StartOS Actions tab. Authorize once on BTCPay's consent page; Keysat registers a webhook automatically.
03
Define products + policies
Declare a product, set its price in sats, define a policy (duration, seat cap, trial, entitlements).
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.
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)

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:

Download keysat_x86_64.s9pk from GitHub releases.
StartOS dashboard → Sideload → drag the file in.
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.

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

Sample Product