TrueSight

Turn any Ring camera into any sensor: ask it a question in plain words, get alerts with signed, privacy-redacted evidence anyone can verify.

Comment

Inspiration

A Ring camera watches a front door all day, but you still can't ask it the simplest things: Is the side gate latched? Did the bins go out? Is there a package on the porch? Buying a separate sensor for every question is expensive, and the camera already sees the answer.

Two more problems kept coming up when we talked to family and neighbors about cameras:

  • Footage isn't proof. A screenshot can be cropped, edited or re-dated, and nobody can tell.
  • Cameras see more than they should. The neighbor's yard, people walking past, faces.

TrueSight started from one question: what if a camera could answer any question, prove what it saw, and show you exactly what it did not look at?

What it does

You draw a box on a Ring camera frame, ask a question in plain words, and choose the answers that count (for example latched / open, with open as an alert). On every motion event, doorbell press, linked contact-sensor event, or on a schedule, TrueSight:

  1. Fetches the latest frame through the Ring API.
  2. Pixelates privacy zones and faces, then sends only the box to a vision model.
  3. Changes the sensor's state only after the answer is confirmed.
  4. On an alert, seals the original frame as evidence before redacting it, plays a Ring Chime and notifies you.
  5. Exports the incident as one signed file that anyone can verify in a browser, without an account and without ever seeing the unredacted original.

Every AI check also leaves a privacy receipt: how much of the frame the AI saw, and whether the frame was kept or thrown away.

How I built it

Ring Partner API. Device discovery, image downloads, event history, clips, chime playback, HMAC-verified webhooks and one-way account linking. I don't own a Ring camera, so I tested live with a Ring Developer Playground token and its Playground Device. The Playground sends no webhooks, so I built an event-history poller that feeds the same pipeline.

Perception. Only the region the owner draws reaches the AI. If the frame is $W \times H$ and the region is $w \times h$, the model sees a fraction

$$\rho = \frac{w\,h}{W\,H}$$

of the frame, usually 10–20%. The model runs on Groq with strict JSON output whose allowed values are the owner's own labels plus unknown, so it never has to guess. An output guardrail blocks any description of a person's gender, age, race or intent.

Debouncing. A state only changes after $k$ answers in a row agree, each with confidence $\ge \tau$. If a single frame is misread with probability $p$, and we treat misreads as roughly independent, a false alarm needs about

$$P_{\text{false}} \approx p^{k}$$

For $p = 0.05$, going from $k=1$ to $k=2$ cuts false alarms from $5\%$ to $0.25\%$, at the cost of one extra check.

A tamper-evident ledger. Every event (sensor created, Ring event, state change, evidence captured, redaction, export, even viewing an original) is an entry $e_n$ that contains the previous entry's hash:

$$h_n = \mathrm{SHA\text{-}256}\big(\mathrm{canon}(n,\ t_n,\ \mathrm{type}n,\ \mathrm{data}_n,\ h{n-1})\big), \qquad \sigma_n = \mathrm{Sign}_{\mathrm{ES256}}(\cdots)$$

Editing entry $k$ changes $h_k$, so entry $k+1$ no longer links to it. Recomputing the hash doesn't help, because the signature $\sigma_k$ can't be forged without the private key.

Proving a redaction is honest. Let $R$ be the set of redacted rectangles and $I$ the original image. At capture time, TrueSight signs a digest of every pixel outside $R$:

$$D = \mathrm{SHA\text{-}256}\big(W \times H \;|\; I \cdot \mathbb{1}_{\overline{R}}\big)$$

A verifier who has only the redacted image $I'$ recomputes $D'$. Barring a SHA-256 collision,

$$D' = D \iff I'(x,y) = I(x,y)\quad \forall\,(x,y) \notin R$$

That proves the redaction changed nothing except the declared boxes, without anyone seeing the original.

Stack. A TypeScript monorepo: an Express server, a React + Vite + Tailwind console, and a landing page built with React Three Fiber and GSAP. The signer, ledger and storage have adapters for AWS KMS, DynamoDB, S3 Object Lock, Rekognition and SNS that you switch on in config. My demo runs the local signer and disk storage. I also built a Ring simulator (three cameras, a chime and a contact sensor that send Ring-format, HMAC-signed webhooks), so the whole pipeline has end-to-end tests without any hardware.

Challenges I ran into

  • No Ring hardware. Playground tokens last about 30 minutes and receive no webhooks, so we polled event history instead and refreshed the token right before every test.
  • Account linking. We expected "Log in with Ring" in the Developer Console to link an account, but it only adds a staging user. Linking actually starts in the Ring AppStore. Along the way, our console treated Ring's 401 as "your session expired" and trapped us in a sign-in loop.
  • Media windows. Snapshot requests failed with TIME_RANGE_NOT_AUTHORIZED, because Ring only serves media recorded after consent and the API doesn't expose that date. We made the request window shrink until Ring accepts it, then remember the accepted start.
  • Clock skew. Our PC's clock was about 22 seconds ahead of Ring's, so requests failed with "end timestamp cannot be in the future". We stopped sending an end time and estimate Ring's clock from its Date header.
  • An undocumented error. After switching to a new Playground token, older recordings returned GRECO_NO_VALID_KEY: they could no longer be decrypted. The fix is to record a fresh clip after every new token.
  • Pixel-exact proof. JPEG re-encoding changes almost every pixel, which would break the redaction proof. So the redacted copy is a lossless PNG, and the server checks its own digest before signing.

Accomplishments that I am proud of

  • It runs on the real Ring API without owning a Ring camera: teach a sensor on the Playground Device, trigger a Vehicle event, and watch it become sealed evidence.
  • A redacted image you can trust. Anyone can prove that only the declared boxes were hidden, without ever seeing the original.
  • Forgery gets caught. In our sample, a forger rewrites "open" to "latched" and even recomputes the hash. The verifier still names the exact entry that was changed.
  • An open-source verifier. truesight-verify (MIT) runs 11 checks offline in any browser or from the command line, so nobody has to trust our servers.
  • Privacy you can see. The AI sees only the box you drew, and every check leaves a receipt.
  • A landing page where every demo is real. It signs and verifies a fresh evidence bundle right in your browser.
  • A Ring simulator and end-to-end tests that cover the whole flow, from signed webhook to verified bundle.

What I learned

  • How the Ring Partner API fits together: account linking, token exchange, webhooks signed with HMAC, and why media access depends on consent.
  • That small details make or break signatures: canonical JSON (the same object must always give the same bytes), ES256 signature formats, and RFC 7638 key thumbprints.
  • That privacy by design is mostly about defaults: crop before the AI, discard frames unless they become evidence, and give the owner a receipt for every check.
  • How useful the Ring MCP docs server is for searching a very large API reference from an AI coding assistant. We kept a friction log of every documentation gap we hit.

What's next for TrueSight

  • Real accounts: test with a linked Ring account and live webhooks, beyond the Playground.
  • Production evidence on AWS: AWS KMS for signing, S3 Object Lock for write-once storage, and Amazon Rekognition for live face pixelation.
  • More templates and smarter scheduling, such as checking more often after dark, or only while you're away.
  • Publish truesight-verify on npm, so insurers, neighbors or anyone else can check Ring-derived evidence in their own tools.
  • A "Verified" tier for Ring owners, with evidence that insurers can accept for claims.

Built With

Share this project:

Updates

Submission history