JSONPath Online Evaluator

How to test JSONPath expressions online

jsonsql.dev evaluates JSONPath expressions instantly in your browser. No data is sent to any server — your JSON stays on your machine.

JSONPath syntax reference

JSONPath is to JSON what XPath is to XML — a query language for extracting data from structured documents using path expressions.

JSONPath dot notation vs bracket notation

Use dot notation ($.store.name) for simple keys and bracket notation ($['store']['my key']) when property names contain spaces or special characters.

When to use dot notation

• Simple alphanumeric property names: $.user.name
• Chaining multiple levels: $.config.database.host
• Combined with array access: $.users[0].email

When to use bracket notation

• Keys with spaces: $['first name']
• Keys with special characters: $['content-type']
• Keys that look like numbers: $['404']
• Dynamic or computed keys in code

Side-by-side comparison

// These expressions are equivalent:
$.store.books[0].title
$['store']['books'][0]['title']

// Bracket notation is required for special keys:
$['first name']          // space in key
$['content-type']        // hyphen in key
$['@attributes']['id']   // @ in key

// Dot notation is shorter and more readable:
$.store.bicycle.color    // preferred
$['store']['bicycle']['color']  // equivalent but verbose

JSONPath filter expressions

JSONPath filter expressions use the syntax [?(@.field op value)] where @ refers to the current element being evaluated.

Numeric comparison

// Input
{
  "products": [
    { "name": "Widget", "price": 25 },
    { "name": "Gadget", "price": 75 },
    { "name": "Gizmo", "price": 150 }
  ]
}

// Filter products cheaper than $100
$.products[?(@.price < 100)]
→ [{"name":"Widget","price":25}, {"name":"Gadget","price":75}]

// Filter products $75 or more
$.products[?(@.price >= 75)]
→ [{"name":"Gadget","price":75}, {"name":"Gizmo","price":150}]

String comparison

// Filter by exact string match
$.store.books[?(@.category == "fiction")]
→ Books in the fiction category

// Filter by not equal
$.store.books[?(@.category != "programming")]
→ Books NOT in the programming category

Existence check

// Filter elements that have an "email" field
$.users[?(@.email)]
→ Only users that have an email property

Supported operators

• == — equal to (strings and numbers)
• != — not equal to
• > — greater than
• < — less than
• >= — greater than or equal
• <= — less than or equal
• @.field (no operator) — existence check

JSONPath wildcard and recursive descent

Wildcards and recursive descent are the most powerful JSONPath features for searching across complex, deeply nested JSON structures.

Wildcard ([*])

The wildcard [*] matches all elements at the current level:

// Get all elements of an array
$[*]                    → all top-level elements

// Get a field from every array element
$.store.books[*].title  → ["The Great Gatsby", "Clean Code", "Design Patterns", "1984"]

// Get all values of an object
$.store.*               → [books_array, bicycle_object]

Recursive descent (..)

The recursive descent operator .. searches for a key at any depth in the JSON tree:

// Find ALL "price" values anywhere in the document
$..price
→ [12.99, 33.49, 41.99, 9.99, 199.95]

// Find all prices under "store" only
$.store..price
→ [12.99, 33.49, 41.99, 9.99, 199.95]

// Find all "title" values anywhere
$..title
→ ["The Great Gatsby", "Clean Code", "Design Patterns", "1984"]

Practical use cases

• API response extraction — $..id collects all IDs from a nested API response without knowing the exact structure.
• Config file search — $..host finds all host configurations across multiple environments.
• Data validation — $..email extracts all email fields to check for valid formats.
• Error log parsing — $..error finds all error messages in a structured log.

JSONPath vs jq vs SQL for querying JSON

Different tools for different needs. Here is how JSONPath compares to jq and SQL for common JSON querying tasks.

Same query in all three syntaxes

// Task: Get titles of books cheaper than $15

// JSONPath
$.store.books[?(@.price < 15)].title

// jq
.store.books[] | select(.price < 15) | .title

// SQL (jsonsql.dev SQL mode)
SELECT title FROM store.books WHERE price < 15

Try the SQL query mode or MongoDB query mode on jsonsql.dev for more advanced querying.

JSONPath in different languages

JSONPath is supported across all major programming languages. Here are code snippets showing how to evaluate JSONPath expressions in each.

JavaScript (jsonpath-plus)

import { JSONPath } from 'jsonpath-plus';

const data = { store: { books: [{ title: 'Gatsby', price: 12.99 }] } };
const result = JSONPath({ path: '$.store.books[*].title', json: data });
console.log(result); // ["Gatsby"]

Python (jsonpath-ng)

from jsonpath_ng.ext import parse

data = {"store": {"books": [{"title": "Gatsby", "price": 12.99}]}}
expr = parse("$.store.books[*].title")
result = [m.value for m in expr.find(data)]
print(result)  # ["Gatsby"]

Java (Jayway JsonPath)

import com.jayway.jsonpath.JsonPath;

String json = "{\"store\":{\"books\":[{\"title\":\"Gatsby\"}]}}";
List<String> titles = JsonPath.read(json, "$.store.books[*].title");
System.out.println(titles); // ["Gatsby"]

Command line (jq equivalent)

# jq uses a different syntax but achieves the same result
cat data.json | jq '.store.books[].title'
# Output: "Gatsby"

# For JSONPath-compatible CLI, use jsonpath-cli (Node.js):
npx jsonpath-cli '$.store.books[*].title' data.json

Related tools

Frequently asked questions