Accept bitcoin without anyone holding your money.
Nemequene only ever knows your extended public key. Payments go straight from your customer to your own wallet — we are never in the middle, and we could not take custody even if we wanted to.
Non-custodial by construction
We store nothing but your watch-only public key. No private key capable of spending your funds exists anywhere in this system. That is not a policy we promise to follow — it is the limit of what the software can do.
Every response carries its proof
Each reply closes with the chained hash of the record at that moment. The response is the receipt, and you can verify it again months later without asking us for anything.
A record you can audit
Events are written to an append-only log chained with SHA-256. You can prove your history is complete and has no gaps, so a missing event is something you can demonstrate rather than discover while reconciling.
How it works
- Share your extended public key — or don't. The key is read-only: it lets us derive addresses that belong to your wallet, and nothing more. If you would rather not hand over a key that maps your whole shop, derive the addresses yourself and upload a batch instead. Every address you upload is checksum-verified before it is ever handed to a payer.
- Ask for an invoice. You get a fresh address every time, derived under the BIP-84 standard and never reused across customers.
- We watch the chain. When the payment confirms, the invoice is marked paid and the event is appended to your verifiable record.
- Retries are safe. Repeat a request with the same reference and you get back the same invoice and the same address, so a customer is never charged twice and no address is wasted.
Proofs you can hand to someone else
They exist because “trust our dashboard” is not evidence.
Timestamping
Seal any SHA-256 digest — a contract, a dataset, a model, a build — into the same ordered tree as your payments, and get back a dossier a third party can verify without ever contacting us.
Precedence certificates
Prove that one sealed document existed strictly before another. Not “the timestamps differ” — a consistency proof that the first was already sealed in a tree where the second did not yet exist.
Continuous log attestation
Deposit your own log's Merkle root on a schedule. Your compliance record becomes fork-evident even against your own administrators, and every consecutive pair of roots is certifiable.
Replay
Our state is a deterministic fold of your event log. Re-run it yourself and you get byte-identical results — which is why a reconciliation with us cannot end in a dispute about what happened.
Questions people actually ask
Can you ever touch my money?
No, and not as a policy — as an absence. We hold no private key of yours, so there is nothing to seize, leak or misuse. Payments go from your customer straight to an address your wallet controls. We watch and we keep records; we cannot spend.
What happens to me if you disappear?
You keep collecting. The addresses are derived from your own key (or uploaded by you), so your wallet already controls every payment that has ever been made to you. What you would lose is our bookkeeping — which is why the event log is exportable and independently verifiable rather than locked in our database.
Why should I believe your numbers?
You shouldn't have to. Every successful response carries a cryptographic proof against an append-only log, so you can verify inclusion, ordering and completeness yourself. If we ever dropped or altered an event, that is demonstrable — not a matter of our word against yours.
Do you support Lightning?
No, and we do not intend to. Running Lightning means holding funds in channels on your behalf, and that is custody by another name. We would rather be honestly on-chain than quietly custodial.
How do refunds work?
You send them from your own wallet, because you are the one holding the funds. We are not in the middle, which means we can neither delay your refund nor claw back a payment you already received.
Built from the ground up
The language, compiler, web server, TLS stack, datastore and certificate client behind Nemequene were all written from scratch, with no third-party dependencies — and this page itself is woven by our own web framework.