Developer14 min read
JSON Path Finder Online: How to Query JSON with JSONPath Expressions
Tags:JSONPathJSONDeveloper ToolsData ExtractionAPI Development
Loading math content...
Paste your JSON into FindUtils' free JSON Path Finder, type a JSONPath expression like $.users[0].name, and see the matched values instantly — no installation, no signup, no data uploaded to servers. The tool evaluates your expression in real time, shows the extracted results as formatted JSON, and displays every resolved path so you can copy them with a single click.
JSONPath is a query language for JSON, often described as "XPath for JSON." It lets you navigate complex nested structures, filter arrays by conditions, and extract exactly the data you need using a concise expression syntax. This guide covers everything from basic dot notation to advanced filter expressions, with practical examples you can test directly in the playground.
JSONPath is a standardized query language (formalized as RFC 9535 in February 2024) that lets you select and extract specific values from JSON documents. Every expression starts from the root ($) and uses a combination of dot notation, bracket notation, wildcards, and filters to navigate to target data.
Here's why developers use JSONPath daily:
JSONPath is supported natively by Postman, JMeter, Jayway (Java), AWS Step Functions, Kubernetes, and dozens of other tools. Learning the syntax once lets you use it everywhere.
Navigate to FindUtils' JSON Path Finder. You'll see a query bar at the top and two panels below: JSON Input on the left and Result on the right. Paste your JSON data into the input panel, or click the Load Sample button to start with example data containing users, metadata, and nested objects.
You can also drag and drop a .json file directly into the input panel. The tool accepts any valid JSON — objects, arrays, strings, or numbers.
Type your JSONPath expression in the query bar. The default expression is $, which returns the entire document. Build from there:
$.users — Access the "users" array$.users[0] — Get the first user$.users[*].name — Get all user names$.users[?(@.age>25)] — Filter users older than 25Results update in real time as you type. The match count and execution time are displayed next to the query bar.
Click the Examples button to browse 19 categorized JSONPath queries:
..Click any example to load it into the query bar instantly.
When your expression returns results, the resolved paths appear as clickable chips above the output (e.g., $.users[0].name, $.users[1].name). Click any path to copy it to your clipboard. This is the core "path finder" functionality — discover the exact path to any value in your JSON.
Use the Copy button to copy the entire result to your clipboard, or click Download JSON to save the output as a file. Press Enter after writing an expression to save it to your query history for quick re-use.
| Expression | Description | Example |
|---|---|---|
$ | Root element | Entire document |
$.field | Dot notation property | $.name → "John" |
$['field'] | Bracket notation property | $['content-type'] → "text/html" |
$.a.b.c | Nested property chain | $.user.address.city → "New York" |
$[0] | Array index (zero-based) | First element |
$[-1] | Negative index | Last element |
Dot notation works for simple property names. Bracket notation handles special characters like hyphens, spaces, or dots in property names.
| Expression | Description | Result |
|---|---|---|
$[*] | All elements of array/object | Every child value |
$.users[*].name | Specific field from every element | ["Alice", "Bob", "Charlie"] |
$[0:3] | Array slice (index 0, 1, 2) | First 3 elements |
$[2:] | Slice from index 2 onwards | Elements from third to end |
$[:3] | First N elements | First 3 elements |
$[1:4] | Range slice | Elements at index 1, 2, 3 |
Wildcards are essential for extracting the same field from every object in an array — one of the most common JSONPath operations.
| Expression | Description |
|---|---|
$..name | All "name" fields at any depth |
$..id | All "id" fields anywhere in the document |
$..price | Every "price" value regardless of nesting |
Recursive descent (..) is JSONPath's most powerful navigation feature. It searches the entire document tree and returns every match, regardless of how deeply nested it is. Use it when you know the field name but not its exact location.
Filters let you select array elements that match a condition. The @ symbol refers to the current element being evaluated.
| Expression | Description |
|---|---|
$[?(@.age > 25)] | Elements where age exceeds 25 |
$[?(@.active == true)] | Elements where active is true |
$[?(@.role == "admin")] | Elements matching a string |
$[?(@.price <= 100)] | Elements where price is 100 or less |
$[?(@.status != "draft")] | Elements not matching a value |
Supported operators: ==, !=, >, <, >=, <=. The right-hand value can be a number, string (in double quotes), boolean (true/false), or null.
Suppose you receive this JSON from a REST API:
{
"data": {
"users": [
{"id": 1, "name": "Alice", "email": "[email protected]", "role": "admin"},
{"id": 2, "name": "Bob", "email": "[email protected]", "role": "user"},
{"id": 3, "name": "Charlie", "email": "[email protected]", "role": "user"}
],
"pagination": {"page": 1, "total": 42}
}
}Common queries you'd run in the JSON Path Finder:
$.data.users[*].name → ["Alice", "Bob", "Charlie"] $.data.users[0].email → "[email protected]" $.data.users[?(@.role=="admin")] → [{"id":1, "name":"Alice", ...}] $.data.pagination.total → 42 $..email → ["[email protected]", "[email protected]", "[email protected]"]
JSON config files for applications, Kubernetes manifests, and infrastructure-as-code templates often have deep nesting:
$.database.connections.primary.host → "db-prod.example.com" $.services[*].port → [8080, 3000, 5432] $.services[?(@.port==8080)].name → ["api-gateway"] $..timeout → [30, 60, 120]
$.products[?(@.price<=50)] → Products under $50 $.products[?(@.inStock==true)] → Available products only $.products[*].category → All category names $..reviews → All reviews from any product
Build tools and test runners output JSON results. JSONPath makes it easy to extract specific metrics:
$.testSuites[*].name → All suite names $.testSuites[?(@.failures>0)] → Suites with failures $..duration → All durations $.summary.totalTests → Total test count
Both JSONPath and jq query JSON data, but they solve fundamentally different problems. JSONPath selects data; jq transforms it.
| Feature | JSONPath | jq |
|---|---|---|
| Purpose | Select and extract values | Select, transform, aggregate, construct |
| Complexity | Query language (like SQL SELECT) | Full programming language |
| Transform data | No — extraction only | Yes — map, reduce, reshape |
| Aggregate | No | Yes — sum, min, max, group_by |
| String operations | No | Yes — split, join, regex |
| Create new JSON | No | Yes — construct arbitrary output |
| Pipe chaining | No | Yes — unlimited pipe operations |
| Ecosystem | Postman, JMeter, AWS, K8s | CLI tools, shell scripts, CI/CD |
| Learning curve | Easy (30 minutes) | Moderate (2-3 hours) |
| Best for | Extracting known values | Data processing and reshaping |
Recommendation: Use JSONPath when you need to locate and extract specific values — especially in tools that already support it (Postman, JMeter, AWS). Use jq (try FindUtils' JQ Playground) when you need to transform, aggregate, or reshape data.
| Feature | FindUtils (Free) | jsonpath.com | jsonpathfinder.com | Site24x7 | jsonpath-evaluator.com |
|---|---|---|---|---|---|
| Price | Free, no signup | Free | Free | Free | Free |
| Real-time evaluation | Yes | Yes | Click-based | Manual | Yes |
| Built-in examples | 19 categorized examples | None | None | Example JSON | None |
| Syntax reference | Embedded + reference panel | None | None | Reference table | Linked docs |
| Query history | Yes (20 queries) | No | No | No | No |
| Matched paths display | Clickable path chips | Path list | Click-to-copy | Path tree | Path panel |
| File upload | Drag & drop | Drag & drop | No | No | No |
| Output export | Copy + JSON download | No | No | No | No |
| Filter expressions | Yes (==, !=, >, <, >=, <=) | Yes | No (no queries) | Yes | Yes |
| Recursive descent | Yes ($..field) | Yes | No | Yes | Yes |
| Privacy | Client-side, nothing uploaded | Unknown | Client-side | Server-side | Client-side |
| RFC 9535 compliance | Partial (common operations) | Yes | N/A | Unknown | Yes |
| Multiple implementations | No | No | No | No | No |
FindUtils' JSON Path Finder is optimized for learning and daily use: 19 built-in examples, a quick-reference panel, query history, and clickable path chips make it the most feature-rich free option for developers who want to test JSONPath expressions quickly. For strict RFC 9535 compliance, jsonpath.com and jsonpath-evaluator.com are good alternatives.
Wrong: .users[0].name (missing $)
Right: $.users[0].name
Every JSONPath expression must start with $ to indicate the root of the document.
Wrong: $.content-type (hyphen breaks dot notation)
Right: $['content-type']
Property names containing hyphens, dots, spaces, or other special characters require bracket notation with quotes.
$[*] and $.. are different:
$.users[*].name — Gets names from the users array only$..name — Gets ALL "name" fields at every level of the documentUse [*] when you know the exact array location. Use .. when you need to search the entire tree.
JSONPath extracts data — it cannot transform it. If you need to rename fields, merge arrays, or calculate aggregates, use jq instead. FindUtils' JQ Playground handles these transformations.
Wrong: $.users[?(@.role==admin)] (unquoted string)
Right: $.users[?(@.role=="admin")]
String values in filter expressions must be wrapped in double quotes. Numbers and booleans (true, false, null) do not need quotes.
JSONPath isn't just a learning exercise — it's embedded in tools developers use daily:
pm.expect(jsonData.users[0].name).to.equal("Alice")kubectl get pods -o jsonpath='{.items[*].metadata.name}'Learning JSONPath syntax in a playground means you can apply it immediately across all these tools.
Q1: What is JSONPath and what is it used for?
A: JSONPath is a query language for JSON documents, standardized as RFC 9535 in 2024. It lets you navigate JSON structures and extract specific values using expressions like $.users[0].name. Developers use it in API testing (Postman, JMeter), infrastructure management (Kubernetes, AWS Step Functions), and data extraction pipelines.
Q2: Is the FindUtils JSON Path Finder free to use? A: Yes. FindUtils' JSON Path Finder is completely free with no signup, no ads, and no usage limits. All processing happens in your browser — your JSON data is never sent to any server.
Q3: What is the difference between JSONPath and jq? A: JSONPath is a query language for extracting values from JSON (like SQL SELECT). jq is a full programming language that can extract, transform, aggregate, and construct new JSON. Use JSONPath for simple data extraction; use jq when you need to reshape or calculate data. Try the FindUtils JQ Playground for jq.
Q4: How do I find the path to a specific value in JSON?
A: Paste your JSON into the FindUtils JSON Path Finder and start with $ to see the full document. Use the Examples button to explore common query patterns. When your expression returns results, the resolved paths appear as clickable chips above the output — click to copy any path instantly.
Q5: What's the best free JSONPath tester online in 2026? A: FindUtils offers one of the most feature-rich free JSONPath testers available. It includes 19 built-in examples, an embedded syntax reference, query history, drag-and-drop file upload, and clickable path chips — all with client-side processing for maximum privacy. For strict RFC 9535 compliance testing, jsonpath.com is also a solid choice.
Q6: Is it safe to paste sensitive JSON into an online tool? A: On FindUtils, yes. All processing happens in your browser using JavaScript — your JSON data is never transmitted to any server. There's no backend, no logging, and no data storage. Verify by checking your browser's network tab while using the tool.
Q7: What JSONPath features does the FindUtils tool support?
A: The tool supports dot notation ($.field), bracket notation ($['key']), array indexing ($[0], $[-1]), array slicing ($[0:3]), wildcards ($[*]), recursive descent ($..field), and filter expressions with comparison operators (==, !=, >, <, >=, <=). This covers the vast majority of real-world JSONPath use cases.
Q8: How do I filter JSON arrays with JSONPath?
A: Use filter expressions with the @ symbol: $.users[?(@.age>25)] returns users older than 25, $.items[?(@.active==true)] returns active items, and $.products[?(@.price<=100)] returns products priced at 100 or less. Test filters instantly in the JSON Path Finder.