Signing & login

Back in chapter 2 you learned that your Nostr identity is a keypair. The public key is your name tag; the secret key (shown as an nsec) is the pen that writes your signature on every event.

So here’s the puzzle: you want to use ten different Nostr apps. Every one of them needs your signature on the notes you post. Do you hand your pen to all ten?

Please don’t. Think of your secret key like the master key to your house. You wouldn’t give a copy to every delivery driver. You’d rather have a doorman who opens the door for them, checks what they’re carrying, and never lets the key out of his pocket. On Nostr, that doorman is called a signer.

Login without passwords

There are no accounts on Nostr, so there’s no password to type. When an app says “log in”, all it really needs is:

1. Your public key, so it knows whose feed to show and whose notes to fetch.
2. A way to get things signed, so your posts, likes and follows count as yours.

The dangerous shortcut is to give the app your nsec, which covers both at once. The safe way is to give it only number 1, plus a phone line to a signer for number 2.

Try it: who gets to touch your key?

Below is the same note signed three ways. Everything is real: real keys, real Schnorr signatures and real encryption running in your browser. The keys are demo keys made just for this page, so play freely.

Things to try:

• Sign with Paste your nsec and watch the key-leak detector go red. The app now is you.
• Switch to Browser extension, sign, then press Reject in the signer. Nothing gets signed.
• Try Remote bunker and open the hops in the middle column: the relay only ever carries gibberish.

The browser extension (NIP-07)

The most common signer is a browser extension (popular ones include Alby, nos2x and Nostr Connect). It follows NIP-07, which is wonderfully small: the extension adds an object called window.nostr to every web page. A web app calls it like a phone:

• “Who is this?” → getPublicKey() returns your public key. That’s the entire login.
• “Please sign this note.” → signEvent(template) makes the extension pop up, show you the note, and, if you approve, hand back the finished, signed event.

The secret key lives inside the extension’s private storage. The web page can’t read it, just as one website can’t peek into another website’s cookies.

Step through both tabs. In the first one, notice that only finished things travel to the app: a public key and a signed event.

interface WindowNostr {
  getPublicKey(): Promise<string>; // hex pubkey
  signEvent(event: { created_at: number; kind: number; tags: string[][]; content: string }): Promise<Event>; // adds id, pubkey, sig
  nip44?: {
    encrypt(pubkey: string, plaintext: string): Promise<string>;
    decrypt(pubkey: string, ciphertext: string): Promise<string>;
  };
  nip04?: { /* same shape, deprecated */ };
}

if (!window.nostr) throw new Error("No NIP-07 signer found. Install a Nostr extension.");

const pubkey = await window.nostr.getPublicKey(); // the whole "login"

const signed = await window.nostr.signEvent({
  kind: 1,
  created_at: Math.floor(Date.now() / 1000),
  tags: [],
  content: "gm!",
}); // throws if the user clicks "Reject"

The remote signer, or “bunker” (NIP-46)

Extensions are great on a laptop, but what about your phone, a shared computer, or an app that can’t install extensions? NIP-46 moves the signer to a different device, called a bunker. It could be an app on your phone, a little server at home, or a hosted service.

The clever part: the app and the bunker talk through an ordinary Nostr relay, like passing notes through a mailbox. Every note in the mailbox is locked with NIP-44 encryption, so the relay sees who is passing notes but not what they say.

1. The bunker gives you a connection link: bunker://<bunker pubkey>?relay=wss://…&secret=….
2. You paste it into the app. The app makes a throwaway keypair just for talking to the bunker.
3. The app sends an encrypted connect request; the bunker checks the one-time secret and answers ack.
4. The app sends get_public_key to learn your pubkey, which can differ from the bunker’s own key in the link.
5. From then on, every sign_event request pops up on your phone. Approve, and the signed event comes back.

Flip the diagram above to the NIP-46 bunker tab and step through it. Open a hop’s details to compare what the relay sees with what the bunker decrypts.

{
  "kind": 24133,
  "pubkey": "<client pubkey (throwaway)>",
  "tags": [["p", "<remote-signer pubkey>"]],
  "content": "<nip44(request)>",
  "created_at": 1735689600,
  "id": "…",
  "sig": "…"
}

{ "id": "s1", "method": "sign_event", "params": ["{\"kind\":1,\"content\":\"gm\",\"tags\":[],\"created_at\":1735689600}"] }
{ "id": "s1", "result": "{\"kind\":1,…,\"id\":\"…\",\"pubkey\":\"…\",\"sig\":\"…\"}" }

import { generateSecretKey } from "nostr-tools/pure";
import { BunkerSigner, parseBunkerInput } from "nostr-tools/nip46";

const pointer = await parseBunkerInput("bunker://…?relay=wss://relay.example&secret=…");
if (!pointer) throw new Error("Invalid bunker URL");

const clientKey = generateSecretKey(); // throwaway: store it to resume the session later
const bunker = BunkerSigner.fromBunker(clientKey, pointer, { onauth: (url) => window.open(url) });
await bunker.connect();

const pubkey = await bunker.getPublicKey(); // the user's key, not the bunker's
const signed = await bunker.signEvent({ kind: 1, created_at: Math.floor(Date.now() / 1000), tags: [], content: "gm" });

Names you can read: NIP-05

Public keys are great for computers and terrible for humans. Nobody wants to tell a friend “follow me at npub1qy88wumn8ghj7…”. NIP-05 adds an email-like label such as alice@alpha.example.

It works like a name badge that a company prints for you. Alice writes alice@alpha.example in her profile (kind 0 metadata). Your app doesn’t just believe her: it asks the domain alpha.example for a little file called nostr.json and checks that the name alice points to Alice’s public key. If the domain agrees, the app shows a checkmark.

Try Borrowed name: Alice’s profile claims to be bob@beta.example, but the domain lists Bob’s key there, so the check fails. Anyone can type any name into their profile; only the domain owner can vouch for it.

{
  "names": { "alice": "<64-char lowercase hex pubkey>" },
  "relays": { "<that pubkey>": ["wss://relay.alpha.example"] }
}

import { queryProfile, isValid } from "nostr-tools/nip05";

const pointer = await queryProfile("alice@alpha.example"); // { pubkey, relays } | null
const ok = await isValid(profilePubkey, "alice@alpha.example"); // true if the domain agrees

Quick check