JSONPath Tester
Evaluate JSONPath expressions against JSON data in your browser. Query nested objects and arrays, test selectors, inspect matching values and paths, and copy the results for API debugging, configuration work, and data-processing tasks.
Key Features
Evaluate JSONPath Expressions
Run a JSONPath expression against a parsed JSON document and inspect the values selected by the current evaluator.
Inspect Matching Values
View the number of matches and the extracted values returned by the expression. Results should remain distinguishable even when multiple matches contain identical data.
Show Match Paths
Each result shows its JSONPath, the equivalent JSON Pointer (RFC 6901), and the node type, so you can locate the match in the source document or in another tool.
Common JSONPath Syntax
Use the root selector, child properties, bracket notation, array indexes, wildcards, recursive descent, and simple comparison filters. Slices, unions, regular expressions, and functions are not supported.
Syntax Reference
Open the built-in reference to review the operators this evaluator supports, with examples you can copy into the expression field.
Copy Query or Results
Copy the tested expression, matched values, paths, or result JSON for use in API tests, scripts, configuration, documentation, or debugging.
Browser-Based Evaluation
JSON parsing and JSONPath evaluation happen in your browser. The page does not require an account or upload your document to a remote service.
How to Use
Enter valid JSON
Paste an API response, configuration document, export, or other valid JSON into the input editor. The JSON must parse successfully before a query can run.
Write a JSONPath expression
Start with the root selector $, then add properties, indexes, wildcards, recursive selectors, slices, or filters supported by the current evaluator.
Evaluate the expression
Click Evaluate to run the query. The result distinguishes a valid expression with no matches from an expression that cannot be parsed or is not supported.
Inspect values and locations
Review each matched value together with its concrete path and, when available, its JSON Pointer or node type.
Copy and refine
Copy the expression or selected results for use in code and refine the query incrementally until it returns exactly the nodes you need.
JSONPath Query Example
Use a JSONPath expression to select the title of the first book and compare it with a wildcard query.
{
"store": {
"book": [
{
"title": "Sayings of the Century",
"price": 8.95
},
{
"title": "Sword of Honour",
"price": 12.99
}
]
}
}[
{
"path": "$.store.book[0].title",
"value": "Sayings of the Century"
}
]How to Test JSONPath Expressions Online
What Is JSONPath?
JSONPath is a query syntax for navigating and selecting data from JSON documents. It is commonly used to find nested properties, array items, matching records, and values inside API responses or configuration files.
JSONPath implementations are not all identical. Some tools follow the newer IETF JSONPath RFC 9535, while others implement older or library-specific dialects. A reliable tester should identify the syntax it supports rather than implying that every JSONPath expression works everywhere.
How to Use a JSONPath Tester
- Enter JSON: Paste a valid JSON object or array into the document editor.
- Write an expression: Start with
$and add property names, array indexes, wildcards, recursive selectors, slices, or filters supported by the evaluator. - Evaluate: Run the query against the parsed document.
- Classify the result: Determine whether the expression is invalid, valid but has no matches, or returns one or more nodes.
- Inspect paths: Review the concrete path, JSON Pointer, value, and node type when available.
- Copy the query: Reuse the tested expression in application code, API tests, a pipeline, or documentation.
Common JSONPath Expressions
$: Select the root document.$.user.name: Select a nested property with dot notation.$["user-name"]: Select a property whose name requires bracket notation.$.items[0]: Select the first item in an array.$.items[*].id: Select the id property from every item.$..price: Search for price properties recursively.$.items[?(@.price > 10)]: Filter items when predicate syntax is supported.
Dot Notation and Bracket Notation
Dot notation is concise for ordinary property names:
$.store.book[0].titleBracket notation is useful for property names containing spaces, hyphens, punctuation, or characters that are not convenient in an identifier:
$["user profile"]["display-name"]Use the notation supported by the evaluator and quote property names exactly as they appear in the JSON.
Wildcards, Recursive Descent, and Slices
A wildcard selects multiple children, while recursive descent searches below the current location. Array slices select a range when supported:
*: Match children or array items...: Search descendants recursively.[0:3]: Select a slice when the evaluator supports slice syntax.
Recursive queries can return many nodes, especially in large documents. Review match paths rather than assuming that every value with the same key belongs to the same logical object.
Filter Expressions
Filters let you select array items based on a condition, such as:
$.store.book[?(@.price < 10)].titleFilter syntax and available functions vary between JSONPath implementations. Comparisons involving missing properties, null values, strings, and numbers should be tested against the actual evaluator.
Match Values Are Not Enough
Two nodes can return the same value but represent different locations:
{"users":[{"id":1},{"id":1}]}A useful result view should show both the value and its path, such as $.users[0].id and $.users[1].id. An RFC 6901 JSON Pointer can provide another precise location format for integration with tools that use JSON Patch or pointer-based updates.
Invalid Expression vs No Match
These results are different:
- Invalid expression: The parser cannot understand the query or the evaluator does not support part of its syntax.
- No match: The expression is valid but does not select a node in the current document.
- Successful match: One or more values or nodes were selected.
Keeping these states separate makes debugging much faster. A syntax error should be fixed in the expression, while a no-match result usually requires checking property names, array indexes, document structure, or filter conditions.
JSONPath and JSON Pointer
JSONPath is a query language that can select multiple nodes. JSON Pointer, defined by RFC 6901, identifies one location using slash-separated tokens such as /users/0/name. They solve different problems and should not be presented as interchangeable syntax.
JSONPath in API Testing
JSONPath is useful for checking API responses, extracting fields, and writing assertions. For example, a test can verify that $.data.items[*].id returns expected identifiers. The exact expression syntax must match the API testing tool or library used by the project.
Implementation and Compatibility
Before copying a query into production code, test it in the target library. A query that works in a browser tester may fail in a tool that uses a different JSONPath dialect, function set, filter syntax, or result model. If the page implements RFC 9535, include the specification version and supported extensions in the reference.
Large JSON Documents
Direct property access is usually cheaper than recursive searches and complex filters. For large documents, result rendering can become as important as evaluation. A Web Worker, lazy filtering, virtualized results, and a result limit can keep the interface responsive.
Browser-Based Privacy
This tester is designed to parse and evaluate JSON in the browser instead of sending the document to a remote service. That is useful for development payloads and private configuration samples, but it is not a secret-management system. Avoid entering credentials, tokens, private customer information, or production secrets into any online tool.
Related Articles
