Home → JSONPath Cheatsheet

JSONPath Cheatsheet: Complete Syntax Reference with Examples (2026)

JSONPath is the standard way to query and extract data from JSON documents. Think of it as SQL for JSON, or XPath for JSON. This cheatsheet covers every operator, expression, and pattern you'll encounter — with real examples for each.

Quick Reference: All JSONPath Operators

Sample JSON for All Examples

All examples below use this JSON document:

{
  "store": {
    "name": "The Book Shop",
    "books": [
      { "title": "Clean Code", "author": "Robert Martin", "price": 29.99, "category": "programming", "tags": ["code", "best-practices"] },
      { "title": "The Pragmatic Programmer", "author": "David Thomas", "price": 35.00, "category": "programming" },
      { "title": "Design Patterns", "author": "GoF", "price": 49.99, "category": "architecture" },
      { "title": "JavaScript: The Good Parts", "author": "Douglas Crockford", "price": 19.99, "category": "javascript" }
    ],
    "manager": { "name": "Jane Doe", "email": "jane@bookshop.com" }
  },
  "currency": "USD"
}

Basic Path Navigation

Access a direct child

$.currency
// Result: "USD"

$.store.name
// Result: "The Book Shop"

$.store.manager.email
// Result: "jane@bookshop.com"

Access array elements by index

$.store.books[0]
// Result: { "title": "Clean Code", "author": "Robert Martin", ... }

$.store.books[0].title
// Result: "Clean Code"

$.store.books[-1].title
// Result: "JavaScript: The Good Parts"  (last element)

Wildcards

The * wildcard matches all children of an element:

$.store.books[*].title
// Result: ["Clean Code", "The Pragmatic Programmer", "Design Patterns", "JavaScript: The Good Parts"]

$.store.books[*].price
// Result: [29.99, 35.00, 49.99, 19.99]

$.store.*
// Result: all values inside store (books array, manager object)

Recursive Descent (..)

The .. operator searches recursively at any depth:

$..title
// Result: all title properties anywhere in the document
// ["Clean Code", "The Pragmatic Programmer", "Design Patterns", "JavaScript: The Good Parts"]

$..name
// Result: ["The Book Shop", "Jane Doe"]  — finds name at any level

$..price
// Result: [29.99, 35.00, 49.99, 19.99]

Array Slicing

Array slices work like Python slices — [start:end:step]:

$.store.books[0:2]
// Result: first 2 books (index 0 and 1)

$.store.books[1:]
// Result: all books from index 1 onwards

$.store.books[:2]
// Result: first 2 books (same as [0:2])

$.store.books[::2]
// Result: every 2nd book (index 0, 2)

$.store.books[-2:]
// Result: last 2 books

Multiple Indexes (Union)

$.store.books[0,3].title
// Result: ["Clean Code", "JavaScript: The Good Parts"]

$.store.books[0]['title','author']
// Result: { "title": "Clean Code", "author": "Robert Martin" }

Filter Expressions

Filter expressions use ?(@.field operator value) syntax. @ refers to the current array item:

Filter by existence

$.store.books[?(@.tags)]
// Result: books that HAVE a tags property
// [{ "title": "Clean Code", ..., "tags": ["code", "best-practices"] }]

Filter by comparison

$.store.books[?(@.price < 30)].title
// Result: ["Clean Code", "JavaScript: The Good Parts"]

$.store.books[?(@.price >= 35)].title
// Result: ["The Pragmatic Programmer", "Design Patterns"]

$.store.books[?(@.price == 19.99)].title
// Result: ["JavaScript: The Good Parts"]

Filter by string equality

$.store.books[?(@.category == "programming")].title
// Result: ["Clean Code", "The Pragmatic Programmer"]

$.store.books[?(@.author != "GoF")].title
// Result: ["Clean Code", "The Pragmatic Programmer", "JavaScript: The Good Parts"]

Multiple conditions (AND / OR)

$.store.books[?(@.price < 40 && @.category == "programming")].title
// Result: ["Clean Code", "The Pragmatic Programmer"]

$.store.books[?(@.price > 45 || @.category == "javascript")].title
// Result: ["Design Patterns", "JavaScript: The Good Parts"]

Bracket Notation vs Dot Notation

JSONPath supports both dot and bracket notation. They are equivalent:

Complete Reference Table

JSONPath in Different Languages

JSONPath is implemented in every major language. Below are copy-paste snippets for JavaScript/Node.js, Python (jsonpath-ng), Java, Go, PHP, C#, and Kotlin — the runtimes developers ask about most. Each uses the same query, $.store.books[*].title, against the sample JSON above so you can compare libraries side by side.

JavaScript / Node.js

// Using jsonpath-plus (npm install jsonpath-plus)
import { JSONPath } from 'jsonpath-plus';

const titles = JSONPath({ path: '$.store.books[*].title', json: data });
// Result: ["Clean Code", "The Pragmatic Programmer", ...]

Python (jsonpath-ng)

jsonpath-ng (imported as jsonpath_ng) is the most widely used JSONPath library for Python. Install it with pip install jsonpath-ng, then parse() your expression once and call .find() to evaluate it against any data:

# Using jsonpath-ng (pip install jsonpath-ng)
from jsonpath_ng import parse

expr = parse('$.store.books[*].title')
matches = [match.value for match in expr.find(data)]
# Result: ["Clean Code", "The Pragmatic Programmer", ...]

# jsonpath-ng also supports the extended filter syntax via jsonpath_ng.ext:
from jsonpath_ng.ext import parse as parse_ext
cheap = parse_ext('$.store.books[?(@.price < 10)].title').find(data)

Note: the base jsonpath_ng.parse covers standard selectors; for filter expressions like ?(@.price<10) use jsonpath_ng.ext. Reusing a parsed expr across calls is faster than re-parsing the string each time.

Java (Spring / Jayway)

// Using Jayway JSONPath (Maven: com.jayway.jsonpath:json-path)
import com.jayway.jsonpath.JsonPath;

List<String> titles = JsonPath.read(json, "$.store.books[*].title");
// Result: ["Clean Code", "The Pragmatic Programmer", ...]

Go

// Using github.com/PaesslerAG/jsonpath
import "github.com/PaesslerAG/jsonpath"

result, _ := jsonpath.Get("$.store.books[*].title", data)

PHP

The standard JSONPath library for PHP is galbar/jsonpath (or the older flow/jsonpath). Install with Composer — composer require galbar/jsonpath — then evaluate expressions against a decoded array:

<?php
// composer require galbar/jsonpath
use JSONPath\JSONPath;

$data = json_decode($json, true);
$titles = (new JSONPath($data))->find('$.store.books[*].title')->getData();
// Result: ["Clean Code", "The Pragmatic Programmer", ...]

// Filter expressions work the same way in PHP:
$cheap = (new JSONPath($data))->find('$.store.books[?(@.price < 10)].title');
?>

C# / .NET

In C#, JSONPath is built into Newtonsoft.Json (Json.NET) via SelectTokens — no extra package beyond Json.NET. System.Text.Json does not support JSONPath natively, so Json.NET remains the standard choice:

// using Newtonsoft.Json.Linq;
JObject root = JObject.Parse(json);

// SelectTokens returns every match for a JSONPath query
var titles = root.SelectTokens("$.store.books[*].title")
                 .Select(t => t.ToString());
// Result: ["Clean Code", "The Pragmatic Programmer", ...]

// SelectToken (singular) returns the first match, or null:
string first = (string)root.SelectToken("$.store.books[0].title");

Kotlin

On the JVM, Kotlin uses the same Jayway JSONPath library as Java. Add com.jayway.jsonpath:json-path to your Gradle dependencies, then read paths directly:

// implementation("com.jayway.jsonpath:json-path:2.9.0")
import com.jayway.jsonpath.JsonPath

val titles: List<String> = JsonPath.read(json, "$.store.books[*].title")
// Result: ["Clean Code", "The Pragmatic Programmer", ...]

// Filter expressions work the same way in Kotlin:
val cheap: List<String> = JsonPath.read(json, "$.store.books[?(@.price < 10)].title")

String Matching in Filters: contains, substring & regex

Beyond == and </> comparisons, most JSONPath engines support string functions inside filter expressions. Support varies by library, so test against your runtime:

There is no single standard for string functions in JSONPath, so =~ regex (the most widely implemented) is the safest way to do "contains", "substring", and "matches" queries. The live evaluator uses regex-style matching so you can confirm an expression before shipping it.

Newlines & Escaping in JSONPath

Two common gotchas when a path or value contains special characters:

• Keys with dots, spaces, or newlines — use bracket notation with quotes instead of dot notation: $['user']['first name'] or $['weird\nkey']. Dot notation ($.user.first name) breaks on anything that isn't a valid identifier.
• Matching newline characters in values — inside a regex filter, match a literal newline with \n: $..[?(@.note =~ /line1\nline2/)]. Remember that in JSON the value itself stores \n as an escaped sequence.
• Escaping quotes — when a string literal in a filter contains a quote, switch the surrounding quote style: [?(@.label == "it's here")].

JSONPath Alternatives

JSONPath is the most common query language for JSON, but it is not the only one. If JSONPath does not fit your use case, these are the main alternatives developers reach for:

Rule of thumb: use JSONPath for ad-hoc extraction with wildcards and filters, JMESPath when you need a stable cross-language spec, jq for shell pipelines, and JSON Pointer when you only need one exact path. You can prototype any JSONPath expression in the live JSONPath evaluator before porting it to your language of choice.

Common JSONPath Patterns

These are the patterns developers use most often:

JSONPath vs XPath Comparison

Frequently Asked Questions

// JSON
{"user": {"name": "Alice", "age": 30, "city": "London"}}

// Basic selectors
$              → entire document
$.user         → {"name":"Alice","age":30,"city":"London"}
$.user.name    → "Alice"
$.user.age     → 30

// JSON
{"items": ["apple", "banana", "cherry"]}

// Array selectors
$.items        → ["apple","banana","cherry"]
$.items[0]     → "apple"
$.items[2]     → "cherry"
$.items[-1]    → "cherry" (last)
$.items[0:2]   → ["apple","banana"] (slice)
$.items[*]     → all items

// JSON with nested structure
{"a": {"b": {"id": 1}}, "c": {"id": 2}, "id": 3}

// Recursive descent
$..id  → [1, 2, 3]  // finds "id" at ALL depths
$..b   → [{"id": 1}]

// JSON
{"products": [
  {"name": "A", "price": 10, "inStock": true},
  {"name": "B", "price": 25, "inStock": false},
  {"name": "C", "price": 15, "inStock": true}
]}

// Filter expressions
$.products[?(@.inStock)]            → A and C objects
$.products[?(@.price < 20)]         → A and C objects
$.products[?(@.name == "B")]        → B object
$.products[?(@.price >= 15)].name   → ["B","C"]

Related Tools & Guides

JSONPath Online Evaluator  |  JSON Schema Tutorial  |  How to Validate JSON  |  JSON vs XML  |  JSON Formatter  |  Full JSON Cheatsheet

// JavaScript (jsonpath-plus)
import { JSONPath } from 'jsonpath-plus';
const results = JSONPath({ path: '$.users[*].email', json: data });

# Python (jsonpath-ng)
from jsonpath_ng import parse
matches = [m.value for m in parse('$.users[*].email').find(data)]

// Java (Jayway JsonPath)
List<String> emails = JsonPath.read(json, "$.users[*].email");

// Go (gjson)
result := gjson.Get(json, "users.#.email")