A couple of days ago, I was building out JSON-LD for siteimp.com when I ran into a funny situation. I was looking for something less than full Schema.org validation because that was overkill for my tiny bit of data. But I wanted a basic sanity checker before I hit push and potentially munged up how Google looks at a production website. So not quite full validation just... a sanity check.

As per usual, I wanted something private, that I could use through a browser, that didn't have ads or adware and that didn't require uploading data to a server. It's pretty hard to find anything that meets those four requirements and so, since I had some existing code that was close, I decided to build my own.

What the tool does

The new JSON-LD Sanity Checker is intentionally small because I didn't really need more. It's just the basic checks that I'd like to automate before I potentially ruin the next several months of my life.

It lets you paste JSON-LD, or a full <script type="application/ld+json"> block, and then checks whether the content is valid JSON. If it can parse the data, it shows a small report and renders the JSON-LD as an expandable tree so you can inspect the structure without staring into a wall of braces.

It also checks for a few obvious structured-data issues:

  • missing @context
  • missing or suspicious @type
  • graph items that are not objects
  • duplicate @id values
  • empty string fields
  • common URL fields that look relative, empty, or invalid
  • a few common missing fields for things like articles, web pages, organizations, websites, and software applications

That is about as ambitious as I wanted this to be.

What the tool does not do

This is not a full Schema.org validator.

It is not a Google rich results test.

It does not tell you whether Google will like your structured data, use your structured data, ignore your structured data, or toss it into the algorithmic swamp behind the shed.

There are better tools for full validation, and those tools should exist. But I wanted something smaller and faster: a quick preflight check for the moment before publishing when you mostly want to know:

Is this valid JSON-LD, can I read it, and does anything look obviously wrong?

That is the whole job.

Why browser-only matters

I keep coming back to this because it matters to me: the tool runs in your browser.

It does not fetch your URL. It does not crawl your page. It does not call an API. It does not upload your structured data to hluska.ca. It does not require an account. It does not store anything server-side. There are no ads and I am allergic to running adware on my own projects. This is about as private as you can get... but you shouldn't trust me (or anyone) who says that so verify claims like this.

You paste the JSON-LD into the page, the JavaScript runs locally, and the result appears in your browser.

If you refresh or close the page, the input is gone. That is not a missing feature. That is the point.

How to test the privacy claim

I added the same kind of plain-language testing guidance I used for the JSON and NDJSON tools.

After the page loads, you can turn off your internet connection and use the checker. If it still works, the checking is happening in your browser.

You can also open your browser developer tools, switch to the Network tab, and check some JSON-LD. You should not see your structured data being uploaded anywhere.

That does not mean every browser tool is safe, and it does not mean you should paste sensitive production data into random websites. But it gives you a practical way to verify what this tool is doing instead of relying on a trust-me-bro privacy paragraph wearing a tiny hat.

Why this fits with the other tools

This started with the NDJSON Formatter, which I built while preparing for Siteimp's beta support workflow. Then I realized the same basic code could become a JSON Formatter, because normal JSON gets far more search traffic and is useful to far more people.

The JSON-LD Sanity Checker is the next little branch on that tree.

At this point, the tools section is becoming a small local-first toolbox:

  • JSON Formatter
  • NDJSON Formatter
  • JSON-LD Sanity Checker
  • SCSS Contrast Grid
  • Django Secret Key Generator

None of these are giant products. They are small browser tools that do one thing clearly and avoid turning simple developer chores into data collection exercises.

That feels like a surprisingly good direction.

The Siteimp connection

This also connects naturally to Siteimp.

Siteimp is about website integrity, evidence, and making real website problems easier to inspect. Structured data fits that world. It is one of those quiet pieces of a website that can be correct, broken, stale, incomplete, misleading, or just sort of weird.

A tiny JSON-LD sanity checker on hluska.ca is useful on its own, but I can also imagine a more complete structured-data workbench eventually living on Siteimp. That version could do more: inspect pages, compare structured data across URLs, help find missing metadata, and fit into a broader site integrity workflow.

But that is later.

For now, this is deliberately small.

Paste JSON-LD. Check it. Expand the tree. Catch the obvious stuff. Keep everything local.

Not every tool needs to become a platform. Sometimes the best tool is just a flashlight you trust.