Anatomy of an event

In the last chapter you got a keypair. Now let’s use it. On Nostr, everything you do is an event: a post, a like, your profile, the list of people you follow. Different jobs, one shape. Learn that shape once and you can read the whole protocol.

A sealed envelope with a fingerprint

Think of an event as a postcard you put in a clear plastic sleeve:

• The postcard is what you want to say: the text, when you wrote it, what kind of message it is, and a few sticky labels.
• The fingerprint stamped on the sleeve is calculated from the postcard. Change one letter on the card and the fingerprint no longer matches.
• Your wax seal goes on top of the fingerprint. Only you can press it, but anyone can check it’s yours.

That’s it. That’s an event. The fingerprint is the id, and the wax seal is the signature.

Here is a real one, written by Alice. Click any field to learn what it does.

Try it now: switch to A forger (no key) and change the text. The content updates, but the old id and signature are still stuck on it, and the verification pipeline catches you at the very first check. Switch back to Alice and the same edit is perfectly fine, because she can re-sign.

The seven fields

Every event has exactly these seven fields. Nothing more is required, nothing less is allowed.

kind: one number, many jobs

The kind tells apps how to read the rest. Kind 1 is a short text note, kind 0 is your profile, kind 3 your follow list, kind 7 a reaction (a “like”). The number also tells relays how to store it: most events are kept forever, but some are replaceable (only your latest profile matters), and some are ephemeral (pass it on, don’t keep it). We’ll tour the whole zoo in chapter 6.

tags: sticky labels

Tags are a list of little lists. The first item is the label’s name, the rest are its values:

• ["e", "<event id>"] points at another event. That’s how replies and quotes work.
• ["p", "<pubkey>"] mentions a person, so their app can notify them.
• ["t", "nostr"] is a hashtag.

Labels with a single letter are special: relays index them, so a client can ask “give me every note tagged #nostr” or “every reply to this event”.

created_at: a claim, not a clock

created_at is a Unix timestamp, chosen by the author. Nothing stops Alice from writing “January 2009”. Clients sort feeds by it, and many relays reject events from too far in the future, but don’t treat it as proof of when something happened.

How the fingerprint is made

To compute the id, every client follows the same recipe from NIP-01:

1. Serialize. Put the fields in a fixed order inside a JSON array, with no extra spaces: [0, pubkey, created_at, kind, tags, content]. The leading 0 is a version marker.
2. Hash. Encode that text as UTF-8 bytes and run them through SHA-256. Out come 32 bytes, written as 64 hex characters. That’s the id.
3. Sign. Alice signs the id with her secret key using a Schnorr signature. That’s the sig.

A hash has a wonderful property called the avalanche effect: change one character of the input and roughly half of the output bits flip. Watch the “id digits changed” counter in the lab: a single letter usually scrambles about 60 of the 64 hex digits.

[0,"a73883912a48c3551c1548fd454876d577126a61c76b5486c807bfec5869e183",1735686600,1,[],"testing testing is this thing on"]

import { sha256 } from "@noble/hashes/sha2.js";
import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";

const serialized = JSON.stringify([0, pubkey, created_at, kind, tags, content]);
const id = bytesToHex(sha256(utf8ToBytes(serialized)));

Checking the seal

When your app receives an event from a relay, it doesn’t trust it just because it arrived. It verifies it, in two steps:

1. Recompute the id from the fields. Does it match the id the event claims? If not, something was changed after signing.
2. Check the sig against the id and the pubkey. If it fails, the event wasn’t signed by that key.

Both checks are pure math, and they run on your own device. That’s the big idea: you don’t need to trust the relay. A relay can refuse to deliver Alice’s notes, but it cannot change a single word of them, or invent new ones in her name, without getting caught.

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

const sk = generateSecretKey(); // Uint8Array(32)
const event = finalizeEvent(
  {
    kind: 1,
    created_at: Math.floor(Date.now() / 1000),
    tags: [["t", "nostr"]],
    content: "Hello Nostr!",
  },
  sk,
); // adds pubkey, id and sig

verifyEvent(event); // true

// A tampered copy, as it would arrive from the network (plain JSON):
const tampered = JSON.parse(JSON.stringify({ ...event, content: "Hello Nostr?" }));
verifyEvent(tampered); // false: the id no longer matches

["e", "<32-byte hex event id>", "<recommended relay URL, optional>", "<author pubkey, optional>"]
["p", "<32-byte hex pubkey>", "<recommended relay URL, optional>"]
["a", "<kind>:<pubkey hex>:<d tag value>", "<recommended relay URL, optional>"]

Inspect any event

Got an event from somewhere else? Paste it into the event inspector tool: it checks the id and signature right in your browser and explains every field.

Quick check