How to Test JSONPath Expressions (With Examples)

What Is JSONPath?

JSONPath is a query language for JSON data, similar to how XPath works for XML. It allows you to extract specific values, arrays, or nested objects from a JSON document using a concise expression syntax. JSONPath was originally proposed by Stefan Goessner in 2007 and has since become a widely adopted standard for querying JSON data in programming languages, APIs, and data processing tools.

When working with large or deeply nested JSON responses from APIs, JSONPath lets you pinpoint exactly the data you need without writing custom traversal code. Instead of navigating through multiple levels of objects and arrays manually, you write a single expression that describes the path to the desired data.

JSONPath Syntax Basics

JSONPath expressions always start with $, which represents the root of the JSON document. From there, you use dots and brackets to navigate into the structure. Here are the fundamental operators:

$          — The root object/element
.key       — Child operator (dot notation)
['key']    — Child operator (bracket notation)
..         — Recursive descent (search all levels)
*          — Wildcard (all objects/elements)
[n]        — Array index (0-based)
[start:end] — Array slice
[?(@.expr)] — Filter expression
@          — Current node (used in filters)

Let's use this sample JSON document to demonstrate each operator:

{
  "store": {
    "name": "Tech Books",
    "books": [
      {
        "title": "Clean Code",
        "author": "Robert C. Martin",
        "price": 33.99,
        "tags": ["programming", "best-practices"]
      },
      {
        "title": "The Pragmatic Programmer",
        "author": "David Thomas",
        "price": 42.50,
        "tags": ["programming", "career"]
      },
      {
        "title": "Design Patterns",
        "author": "Gang of Four",
        "price": 39.99,
        "tags": ["programming", "architecture"]
      }
    ]
  }
}

Common JSONPath Examples

Accessing Nested Properties

To get the store name, use dot notation to navigate through the object hierarchy:

$.store.name
// Result: "Tech Books"

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

$.store.books[2].price
// Result: 39.99

Using Wildcards

The wildcard operator * selects all elements at the current level. Combined with array indexing, it is very powerful:

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

$.store.books[*].price
// Result: [33.99, 42.50, 39.99]

Array Slicing

Array slicing lets you select a range of elements from an array, similar to Python's slice syntax:

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

$.store.books[-1:].title
// Result: ["Design Patterns"]  (last element)

Filter Expressions

Filters let you select elements based on conditions. The @ symbol refers to the current element being evaluated:

$.store.books[?(@.price < 40)]
// Result: books with price less than 40

$.store.books[?(@.author == 'David Thomas')]
// Result: [{ "title": "The Pragmatic Programmer", ... }]

$.store.books[?(@.tags[0] == 'programming')]
// Result: all books (all have "programming" as first tag)

Recursive Descent

The recursive descent operator .. searches through all levels of the JSON document. This is useful when you know the key name but not its exact location in the hierarchy:

$..title
// Result: ["Clean Code", "The Pragmatic Programmer", "Design Patterns"]

$..price
// Result: [33.99, 42.50, 39.99]

$..tags
// Result: [["programming","best-practices"], ["programming","career"], ...]

JSONPath vs XPath

JSONPath was directly inspired by XPath, and many concepts translate between the two. The root element in XPath is / while in JSONPath it is $. Child access in XPath uses / while JSONPath uses . or []. Recursive descent is // in XPath and .. in JSONPath. Predicates use [condition] in XPath and [?(expression)] in JSONPath.

The key difference is that XPath is designed for the tree structure of XML (with attributes, namespaces, and text nodes), while JSONPath is designed for the simpler object-and-array structure of JSON. If you already know XPath, learning JSONPath will feel natural — the concepts are the same, just with different syntax.

How to Use the PulpMiner JSONPath Tester

Paste your JSON data into the input editor on the left side. Enter your JSONPath expression in the query field at the top. The tool evaluates the expression in real time and displays the matching results on the right side. If the expression is invalid, you will see an error message explaining what went wrong.

The tester highlights the matched nodes in the original JSON, making it easy to verify that your expression is selecting the right data. This visual feedback is especially helpful when writing complex filter expressions or when working with deeply nested structures where it is hard to trace the path manually.

Practical Use Cases

JSONPath is used in many real-world scenarios. API testing tools like Postman use JSONPath to extract values from API responses for assertions. Data processing pipelines use JSONPath to extract specific fields from large JSON documents. Configuration management tools use JSONPath to query and modify JSON config files. Monitoring systems use JSONPath to extract metrics from JSON log entries and webhook payloads.

When you are building a JSONPath expression for production use, it is essential to test it against sample data first. PulpMiner's JSONPath Tester lets you iterate quickly — paste your JSON, try different expressions, and see results instantly. Once you have the right expression, you can confidently use it in your code or configuration.

Try the JSONPath Tester