Every license verification the Neighborhood Registry records becomes an event in a public ledger. Each event is chained to the one before it with SHA-256: an event’s hash is computed over the previous event’s hash together with the event’s own recorded fields. Edit, delete, or insert an event after the fact and the chain no longer recomputes — the break is visible to anyone who re-walks it. On top of the chain, the Registry signs the current chain head with its Ed25519 signing key, so the head state itself carries a cryptographic attestation that anyone can check against the Registry’s published public key.
Current signed checkpoint
The checkpoint below is refreshed every 15 minutes. Each refresh re-walks the entire chain from the beginning; a new checkpoint is signed only when every link verifies.
- Events in the log: see checkpoint
- Chain head (SHA-256): see checkpoint
- Last event id: see checkpoint
- Checkpoint issued: see checkpoint
- Signing key: nr-verify-2026-01
Machine-readable checkpoint: /transparency-checkpoint.json
What an event records
Each event commits to seven fields: the Registry profile id of the professional, the licensing authority, the license number, the recorded status, the date and time the check was recorded (the ledger clock), the authority source URL the check read, and a short label describing the check. Those are the same fields published in the event export — nothing is committed to the chain that is not also published here.
Coverage, stated plainly
The ledger’s first event is dated July 30, 2026. The log covers the Registry’s verification history from the day the ledger began; there are no events before that date, and the log says nothing about any record before it.
The hash chain was introduced on October 24, 2026. Events recorded before that day were chained retroactively, and every one of those entries carries a note saying so in the export. For those early events, the chain proves the record has not been altered since October 24, 2026 — the day it was chained.
New events append as verifications are recorded. A checkpoint attests to a prefix of the log: every event up to the checkpoint’s last event id, in order, with nothing altered.
Downloads
- Signed chain-head checkpoint (JSON): transparency-checkpoint.json
- Full event export (gzip JSON Lines, one event per line, the same snapshot the checkpoint attests to): transparency-events.jsonl.gz
- Signing keys (JWKS): nr-verification-key.json
- Related: the Verification Ledger report, the license wire, and how we verify.
Verify it yourself
You do not need the Registry’s database, code, or permission. Three public files are enough:
curl -O https://neighborhoodregistry.com/transparency-checkpoint.json curl -O https://neighborhoodregistry.com/transparency-events.jsonl.gz curl https://neighborhoodregistry.com/.well-known/nr-verification-key.json -o nr-verification-key.json
Step 1 — re-walk the chain (Python 3, standard library only):
import gzip, hashlib, json
genesis = hashlib.sha256(b"neighborhood-registry|verification-ledger|genesis-v1").hexdigest()
prev = genesis
n = 0
for line in gzip.open("transparency-events.jsonl.gz", "rt", encoding="utf-8"):
e = json.loads(line)
assert e["prev_hash"] == prev, "chain break at event %s" % e["id"]
payload = "|".join([str(e["professional_id"]), e["authority"], e["license_number"],
e["status"], e["checked_at"], e["source_url"] or "", e["detail"] or ""])
prev = hashlib.sha256((prev + "|" + payload).encode("utf-8")).hexdigest()
assert prev == e["event_hash"], "hash mismatch at event %s" % e["id"]
n += 1
print(n, prev)
Compare the printed count and final hash with events and head_hash in the checkpoint. If every event matches and the totals agree, the log you downloaded is internally untampered from the genesis value onward.
Step 2 — verify the checkpoint signature (requires the Python cryptography package):
import base64, json
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
def b64d(s):
return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
cp = json.load(open("transparency-checkpoint.json"))
signature = b64d(cp.pop("signature"))
canonical = json.dumps(cp, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
jwks = json.load(open("nr-verification-key.json"))
x = next(k["x"] for k in jwks["keys"] if k["kid"] == cp["kid"])
Ed25519PublicKey.from_public_bytes(b64d(x)).verify(signature, canonical)
print("signature OK")
The signature covers the RFC 8785 (JCS) canonical form of the checkpoint with the signature member removed; this checkpoint is a flat object of ASCII strings and integers, for which the JCS canonical form is exactly JSON with sorted keys and no whitespace, as produced above. The x value in the JWKS is the raw 32-byte Ed25519 public key, base64url-encoded.
What this does and does not prove
The chain and the checkpoint prove that the events published here are the events the Registry recorded, in this order, unaltered since each was chained — and that the Registry’s key signed that head state at the checkpoint’s stated time. Licensure itself rests on the underlying authority records: every event names the authority and the source it read, so any single event can be checked against the authority directly.
