BoreLine derives every invoice address from your own wallet key. You do not have to take that on faith. An open-source verifier you run yourself re-derives each address from your key and flags any that does not match, so a compromised server could never reroute your Bitcoin without you catching it first. You never have to run any of this to accept payments; it exists so you can verify us instead of trusting us, whenever you want.
A hosted processor tells your customer which address to pay. If that server were ever compromised, it could quietly swap in an attacker's address for an invoice and send your money elsewhere. Checking a handful of addresses by hand does not close this gap, because a dishonest server can serve correct addresses for the ones you check and substitute the rest. The only real defence is to check every address automatically, against a key the server does not control.
BIP84 derivation is deterministic: one public key plus one index gives exactly one address. The verifier pulls your invoice list from a read-only endpoint, re-derives m/0/index from your own ZPUB, and confirms each matches the address the server issued. Because your key comes from you and the code comes from the public repo, a compromised server cannot pass the check by handing over a matching fake. It never supplies the key the check runs against.
Pick whichever fits. A single self-contained HTML file you open in your browser, paste your zpub and a verification token, and press verify. Or a small command-line script you can run on a schedule that exits with an error and can page you the moment any address does not match. Neither needs your private key, neither can move funds, and your key never leaves your machine. Both live in the open-source verifiable-core repository.
Verifying the address proves funds can only land in your wallet. It does not, on its own, prove that a payment the processor reports as received actually arrived, since that signal is the server's word. So the verifier can also reconcile payments against the blockchain itself, using a source you choose: a public explorer, your own self-hosted explorer, or your own node's Electrum server. For every paid or pending invoice it checks what the address really received and compares it to what BoreLine reports, catching a "paid" the server claims with no on-chain funds. The money is always in your own wallet, so the worst a dishonest server could do is misreport, and this is how you catch it before fulfilling an order.
A verifier is only worth running if you can trust it, so both tools prove themselves without trusting BoreLine. A built-in self-test derives the published BIP84 specification vector, an anchor defined by the Bitcoin standard rather than by us, and checks it against the known addresses. And you can run the whole thing offline: if it still works with your network off, it cannot be sending anything anywhere. Correctness and confidentiality are both things you confirm for yourself.
| With BoreLine verification | Trust the processor | |
|---|---|---|
| Addresses checked | Every one, automatically | A few, by hand, if any |
| Key the check uses | Yours, never sent to us | Not applicable |
| A rerouted address | Flagged before you share it | Discovered after funds move |
| Trust required in us | None, verify it yourself | Full |
Non-custody you can check, not just claim. Register free, then verify every payout address against your own key.
Start free →