CalConverters

jq Online — JSON Query

Paste JSON, write a jq filter and run it right here in your browser. Powered by a pure-Rust jq engine (jaq) — your data never leaves your device.

Files never leave your device
0
Examples:

What This Tool Does

Paste JSON, write a jq filter, and run it — entirely in your browser. A WebAssembly module compiled from jaq, a pure-Rust reimplementation of the jq language, compiles and runs your filter on your own device. Nothing is uploaded to make this work: your JSON and your filter never leave your browser tab.

Tip: New to jq? Click one of the example buttons above the filter box — identity, field access, iterate, map, or keys — to drop a working filter into the box, then edit it to match your own field names.

How to Use It

Paste your JSON into the input box, or load it from a file. Type a jq filter into the filter box — or click one of the example buttons to start from a working one — and click Run. Each value your filter produces appears as a separate result underneath, in the order the filter emitted them; copy any single result or the full output once you're happy with it.

A jq Mini-Cookbook

jq filters read left to right, and the pipe character | chains one filter's output into the next filter's input. A handful of patterns cover most everyday needs:

.

The identity filter — returns the input completely unchanged. Useful for confirming your JSON parsed the way you expect before writing anything more complex.

.foo

Field access — pulls the value of the key foo out of an object. Chain it to go deeper, e.g. .foo.bar.

.[] | .name

Iterate, then access a field — .[] streams out every element of an array (or every value of an object) one at a time, and the pipe sends each one into .name, producing one output per element that has that key.

map(.x)

Builds a single new array by applying .x to every element of the input array — the array-preserving counterpart to .[] | .x.

keys

Returns an array of an object's keys, sorted alphabetically — handy for a quick look at an unfamiliar document's shape.

.[] | select(.age > 30)

Iterate, then keep only the elements matching a condition — select passes a value through unchanged when the condition is true and drops it otherwise, which is how you filter an array of objects down to the ones you care about.

now

The current Unix timestamp in seconds, supplied by your browser tab so it's always in sync with your own clock rather than depending on a server.

Number Semantics: jq Is f64-Based, Like the Real Thing

This tool mirrors the real jq CLI's number handling, which is different from the Formatter tool on this site. Once a number passes through a jq filter, it's represented as a 64-bit floating-point double — the same representation JavaScript uses — so an enormous integer can come back looking slightly different from how it went in, exactly the way it would with the official jq binary. That's expected jq behavior, not a bug in this tool, and it only matters for numbers past about seventeen significant digits; everyday values are unaffected.

If you need a number preserved exactly as written — say, formatting a document that contains a very large ID or a long decimal without touching a single digit — use the JSON Formatter instead. It parses with Rust in a mode that keeps each number's exact source text, which is what makes it byte-exact where a query-and-transform tool like this one, by design, is not.

Limits

Input JSON is capped at 10 MB, and a single run is capped at 10,000 output values. Both limits stop the run up front with a clear message rather than letting your browser tab stall trying to process or render more than it comfortably can.

Where to Go Next

If what you actually need is to clean up, validate, or minify a JSON document rather than query or transform it — especially one containing very large numbers you don't want altered — the JSON Formatter does that job and keeps every digit exactly as you wrote it.

Frequently asked questions

Is this really the jq command-line tool?
It runs jaq, a from-scratch reimplementation of the jq language written entirely in Rust rather than the original C jq binary. jaq targets the same filter syntax and behavior for everyday use — field access, piping, the standard builtins — so filters you already know should work as expected here, though being an independent implementation, it can differ from the original in rare corners of the language.
Is my JSON uploaded anywhere to run a query?
No. Your JSON and your filter are both handed to a WebAssembly module running inside your browser tab, and the query executes entirely on your own device. Nothing is sent to a server at any point.
Is there a limit on how many results a query can return?
Yes — up to 10,000 output values per run. A filter such as a broad iterate-and-select that would produce more than that stops with a clear message asking you to narrow the query, rather than trying to render an unbounded stream of results in your browser tab.
How is this different from the JSON Formatter tool?
The formatter's job is to validate, pretty-print, minify and sort an existing JSON document without changing what it means, and it goes out of its way to preserve every digit of every number exactly as written. This tool's job is different: you write a filter to select, reshape or transform JSON into something new. One side effect of that difference is numeric — this tool follows real jq number semantics, so a very large integer can come back changed the way the actual jq CLI would handle it, whereas the Formatter never touches a number's digits at all.