UseToolSuite UseToolSuite

JSON Path Finder

Query and filter JSON with JSONPath expressions. Find nested values, extract arrays, and debug complex structures instantly — runs in your browser.

Quick:

What is JSON Path Finder?

JSON Path Finder is a free online tool for querying and filtering JSON data using JSONPath expressions. It helps you navigate deeply nested JSON structures, extract specific values, and debug complex API responses — all without writing any code. Whether you're inspecting a REST API response, filtering configuration data, or exploring a large JSON file, this tool gives you instant results with a clean, readable output. The Path Tree feature maps every value in your JSON to its full path, making it easy to discover the exact JSONPath expression you need.

When to use it?

Use JSON Path Finder when you need to extract specific values from large or deeply nested JSON data. It's especially useful when debugging REST API responses that contain hundreds of fields, when building JSONPath expressions for data pipelines or monitoring tools, or when you need to quickly verify that a particular value exists at a specific path in a JSON document. The filter expression support (e.g., $.books[?(@.price < 20)]) makes it ideal for finding elements that match specific criteria.

Common use cases

Developers use JSON Path Finder to extract user data from authentication API responses, filter product lists by price or category from e-commerce APIs, navigate Kubernetes or Docker configuration files, debug webhook payloads from services like Stripe or GitHub, and build JSONPath expressions for tools like Postman, JMeter, or Grafana. The Path Tree view is particularly valuable for understanding unfamiliar JSON structures from third-party APIs before writing integration code.

JSONPath syntax quick reference

JSONPath uses dot notation and bracket notation to navigate JSON structures. The root element is $, child access uses $.store.book or $['store']['book']. Array indexing is zero-based: $.store.book[0] gets the first book. Wildcards (*) select all children: $.store.book[*].author extracts all authors. The recursive descent operator .. searches all levels: $..price finds every price field regardless of depth. Filter expressions like $.store.book[?(@.price < 10)] select elements matching a condition.

A JSONPath cheat sheet for real queries

Most day-to-day querying uses a small set of operators. Keep this table handy:

ExpressionReturns
$.store.book[0].titleFirst book’s title
$.store.book[*].authorEvery book’s author
$..authorAll author values, any depth
$.store.book[-1]Last book
$.store.book[0:2]First two books (end-exclusive)
$.store.book[?(@.price < 10)]Books cheaper than 10
$..*Every value in the document

The $ is always the root, @ refers to the current element inside a filter, and .. scans recursively at every depth.

The two operators that cause the most confusion

Recursive descent (..) is powerful but blunt — $..author finds every author anywhere in the tree, which is exactly what you want until it returns far more than expected on a large document. Narrow it with a specific key, and prefer an explicit path ($.store.book[*].author) when you know the structure.

Filters (?()) trip people on syntax: the current element must be @ (not $), string comparisons need quotes (?(@.name == 'Jane')), and the operator is == not ===. Get those three right and filters become the most useful tool in the set.

JSONPath, JMESPath, or jq?

They solve overlapping problems with different trade-offs:

  • JSONPath — XPath-style, great for selecting values from API responses; now RFC 9535.
  • JMESPath — also query-focused, with a more consistent spec; used by AWS CLI’s --query.
  • jq — a full command-line language that can transform, reshape, and compute, not just select. Steeper to learn, far more powerful for editing.

If you only need to find values, JSONPath is the simplest. If you need to reshape JSON, that’s jq territory.

Debugging a query that returns nothing

An empty result almost always means a path mismatch, and the usual suspects are: case sensitivity ($.User ≠ $.user), a missing array index (a value inside an array needs [0] or [*]), or the wrong nesting level. Start broad with $.* to list the top-level keys, then walk down level by level. Everything runs locally in your browser, so you can iterate on sensitive API responses without anything leaving your device.

JSON Path Finder Powered by UseToolSuite — free browser tools

JSON Path Finder works on your data locally, without sending a single byte to a server. It's one of the free Format & Convert Tools on UseToolSuite.

Last updated

How to Use This Tool

  1. 1

    Paste your JSON

    Drop in an API response, a config file, or anything else. It stays in your browser — nothing is uploaded.

  2. 2

    Find the path instead of guessing it

    Click "Find Path" to walk the document as a tree, then click the value you want. Its exact JSONPath drops into the expression box and runs immediately. Use the filter to jump straight to a key or a value in a large document.

  3. 3

    Or write the expression yourself

    Type a JSONPath such as $.store.book[?(@.price<20)], or start from one of the quick examples, and press Enter.

  4. 4

    Check what it actually selects

    Click "Explain" to read the expression back in plain English, so an inherited path from someone else's config is not a guessing game.

  5. 5

    Copy or share the result

    Copy the matched JSON, or use Share to produce a link that restores both the data and the expression.

How helpful was this tool?

Click to rate

Embed this tool on your site

Paste this snippet into any HTML page or blog post to embed a live, fully working copy of JSON Path Finder. Free for any use.

Key Concepts

JSONPath

A query language for extracting values from JSON documents, analogous to XPath for XML. JSONPath uses expressions like $.store.book[0].title to navigate nested structures. The root element is $, child properties are accessed with . (dot) or [] (bracket) notation, and special operators include * (wildcard), .. (recursive descent), and ?() (filter expressions). Originally proposed by Stefan Goessner in 2007, JSONPath is now an IETF standard (RFC 9535).

Root Element ($)

The $ symbol represents the root of the JSON document in JSONPath expressions. Every valid JSONPath expression starts with $. For example, $.name accesses the "name" property at the top level of the JSON object. The root element can be an object ({}) or an array ([]), and all subsequent path navigation operates relative to this root.

Recursive Descent (..)

The double-dot operator (..) in JSONPath performs a deep scan of the entire JSON structure, searching for a specified key at all nesting levels. For example, $..author finds every property named "author" regardless of its depth in the document. This is extremely useful for extracting all occurrences of a field from deeply nested or irregular JSON structures, but can return large result sets on complex documents.

Filter Expression (?())

A JSONPath filter expression evaluates a condition against each element and returns only those that match. Written as ?(@.property operator value), where @ represents the current element being evaluated. For example, $.books[?(@.price < 20)] returns all book objects whose price property is less than 20. Comparison operators include ==, !=, <, >, <=, and >=.

Frequently Asked Questions

How do I find the JSONPath of a value without knowing the syntax?

Click "Find Path". The tool renders your JSON as a list of nodes, each one clickable — pick the value you can see and its exact JSONPath is written into the expression box and evaluated straight away. The filter box narrows a large document to the keys or values you type, and shows full paths so you can still tell where each match sits. That is the reverse of a normal JSONPath tester, which needs you to know the expression before you can find anything.

Can it tell me what an existing JSONPath expression does?

Yes — paste it in and click "Explain". The expression is read back as a sentence, so $.store.book[?(@.price<20)] becomes "Start at the root of the document, then take the store property, then take the book property, then keep only the items whose price is less than 20." It covers child access, array indices including negative ones, slices, wildcards, recursive descent and filter comparisons.

What is JSONPath and how does it work?

JSONPath is a query language for JSON, similar to XPath for XML. It uses dot notation ($.store.book[0].title) or bracket notation ($['store']['book'][0]['title']) to navigate and extract values from JSON structures. The root element is always represented by $, and expressions can include wildcards (*), recursive descent (..), array slices ([0:3]), and filter expressions (?(@.price < 10)).

Does this tool support all JSONPath expressions?

This tool supports the most commonly used JSONPath operators: root ($), child (.), recursive descent (..), wildcard (*), array indices ([0]), array slices ([start:end]), and filter expressions (?()). It covers the vast majority of real-world use cases for querying REST API responses and configuration files.

Can I use this tool to query large JSON files?

Yes. All processing happens in your browser, so there are no server-imposed limits. Most modern browsers handle JSON files up to 5–10 MB without performance issues. For very large files (10MB+), the query may take a moment depending on your device.

What is the difference between JSONPath and jq?

JSONPath is a query language designed for JSON navigation in web applications and APIs, using syntax like $.store.book[*].author. jq is a command-line tool for Linux/macOS that provides more powerful transformation capabilities including pipe operators, conditionals, and output formatting. JSONPath is simpler to learn; jq is more powerful but has a steeper learning curve.

Is my JSON data sent to any server?

No. All JSONPath evaluation runs entirely in your browser using JavaScript. Your data never leaves your device, making this tool safe for querying API responses, configuration files, or any sensitive JSON content.

Why does the same JSONPath expression give different results in different tools?

JSONPath was a 2007 proposal, not a formal standard for most of its life, so implementations diverged — especially on edge cases like filter syntax, how the root is handled, whether results are deduplicated, and the behavior of recursive descent. The IETF only standardized it as RFC 9535 in 2024, and not every library conforms yet. Practical consequences: a filter that works in one library may need different quoting in another, and some support script expressions or extensions others don't. When portability matters, stick to the common core (root $, child ., recursive .., wildcard *, index [n], slice [a:b], filter ?()) and test against the specific engine your code will run.

Can JSONPath modify data, or only read it?

JSONPath is a read-only query language — it selects and extracts values from a JSON document but doesn't change them. Think of it like a SELECT, not an UPDATE: $.users[?(@.active)].email returns matching emails, but there's no JSONPath syntax to set or delete them. To modify JSON based on a path, you read the values with JSONPath, then write changes with your programming language (or use a different tool built for transformation, like jq, which has full editing and reshaping capabilities). This tool evaluates queries and shows you what matches, entirely in your browser.

Troubleshooting & Technical Tips

JSONPath returns empty result: No match found for expression

An empty result usually means the path does not exist in the JSON structure. Common causes: (1) Case sensitivity — JSON keys are case-sensitive, so $.User is different from $.user. (2) Missing array index — if a value is inside an array, you need [0] or [*] to access it. (3) Wrong nesting level — use this tool's tree view to visually inspect the JSON structure and find the correct path. Try $.* to see all top-level keys first.

Filter expression syntax error: Unexpected token in ?()

Filter expressions must follow the format ?(@.property operator value). Common mistakes: (1) Missing @ symbol — the current element must be referenced with @, not $. (2) String values must be quoted: ?(@.name == 'John'), not ?(@.name == John). (3) Comparison operators use == (not ===). Example: $.books[?(@.price < 20)] returns all books with price less than 20.

Recursive descent (..) returns too many results

The recursive descent operator (..) searches the entire JSON tree at all levels. If used without a specific key, it returns every value in the document. To narrow results, always follow .. with a specific property name: $..author finds all "author" values at any depth, while $..* returns literally every value. For better precision, use explicit paths where possible: $.store.book[*].author instead of $..author.

Array slice [start:end] behaves unexpectedly

JSONPath array slices follow Python-style conventions: [start:end] is inclusive of start and exclusive of end. So [0:3] returns elements at indices 0, 1, 2 (not 3). Negative indices count from the end: [-1] is the last element, [-2:] returns the last two elements. If you want a single element, use [0] (index) instead of [0:1] (slice). Use [:5] to get the first 5 elements.

Related Guides

GUIDE

JSON: The Complete Developer Guide

Learn everything about JSON — syntax, data types, parsing mechanics, V8 engine optimizations, schema validation, API best practices, and memory management.

JSON Schema Validation: A Practical Guide

Validate JSON with JSON Schema: required fields, type checking, nested objects, conditional schemas, and API integration with Ajv — plus production tips.

Related Tools

JSON Formatter & Validator

Format & Convert Tools

JSON ↔ YAML Converter

Format & Convert Tools

JSON to TypeScript Type Generator

Format & Convert Tools

JSON to CSV Converter

Format & Convert Tools