Identity is a keypair

No sign-up form. Ever.

Every app you’ve used starts the same way: pick a username, choose a password, confirm your email. Behind the scenes, a company writes you into its database. Your account lives there, and it exists only as long as they say so.

Nostr skips all of that. Your identity is not a row in someone’s database: it’s a keypair, two big numbers that belong together:

• a secret key (private key): 32 random bytes that only you know, and
• a public key (pubkey): computed from the secret key, and safe to show the world.

Think of a mailbox with a slot. The public key is the address painted on the front: you put it on business cards so people can find you. The secret key is the only key that opens the box, and here it does something even better: it lets you stamp letters with a seal nobody else can forge.

No server hands these out. You make them yourself, on your own device, in a fraction of a second. Let’s do that right now.

Press the button a few times. Every keypair is brand new: there are about 2²⁵⁶ possible secret keys, so the chance of two people ever rolling the same one is effectively zero. No registry is needed to keep keys unique: math does it for free.

Why can’t anyone work out my secret?

The public key is calculated from the secret key using an elliptic curve called secp256k1 (the same one Bitcoin uses). The useful property is that this calculation is a one-way street: going forward takes microseconds, going backward is hopeless.

Here’s a toy version you can actually see. Your secret is a number of hops; the public key is where you land on the clock. Try it, then try to work backwards.

On a 61-spot clock, guessing backwards takes a blink. On the real curve there are about 10⁷⁷ spots. Every computer on Earth guessing for the lifetime of the universe would not make a dent. That’s what lets you publish your public key everywhere and sleep soundly.

import { generateSecretKey, getPublicKey } from "nostr-tools/pure";

const sk = generateSecretKey(); // Uint8Array(32), from a CSPRNG
const pk = getPublicKey(sk); // 64 lowercase hex chars (x-only)
console.log(pk);

npub and nsec: same keys, friendlier spelling

Raw keys are written in hex: 64 characters of 0–9 and a–f. Computers love hex. Humans copy-pasting it into a chat… less so. Mix up one character and you’ve silently pointed at someone else (or no one).

So NIP-19 re-spells keys using bech32:

• your public key becomes an npub: npub1…
• your secret key becomes an nsec: nsec1…

The prefix tells you what you’re holding (so you notice when you’re about to paste a secret), the alphabet skips look-alike characters like 1, b, i and o, and the last six characters are a checksum: change any character and software will refuse it instead of quietly using the wrong key. Scroll back up to the forge and step through the encoding: the bytes are regrouped 5 bits at a time, and each 5-bit number picks one letter from a 32-letter alphabet.

{
  "kind": 1,
  "pubkey": "7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e",
  "content": "gm"
}

import * as nip19 from "nostr-tools/nip19";

const npub = nip19.npubEncode(pk); // "npub1…"
const nsec = nip19.nsecEncode(sk); // "nsec1…" (sk is a Uint8Array)
const { type, data } = nip19.decode(npub); // type === "npub", data === pk (hex)

Your key is your pen

Holding a secret key isn’t just about being someone: it’s about proving it. Every post you publish is a little JSON event carrying your public key and a signature, made with your secret key using the Schnorr scheme. Anyone (any relay, any app, any stranger) can check that signature with nothing but your public key. Nobody can fake it without your secret.

Try it with the key you forged above. Then change a single letter.

That’s why Nostr doesn’t need a trusted server: the proof travels with the message. We’ll take a signed event apart byte by byte in the next chapter.

import { finalizeEvent, verifyEvent } from "nostr-tools/pure";

const event = finalizeEvent(
  { kind: 1, created_at: Math.floor(Date.now() / 1000), tags: [], content: "gm" },
  sk,
); // adds pubkey, id and sig
verifyEvent(event); // true

Guard the nsec with your life (well, almost)

Here’s the flip side of “no company owns your account”: no company can rescue it either.

• Anyone who gets your nsec is you. They can post, follow and DM as you, forever, and you can’t change “your password”, because there isn’t one.
• If you lose your nsec with no backup, the identity is gone. That’s key loss, and it’s one of Nostr’s honest trade-offs (more in the last chapter).

Your npub, on the other hand, is meant to be shared: on your website, in your bio, on a T-shirt. Let’s practice telling the two apart.

Quick check