Meitheal: SensorThings on ATProto

Browse records (REST)

List all records of a given type using the standard ATProto listRecords endpoint:

GET https://pds.sensorthings.dev/xrpc/
  com.atproto.repo.listRecords
  ?repo=opw.sensorthings.dev
  &collection=dev.sensorthings.thing

Fetch a single record with getRecord:

GET …/com.atproto.repo.getRecord
  ?repo=opw.sensorthings.dev
  &collection=dev.sensorthings.thing
  &rkey=sandy-mills

Subscribe to the firehose (WebSocket)

Receive all new commits in real time – the same mechanism this app uses:

wss://pds.sensorthings.dev/xrpc/
  com.atproto.sync.subscribeRepos

Events arrive as CBOR-encoded commit frames. Filter for dev.sensorthings.* collections to process only sensor data. No authentication required.

Verify it yourself: Python

# pip install atproto
import hashlib, httpx, libipld
from atproto_core.did_doc import DidDocument
from atproto_crypto.verify import verify_signature

did  = "did:plc:fiahvmd5lfxjjvfvefxfz5ac"
coll = "dev.sensorthings.thing"
rkey = "epa-92"
pds  = "https://pds.sensorthings.dev"

# 1. Signing key from the DID document
doc = httpx.get(f"https://plc.directory/{did}").json()
key = DidDocument.from_dict(doc).get_did_key()

# 2. Proof CAR: signed commit + Merkle path + record
car = httpx.get(f"{pds}/xrpc/com.atproto.sync.getRecord",
                params={"did": did, "collection": coll,
                        "rkey": rkey}).content
header, blocks = libipld.decode_car(car)
commit = blocks[header["roots"][0]]

# 3. Commit signature over the commit without its sig
unsigned = {k: v for k, v in commit.items() if k != "sig"}
assert verify_signature(
    key, libipld.encode_dag_cbor(unsigned), commit["sig"])

def cid(block):
    h = hashlib.sha256(libipld.encode_dag_cbor(block)).digest()
    return b"\x01\x71\x12\x20" + h

# 4. Walk the tree to the record, checking each node's hash
def find(node_cid, target, prev=b""):
    node = blocks[node_cid]
    assert cid(node) == node_cid
    sub = node["l"]
    for e in node["e"]:
        k = prev[:e["p"]] + e["k"]
        prev = k
        if target == k:
            return e["v"]
        if target < k:
            return find(sub, target) if sub else None
        sub = e["t"]
    return find(sub, target) if sub else None

value_cid = find(commit["data"], f"{coll}/{rkey}".encode())
assert value_cid and cid(blocks[value_cid]) == value_cid
print("verified", coll, rkey)

Verify it yourself: JavaScript (Node)

// npm i @atproto/repo
import { verifyRecords } from "@atproto/repo";

const did  = "did:plc:fiahvmd5lfxjjvfvefxfz5ac";
const coll = "dev.sensorthings.thing";
const rkey = "epa-92";
const pds  = "https://pds.sensorthings.dev";

// Signing key from the DID document
const doc = await (
  await fetch(`https://plc.directory/${did}`)
).json();
const vm = doc.verificationMethod.find(
  (m) => m.id.endsWith("#atproto"));
const didKey = `did:key:${vm.publicKeyMultibase}`;

// Proof CAR from getRecord
const url = `${pds}/xrpc/com.atproto.sync.getRecord`
  + `?did=${did}&collection=${coll}&rkey=${rkey}`;
const car = new Uint8Array(
  await (await fetch(url)).arrayBuffer());

// Verifies Merkle inclusion AND the commit signature
// against the DID's key; throws if either fails,
// otherwise returns the records in the proof.
const [rec] = await verifyRecords(car, did, didKey);
console.log("verified", rec.collection, rec.rkey);