JSONPath is a query language for extracting values from JSON data, analogous to XPath for XML. It was originally described by Stefan Goessner in 2007. A JSONPath expression navigates a JSON structure using path syntax: $ represents the root, dots navigate to child keys, square brackets access array elements, and special operators like .. (recursive descent) and * (wildcard) select multiple values at once. For example, $.store.books[0].title selects the title of the first book inside the store object. JSONPath is used in APIs, test frameworks, JSON Schema validators, and data processing tools to extract specific values without writing custom traversal code.

How do I get all values of a key at any depth in JSONPath?

Use the recursive descent operator .. (two dots) followed by the key name. For example, $..title selects all "title" values anywhere in the entire JSON document, regardless of how deeply they are nested. $..price selects all "price" values at any depth. This is useful for searching hierarchical data where the same key appears at multiple levels. The result is an array of all matching values. The recursive descent can be combined with filters: $..books[?(@.price > 30)] finds all books at any depth where price exceeds $30. Note that implementation support for recursive descent varies across JSONPath libraries.

JSONPath Cheat Sheet: Syntax and Examples

Q: What is the difference between $ and @ in JSONPath?

$ refers to the root of the JSON document — it is the starting point of every JSONPath expression. @ refers to the current node being evaluated, and is used inside filter expressions. For example, in $.store.books[?(@.price < 40)], the $ selects the root, navigates to store.books, and the filter expression [?(@.price < 40)] uses @ to refer to each book element being tested. Outside of filter expressions, @ is not used. You always start a JSONPath expression with $, and use @ only inside [?(...)] filter predicates to refer to the current array element.

Q: How do I filter an array with JSONPath?

Use a filter expression in the form [?(@.key operator value)]. The @ refers to each array element, and you write a condition like a comparison. Examples: $.books[?(@.price < 30)] selects books cheaper than $30. $.books[?(@.inStock == true)] selects books that are in stock. $.books[?(@.author == "Alice")] selects books by Alice. Multiple conditions can be combined with && (AND) or || (OR): $.books[?(@.price < 50 && @.inStock == true)]. The filter returns all elements that satisfy the condition. Not all implementations support all operators — string matching with =~ (regex) is not universally supported.

Q: What is the JSONPath wildcard selector?

The wildcard * selects all elements at a given level. In an object, $.user.* selects all property values of the user object. In an array, $.books[*] selects all elements of the books array. It can be chained: $.books[*].title selects the title of every book. The wildcard is useful for collecting all values of a key across items without knowing which items exist. It differs from recursive descent (..) — the wildcard selects all at one level, while .. searches all levels of nesting. For example, $..title finds the title key anywhere in the entire document regardless of depth.

Q: What is the difference between dot notation and bracket notation in JSONPath?

Both dot notation ($.store.name) and bracket notation ($.store["name"]) navigate to the same child key and produce identical results. Dot notation is shorter and more readable for simple key names. Bracket notation is required when key names contain spaces, special characters, or look like numbers: $["my key"] or $["1"]. Array element access uses bracket notation with a number: $.books[0]. You can mix both in a single expression: $.store.books[0]["title"] is equivalent to $.store.books[0].title. Bracket notation with double quotes is the safest choice when keys might have special characters.

Last updated: May 11, 2026

JSONPath is a query language for JSON analogous to XPath for XML — it extracts values using path expressions without parsing the entire document in application code. RFC 9535 (2024) is the current standard; the Stefan Goessner spec (2007) was the de facto standard for 17 years and differs in recursive descent and filter syntax. The 4 core operators are $ (root), . (child), [*] (all array items), and ?(...) (filter expression). Array slices follow Python notation: [0:3] returns elements 0, 1, 2; [-1] returns the last element. This cheatsheet covers all operators, filter expressions with comparison operators, wildcards, array slices, recursive descent (..), the @ current node reference, and key differences between JSONPath and jq.

Test JSONPath expressions online

Paste your JSON and a JSONPath expression to see the extracted values instantly — no install needed.

Open JSONPath Tester

Sample JSON used in examples

{
  "store": {
    "name": "Books & More",
    "books": [
      { "title": "Clean Code", "author": "Robert Martin", "price": 35.99, "inStock": true },
      { "title": "The Pragmatic Programmer", "author": "Hunt & Thomas", "price": 45.00, "inStock": true },
      { "title": "Design Patterns", "author": "Gang of Four", "price": 54.95, "inStock": false },
      { "title": "Refactoring", "author": "Martin Fowler", "price": 42.50, "inStock": true }
    ],
    "location": { "city": "San Francisco", "zip": "94105" }
  }
}

Syntax quick reference

Syntax	Meaning
`$`	Root element
`.key`	Child key (dot notation)
`['key']`	Child key (bracket notation)
`..`	Recursive descent — search all levels
`[*]`	Wildcard — all elements of an array
`[0]`	Array index (zero-based)
`[-1]`	Last element
`[0,2]`	Multiple indexes
`[0:3]`	Slice — elements 0, 1, 2
`[?(@.key)]`	Filter — elements where key exists
`[?(@.key == val)]`	Filter — elements where key equals val
`[?(@.key > val)]`	Filter — elements where key > val

Examples

Basic property access

$.store.name
→ "Books & More"

$.store.location.city
→ "San Francisco"

$.store.location['zip']
→ "94105"

Array access

$.store.books[0].title
→ "Clean Code"

$.store.books[-1].title
→ "Refactoring"

$.store.books[1].price
→ 45.00

Wildcard — all elements

$.store.books[*].title
→ ["Clean Code", "The Pragmatic Programmer", "Design Patterns", "Refactoring"]

$.store.books[*].price
→ [35.99, 45.00, 54.95, 42.50]

Array slices

$.store.books[0:2].title
→ ["Clean Code", "The Pragmatic Programmer"]

$.store.books[2:].title
→ ["Design Patterns", "Refactoring"]

Multiple indexes

$.store.books[0,3].title
→ ["Clean Code", "Refactoring"]

Recursive descent

$..title
→ ["Clean Code", "The Pragmatic Programmer", "Design Patterns", "Refactoring"]

$..price
→ [35.99, 45.00, 54.95, 42.50]

Filter expressions

// Books that are in stock
$.store.books[?(@.inStock == true)].title
→ ["Clean Code", "The Pragmatic Programmer", "Refactoring"]

// Books cheaper than $40
$.store.books[?(@.price < 40)].title
→ ["Clean Code"]

// Books $40 or more
$.store.books[?(@.price >= 40)].title
→ ["The Pragmatic Programmer", "Design Patterns", "Refactoring"]

Combining conditions

// In-stock books under $50
$.store.books[?(@.inStock == true && @.price < 50)].title
→ ["Clean Code", "The Pragmatic Programmer", "Refactoring"]

Implementation differences

JSONPath was originally described by Stefan Goessner in 2007 with no formal standard. Different libraries implement it differently. Common variation points:

Negative indexes — [-1] works in most implementations but not all.
Regex filters — =~ operator is not universally supported.
RFC 9535 — A formal JSONPath standard was published in 2024. New libraries may behave differently from older ones.

JSONPath vs jq

jq is a command-line JSON processor with its own more powerful query language. Use JSONPath when embedding queries in application code or config files. Use jq for shell scripting and one-off transformations in the terminal.

Test JSONPath expressions live

Paste any JSON and write JSONPath expressions in Jsonic's JSONPath Tester. Results update as you type. Nothing is uploaded.

Open JSONPath Tester

Frequently asked questions

What is JSONPath?

JSONPath is a query language for extracting values from JSON data, analogous to XPath for XML. It uses path expressions starting with $ (root), dots for child navigation, and brackets for array access. Widely used in APIs, test frameworks, and data processing tools.

What is the difference between $ and @ in JSONPath?

$ refers to the root of the JSON document — every expression starts with it. @ refers to the current node inside filter expressions like [?(@.price < 40)]. Outside filters, only $ is used.

How do I filter an array with JSONPath?

Use [?(@.key operator value)]. Example: $.books[?(@.price < 30)] selects books cheaper than $30. Combine conditions with && or ||. Regex matching with =~ is not universally supported across implementations.

What is the JSONPath wildcard selector?

* selects all elements at one level: $.books[*].title gets titles of all books. It differs from .. (recursive descent), which searches all nesting levels rather than just one.

What is the difference between dot notation and bracket notation?

Both navigate to the same key: $.store.name equals $.store["name"]. Bracket notation is required for keys with spaces or special characters. Array elements always use bracket notation: $.books[0].

How do I get all values of a key at any depth?

Use recursive descent: $..title selects all title values anywhere in the document regardless of nesting depth. Combine with filters: $..books[?(@.price > 30)] finds all books at any depth where price exceeds $30.