JSON Path Evaluator

The JSONPath Evaluator tests JSONPath expressions against JSON documents — the de facto query language for JSON, inspired by XPath for XML. JSONPath uses expressions like $.users[?(@.age > 18)].name to filter, extract, and navigate JSON without writing procedural code. Paste your JSON and a JSONPath expression, see matched values instantly. Essential for: extracting specific fields from large API responses, filtering arrays based on conditions, querying configuration files, and building dynamic data pipelines that need to pull specific values from JSON.

JSONPath is standardized in RFC 9535 (2024) but has multiple implementations (Jayway, Goessner, Stefan Goessner's original) with minor differences. This evaluator uses the RFC 9535 standard syntax with Jayway-compatible extensions — matching what most modern libraries implement. Supports all standard operators: $ (root), . (child), .. (recursive descent), * (wildcard), [n] (index), [n,m] (union), [start:end] (slice), [?(expression)] (filter), @ (current node), and modern function syntax.

JSONPath syntax (RFC 9535):

Basic operators:

- $ — root node.
- .property — child by name.
- [property] — child (supports special chars in names).
- ..property — recursive descent (all descendants with this name).
- * — wildcard (all children).
- [n] — array index (0-based).
- [-1] — from end of array.
- [n,m,k] — union (multiple specific indices).
- [start:end:step] — slice (like Python).
- [?(expression)] — filter based on condition.
- @ — current node in filter.

Example JSON:

``json
{
"users": [
{"name": "Alice", "age": 30, "role": "admin"},
{"name": "Bob", "age": 25, "role": "user"},
{"name": "Carol", "age": 35, "role": "admin"}
],
"config": {
"version": "1.0"
}
}
``

Example queries:

| Expression | Meaning | Result |
|---|---|---|
| $ | Root | entire object |
| $.users | Users array | [Alice, Bob, Carol] |
| $.users[0] | First user | {name: Alice, ...} |
| $.users[-1] | Last user | {name: Carol, ...} |
| $.users[*].name | All names | [Alice, Bob, Carol] |
| $.users[0,2] | Users 0 and 2 | [Alice, Carol] |
| $.users[0:2] | First two users | [Alice, Bob] |
| $.users[?(@.age > 28)] | Users over 28 | [Alice, Carol] |
| $.users[?(@.role == "admin")].name | Admin names | [Alice, Carol] |
| $..name | All names anywhere | [Alice, Bob, Carol] |
| $..role | All roles | [admin, user, admin] |
| $.users[?(@.name =~ "^A")] | Names starting with A | [Alice] |

Filter expressions:

Within [?(...)]:

- Comparison: ==, !=, <, >, <=, >=
- Logical: &&, ||, !
- Regex: =~ (match against regex)
- Exists check: @.email (truthy if field exists)

Examples:

``
$.products[?(@.price < 100 && @.stock > 0)]
$.users[?(@.age >= 18 || @.verified == true)]
$.items[?(@.tags && @.tags.length > 0)]
``

Recursive descent (..):

$..name finds all name properties at any depth. Powerful but can return many results.

Functions (RFC 9535 standard):

- length(array) — array length
- count(nodes) — count of matched nodes
- match(string, regex) — regex match
- search(string, regex) — substring match via regex
- value(node) — value of single node (for type conversion in filters)

Example: $.users[?(length(@.tags) > 3)] (users with more than 3 tags).

Differences between JSONPath implementations:

Historical JSONPath had no single spec — Goessner's 2007 blog post was de facto standard. Multiple implementations:

- Jayway (Java): widely used. Adds some Jayway-specific features.
- jsonpath (JavaScript): Node.js implementation.
- jq: actually a different query language, more powerful.
- RFC 9535 (2024): official IETF spec.

This evaluator uses RFC 9535 + widely-compatible extensions.

Comparison to jq:

jq (the dominant CLI tool) has its own syntax, more powerful than JSONPath (functions, pipelines, transformations). JSONPath is simpler, more widely supported in libraries. For quick extraction: JSONPath. For complex transformations: jq.

Comparison to XPath:

XPath queries XML with similar syntax. JSONPath modeled on XPath for JSON. Most XPath concepts have JSONPath equivalents but syntax differs slightly.

JSONPath vs jq: Both query JSON. jq is more powerful (transformations, functions, pipes). JSONPath is simpler and has library support in many languages. jq is CLI; JSONPath is library-first.

JSONPath vs XPath: XPath for XML. JSONPath modeled on XPath for JSON. Similar concepts, different syntax. XPath is more mature; JSONPath is newer but sufficient for most JSON queries.

JSONPath vs JMESPath: JMESPath is an alternative JSON query language (AWS adopted it for CLI). More powerful than JSONPath, different syntax. Both have strong support.

JSONPath vs GraphQL: GraphQL is a query language for APIs (including what fields to return). JSONPath queries existing JSON. Different scope — GraphQL designs query at request time; JSONPath extracts from response.

This tool vs code evaluation: Tool helps debug JSONPath expressions. For production code, use JSONPath library in your language (jsonpath-ng in Python, jsonpath in JS, Jayway in Java).

RFC 9535 vs Goessner vs Jayway: RFC 9535 (2024) is the official standard. Goessner was de facto 2007-2024. Jayway (Java) is popular with some extensions. Libraries vary — check your implementation.