What LibertyNet is

The whole model in one page, in plain language, in the order the pieces make sense.

LibertyNet is a network of independently operated computers that can find each other and prove who they are, without a company in the middle deciding who is allowed to participate.

That is the whole idea. Everything below is detail.

#The problem it is built around

Normally, when two machines on the internet want to trust each other, they ask a third party. A certificate authority vouches for a domain. An API gateway checks a key it issued. A platform decides who gets an account.

That works, and it also means the third party can decide it does not like you. It is a single point of permission — and, when it is compromised, a single point of forgery.

LibertyNet removes that middle party from the identity question by making identities self-certifying.

#Idea 1 — an identity is derived from its key

A LibertyNet identity looks like this:

did:svrp:n:268d4fe0

That is not an account number issued to someone. It is a fingerprint of a public key — the first four bytes of SHA-256(public_key), in hex.

Which means: given a public key and a claimed identity, anyone can check the pairing themselves, offline, with nothing but a hash function.

sha256(publicKey).slice(0, 8) === "268d4fe0"   // → the claim holds

No lookup. No authority. No network call. You did the whole verification locally.

#The rule that follows from it

#Idea 2 — nodes announce themselves; nobody approves them

A node tells the registry it exists: here is my identity, my address, and what I can do.

{
  "did": "did:svrp:df9d4b9f...02d",
  "public_key": "df9d4b9f...02d",
  "endpoint": "172.20.10.5:55785",
  "capabilities": ["inference", "health:ready"],
  "region": "asia-southeast",
  "last_seen": "2026-07-31T16:33:08Z"
}

The registry is a directory, not a gatekeeper. It does not decide who may join. Reading it requires no key and no account — which is why the quickstart has no signup step.

Since anyone can register, you should assume some records are wrong or hostile. That is fine, and it is exactly what idea 1 is for: you verify every record yourself, and a forged one fails arithmetic rather than policy.

#Idea 3 — a node can be adopted by an operator, with limits

A node is a machine. An operator is whoever is responsible for it.

Binding the two is a four-signature handshake, and the interesting part is that both sides must consent — the operator cannot claim a node, and a node cannot attach itself to an operator who did not agree.

1. The node asks

   It signs a description of itself and what permissions it wants, and gets back a short human-readable code.

2. The operator sees the request

   They redeem the code and see the node's details, including a fingerprint of its key to compare against the node's own screen. That out-of-band comparison is what stops you from adopting a node you do not control.

3. The operator authorizes

   Their device key signs an authorization naming the node and its limits. The authorization can never be broader than what the node asked for.

4. The node accepts

   All four signatures are re-verified atomically before anything becomes active.

The reason for a separate device key: your root key signs one credential, offline, and then goes back in the safe. Everything day-to-day is done by a device key. A stolen laptop costs you a device, not your identity.

Full walkthrough →

#Idea 4 — contribution is measured, not yet paid

What Credits are and are not →

#What LibertyNet deliberately is not

There is no endpoint in this API that moves value. No wallet, no swap, no staking, no token transfer, no trading. That is a scope decision, and this documentation will not imply otherwise. See capability status for the full, current list of what exists.

#The shape of every LibertyNet program

1. Discover

   Ask the registry who is out there. Public, one GET, no auth.

2. Verify

   Check identities yourself before trusting anything. Non-optional in the SDKs.

3. Act

   Talk to a node, or bind one to an operator so it can work under limits you set.

#Where to go next