JSON Search & Filter
Search by key or filter arrays in JSON data
What is JSON?
JSON (JavaScript Object Notation) has become the standard format for data exchange across the web, but real-world JSON payloads are often deeply nested and extensive. A typical REST API response might contain hundreds of fields across multiple levels of nesting — user profiles with embedded addresses, order histories with nested line items, or configuration objects with platform-specific overrides. Finding a specific value in this structure by scanning raw text is tedious and error-prone.
JSON search and filtering tools provide a structured way to query JSON data without writing code. Rather than scrolling through thousands of lines looking for a field called "email," you type the key name and instantly see every occurrence with its full path. Rather than writing a loop to find active users over age 30, you define filter conditions and get the matching subset immediately.
This approach bridges the gap between raw data inspection and programmatic querying. It is faster than writing a throwaway script, more precise than browser find-in-page (which matches text without understanding structure), and more accessible than learning a query language like jq or JSONPath for a quick one-off investigation.
How it works
The key search function performs a depth-first traversal of the parsed JSON tree. At each node, it checks whether the current key matches the search term (case-insensitive by default). When a match is found, the tool records the value along with its full dotted path from the root — for example, "data.users.3.address.zipCode." This path lets you understand exactly where in the structure the value lives, which is critical when the same key name appears at multiple nesting levels.
Dot-notation path resolution works differently: it splits the input path by dots, then walks the JSON tree step by step. Each segment is interpreted as either an object key or an array index (if numeric). The resolver handles both — "users.0.name" accesses the first element of the users array and returns its name field. If any segment along the path does not exist, the tool reports a clear error indicating where the path breaks.
Array filtering evaluates conditions against each element of a target array. The filter parser extracts the field name, operator, and comparison value from the condition string, then iterates over the array testing each element. Items that satisfy all specified conditions are collected into a result array. The comparison engine handles type coercion — numeric strings are compared as numbers when the operator is arithmetic, and string comparisons use locale-aware case folding.
How to use this tool
- Paste your JSON data into the input area. The tool accepts any valid JSON — objects, arrays, or mixed structures of any depth.
- To find all occurrences of a key, type the key name in the search field (e.g., "email" or "status"). Results appear instantly showing every match with its full path and value.
- To access a specific nested value, use dot-notation path syntax (e.g., "data.users.0.name"). Array elements are accessed by numeric index.
- To filter an array, specify the array path and add conditions like "status = active" or "age > 25". Only matching items appear in the results.
- Review the results panel, which shows both the matched values and their paths. Click on a path to see the value in context within the full JSON structure.
- Copy individual results or the entire filtered output for use in debugging, reporting, or further processing.
Examples
Finding all email addresses in an API response
Search for the key "email" across a nested user directory response. The tool finds every email field regardless of depth — top-level user emails, nested contact emails, billing emails — and shows each with its full path like "data.users.5.contacts.0.email" so you can identify which entity each address belongs to.
Filtering active subscriptions from a billing payload
Given an array of subscription objects at the path "data.subscriptions", filter with the condition "status = active" to see only current subscriptions. This is equivalent to writing data.subscriptions.filter(s => s.status === "active") but requires no code.
Extracting configuration values by path
In a large application config JSON, use dot-notation to drill directly to "database.production.connectionString" rather than expanding and scanning the entire configuration tree. The tool returns just the value at that path.
Finding users above a spending threshold
Filter an array of customer objects where "totalSpent > 10000" to identify high-value accounts. Combine with "status = active" to narrow to current customers only. The results show the complete matching objects so you can see all their associated data.
About this tool
Find values by key name or dot-notation path, and filter array items by field conditions. Paste any JSON, search for keys across nested structures, or filter lists by matching criteria — instant results as you type.
Common use cases
- • Finding specific values in deeply nested API responses without scrolling through thousands of lines
- • Filtering arrays of objects by field conditions (e.g., find all users where status is "active")
- • Extracting specific keys from complex JSON structures for reporting or debugging
- • Quickly navigating large configuration files or database exports
Frequently asked questions
- What search syntax does this tool support?
- You can search by key name to find all occurrences across nested structures, or use dot-notation paths (e.g., "user.address.city") to target specific fields. For arrays, you can filter by field conditions.
- Can I search across nested objects and arrays?
- Yes. Key search traverses the entire JSON tree recursively, finding matches at any depth level. Results show the full path to each match for easy navigation.
- Is there a size limit for the JSON input?
- The tool runs in your browser, so it can handle JSON payloads up to several megabytes. Performance depends on your device, but most typical API responses process instantly.
- How does dot-notation path search differ from key search?
- Key search finds every occurrence of a key name anywhere in the JSON tree regardless of its position. Dot-notation path search (e.g., "users.0.address.city") targets a specific location in the hierarchy, following the exact path through nested objects and arrays. Use key search when you know the field name but not where it lives; use path search when you know the exact structure.
- Can I filter arrays by multiple conditions?
- Yes. You can combine conditions on different fields to narrow results — for example, filtering an array of users where status equals "active" and age is greater than 25. Each condition is evaluated against every item in the array, and only items matching all conditions are returned.
- What comparison operators are supported for filtering?
- The filter supports equality (=), inequality (!=), greater than (>), less than (<), greater or equal (>=), less or equal (<=), and contains (for substring matching on string values). Numeric comparisons work on number fields, and string comparisons are case-insensitive by default.