What is the difference between $.store.book[*] and $..book?

$.store.book[*] selects every element of the array at the fixed location store → book. $..book uses recursive descent: it finds a member named 'book' at any depth in the document, wherever it appears. Use [*] when you know the path; use $..book when 'book' could be nested anywhere.

How do I write a JSONPath filter expression?

A filter is [? ] applied to an array or object. Inside, @ refers to the current item. Compare with == != >=, combine with && || !, and test existence by naming a path. Example: $.store.book[?(@.price < 15 && @.category == 'fiction')] keeps fiction books under 15.

Is JSONPath a standard?

Yes. Since February 2024, JSONPath is defined by RFC 9535 — "JSONPath: Query Expressions for JSON" — an IETF Proposed Standard. It pins down the grammar and evaluation semantics that older implementations interpreted differently. This tool follows RFC 9535, and each operator in the legend cites its section.

How do I select the last element of an array in JSONPath?

Use a negative index: $.store.book[-1] returns the last element, [-2] the second-to-last, and so on. A negative index n resolves to length + n. You can also slice from the end, for example [-2:] for the last two elements.

What does the recursive descent .. operator do?

The descendant segment .. applies the next selector to a node and all of its descendants, depth-first in document order. So $..price collects every 'price' member anywhere in the tree, and $..* returns every value in the whole document. It is the most powerful — and slowest — segment.

Does this tool upload my JSON to a server?

No. Parsing and evaluation happen entirely in your browser with a pure JavaScript engine — there is no network request, no API key, and nothing is logged. You can paste sensitive payloads safely and even use the tool offline once the page has loaded.

Which JSONPath functions are supported?

All five RFC 9535 built-ins: length() (of a string, array or object), count() (of a nodelist), match() (full-string regex), search() (substring regex), and value() (the single value of a singular query). Example: $.store.book[?(length(@.title) > 10)] keeps books whose title is longer than ten characters.

Why does my query from another library behave differently here?

Many popular libraries predate RFC 9535 and diverge on details — recursive-descent ordering, negative-index bounds, filter type coercion, or vendor extensions like the parent (^) and script ((...)) selectors. This tester implements the standard and flags non-standard syntax with a positioned error rather than guessing.

Developer · Utility

JSONPath Tester & Evaluator (RFC 9535)

Paste a JSON document and a JSONPath expression to see every matched value and its exact normalized path — evaluated in your browser against the RFC 9535 standard. Wildcards, slices, filters, recursive descent and the built-in functions all supported. No signup, nothing uploaded.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 17, 2026

JSONPath TesterRFC 9535

Runs in your browser

JSONPath expression

Show

Try

JSON document

461 characters. Everything stays in your browser.

Matches

nodes in document order

Query status

Valid

Expression parsed per RFC 9535

Round-trip

Verified

Each path re-resolves to its value

Values

[
  "Nigel Rees",
  "Herman Melville",
  "J. R. R. Tolkien"
]

Document tree

— click any key to write its JSONPath above

Operator legend (RFC 9535)

$Root identifier— The whole JSON document; every query starts here.§2.2
.name / ['name']Name selector— Select an object member by key.§2.3.1
* / [*]Wildcard selector— Select all members of an object or all elements of an array.§2.3.2
[n]Index selector— Select array element n; negative counts from the end.§2.3.3
[start:end:step]Array slice— Half-open Python-style slice, negatives and step allowed.§2.3.4
[?<expr>]Filter selector— Keep items whose boolean expression is true.§2.3.5
..Descendant segment— Apply the next selector to a node and all of its descendants.§2.5.2
length() count() match() search() value()Functions— Built-in filter functions defined by the standard.§2.4

Sources: RFC 9535 (JSONPath) and RFC 8259 (JSON). Filter regex uses the standard's I-Regexp semantics; results are cross-checked against the JSONPath Compliance Test Suite.

How it works

Evaluation is a pure, deterministic function of the pair (jsonDocument, expression) — no network, no randomness, no server. The engine follows RFC 9535, “JSONPath: Query Expressions for JSON”, the IETF standard published in February 2024. Four steps run on every keystroke:

Parse the document. The JSON text is parsed per RFC 8259. If it is malformed, the tool shows the error message with its line and column and stops — a query never runs against invalid JSON.
Parse the expression. The query is broken into segments per the RFC 9535 grammar: a leading root $ followed by child segments (.name, […]) and descendant segments (..name, ..[…]). Any syntax outside the standard raises an error with the exact character position.
Apply the selectors left to right, threading a nodelist — a list of nodes, each carrying its value and its location from the root. Name selectors pick object members (§2.3.1), wildcards take everything (§2.3.2), index selectors read array elements with negative-from-end support (§2.3.3), slices apply a half-open Python-style start:end:step (§2.3.4), and filters keep items whose boolean expression is true (§2.3.5). A descendant segment first expands the nodelist to include each node and all of its descendants, depth-first, before applying its selector (§2.5.2).
Emit results. The final nodelist gives the matched valuesin document order and, from each node's accumulated location, the normalized path in the canonical single-quote bracket form defined in §2.7 — for example $['store']['book'][0]['author'].

Filter expressions support comparisons == != < <= > >=, the logical operators && || !, parentheses, existence tests, and the five standard functions length(), count(), match(), search() and value() (§2.4). Comparisons are only defined between values of the same orderable type; anything else evaluates to false rather than throwing, exactly as the standard prescribes.

As a self-check, every result is round-tripped: the engine re-evaluates each match's normalized path and confirms it resolves back to the same single value. When that holds, the calculator shows “Round-trip verified”. The operator table and worked examples below were reconciled against RFC 9535 and the JSONPath Compliance Test Suite on 2026-07-17.

Operator	What it does	RFC 9535
`$` Root identifier	The whole JSON document; every query starts here.	§2.2
`.name / ['name']` Name selector	Select an object member by key.	§2.3.1
`* / [*]` Wildcard selector	Select all members of an object or all elements of an array.	§2.3.2
`[n]` Index selector	Select array element n; negative counts from the end.	§2.3.3
`[start:end:step]` Array slice	Half-open Python-style slice, negatives and step allowed.	§2.3.4
`[?<expr>]` Filter selector	Keep items whose boolean expression is true.	§2.3.5
`..` Descendant segment	Apply the next selector to a node and all of its descendants.	§2.5.2
`length() count() match() search() value()` Functions	Built-in filter functions defined by the standard.	§2.4

Worked examples

Each example runs against the RFC 9535 bookstore document (three books with author, title, category and price; a red bicycle). Load it with the Sample button in the tool above.

Recursive descent for a key — 3 matches

$..author

..author collects every 'author' member anywhere in the tree.
The three book objects each have an author; the bicycle does not.
Values: ["Nigel Rees", "Herman Melville", "J. R. R. Tolkien"]
Paths: $['store']['book'][0..2]['author']

Filter on a numeric field — 2 matches

$.store.book[?(@.price < 15)].title

Descend store → book, then keep elements where @.price < 15.
Prices are 8.95, 12.99, 22.99 → the first two pass, the third fails.
Take .title of each kept element.
Values: ["Sayings of the Century", "Moby Dick"]

Negative array index — 1 match

$.store.book[-1].price

[-1] resolves to length + (-1) = index 2, the last book (Tolkien).
Then read its price member.
Value: [22.99] · Path: $['store']['book'][2]['price']

Descendant + name — 4 matches

$.store..price

store, then .. expands to store and every descendant.
The name selector 'price' keeps each price member in document order.
Three book prices, then the bicycle price.
Values: [8.95, 12.99, 22.99, 19.95]

Frequently asked questions

Sources & references

The operator table and worked examples on this page were last cross-checked against RFC 9535 and the compliance test suite on 2026-07-17. The engine runs entirely client-side; if you find a query where it disagrees with the standard, email me the document and expression and I'll investigate.

Related tools

LiveUtility

Regex Tester

Test JavaScript regular expressions against any text with live highlighting, capture groups, replacement preview, flag toggles, and a construct-by-construct explainer. ECMA-262, runs entirely in your browser.

Open tool

LiveUtility

CSV to JSON Converter

Paste or upload CSV/TSV and get clean JSON instantly — quoted fields, custom delimiters, automatic type inference, and dot-notation nesting. Array of objects, array of arrays, or column-keyed output. Runs entirely in your browser, nothing uploaded.

Open tool

LiveUtility

JSON Converter

Convert JSON to CSV (RFC 4180), XML (1.0 well-formed), or YAML (1.2 block-style) in your browser. Flattens nested objects with a configurable separator. Round-trip verified, no uploads.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.