JSON Query

How to query JSON online

jsonsql.dev lets you query JSON data instantly in your browser using three powerful syntaxes: Path, SQL, and MongoDB. No data is sent to any server — your JSON stays on your machine.

Path query examples

Dot notation to navigate nested JSON:

// Input
{
  "employees": [
    { "name": "Alice", "age": 32, "department": "Engineering" },
    { "name": "Bob", "age": 28, "department": "Design" },
    { "name": "Carol", "age": 35, "department": "Engineering" }
  ]
}

// Path queries
employees[0].name           → "Alice"
employees[*].name           → ["Alice", "Bob", "Carol"]
employees[age > 30]         → [{ "name": "Alice", ... }, { "name": "Carol", ... }]
employees[department = "Engineering"]  → filters to Engineering staff

SQL query examples

Query JSON arrays using familiar SQL syntax with SELECT, WHERE, ORDER BY, GROUP BY, and aggregate functions:

// Select specific columns
SELECT name, age FROM employees WHERE age > 30

// Aggregate functions
SELECT department, COUNT(*) as count, AVG(salary) as avg_salary
FROM employees
GROUP BY department

// Sorting and limiting
SELECT name, salary FROM employees ORDER BY salary DESC LIMIT 5

// LIKE and IN operators
SELECT * FROM employees WHERE name LIKE "A%"
SELECT * FROM employees WHERE department IN ("Engineering", "Design")

MongoDB query examples

Use MongoDB-style query operators on JSON arrays:

// Simple match
{ "department": "Engineering" }

// Comparison operators
{ "salary": { "$gte": 100000 } }
{ "age": { "$gt": 25, "$lt": 40 } }

// $in operator
{ "department": { "$in": ["Engineering", "Design"] } }

// With sort and limit
{ "$query": { "department": "Engineering" }, "$sort": { "salary": -1 }, "$limit": 5 }

Features

• Three query modes: Path (dot notation), SQL (SELECT/WHERE/GROUP BY), and MongoDB ($gt, $in, $sort)
• Path mode supports wildcards (employees[*].name) and array filters ([age > 30])
• SQL mode supports SELECT, FROM, WHERE, ORDER BY, LIMIT, GROUP BY with aggregate functions (COUNT, SUM, AVG, MIN, MAX)
• MongoDB mode supports $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, plus $sort, $limit, $skip, $project
• Results displayed as formatted tables for tabular data, or syntax-highlighted JSON
• Shows row count and query execution time
• Built-in sample data to try queries immediately
• Works offline — no internet needed after the page loads
• 100% client-side — no data is ever sent to any server

JSON query syntax guide

jsonsql.dev lets you query JSON using three familiar syntaxes — JSONPath dot notation, SQL SELECT statements, and MongoDB-style queries — all running entirely in your browser.

PATH syntax reference

Path mode uses dot notation and bracket notation to navigate JSON structures. It is the fastest way to extract specific values from deeply nested data.

• Dot notation — employees[0].name accesses the name field of the first employee.
• Bracket notation — ["field name"] lets you access keys that contain spaces or special characters.
• Wildcards — employees[*].name returns an array of all name values across every element.
• Array filters — employees[age > 30] filters elements using comparison operators (=, !=, >, <, >=, <=).

// Sample data
{
  "company": {
    "employees": [
      { "name": "Alice", "age": 32, "role": "Lead" },
      { "name": "Bob", "age": 28, "role": "Developer" },
      { "name": "Carol", "age": 35, "role": "Architect" }
    ]
  }
}

// Example 1: Nested dot notation
company.employees[0].name
→ "Alice"

// Example 2: Wildcard to extract all values
company.employees[*].role
→ ["Lead", "Developer", "Architect"]

// Example 3: Filter with comparison
company.employees[age >= 30]
→ [{ "name": "Alice", "age": 32, ... }, { "name": "Carol", "age": 35, ... }]

// Example 4: Bracket notation for special keys
company["employees"][0]["name"]
→ "Alice"

SQL syntax reference

SQL mode lets you query JSON arrays using the same SELECT statements you already know from relational databases. Supported clauses: SELECT, FROM, WHERE, GROUP BY, ORDER BY, and LIMIT. Aggregate functions include COUNT, SUM, AVG, MIN, and MAX.

// Sample data
{
  "orders": [
    { "id": 1, "customer": "Alice", "product": "Laptop", "amount": 1200, "status": "shipped" },
    { "id": 2, "customer": "Bob", "product": "Phone", "amount": 800, "status": "pending" },
    { "id": 3, "customer": "Alice", "product": "Tablet", "amount": 450, "status": "shipped" },
    { "id": 4, "customer": "Carol", "product": "Laptop", "amount": 1200, "status": "delivered" }
  ]
}

// Example 1: SELECT with WHERE
SELECT customer, product, amount FROM orders WHERE amount > 500
→ [{ "customer": "Alice", "product": "Laptop", "amount": 1200 }, ...]

// Example 2: GROUP BY with aggregate
SELECT customer, COUNT(*) as total_orders, SUM(amount) as total_spent
FROM orders GROUP BY customer
→ [{ "customer": "Alice", "total_orders": 2, "total_spent": 1650 }, ...]

// Example 3: ORDER BY + LIMIT
SELECT product, amount FROM orders ORDER BY amount DESC LIMIT 2
→ [{ "product": "Laptop", "amount": 1200 }, { "product": "Laptop", "amount": 1200 }]

// Example 4: LIKE and IN operators
SELECT * FROM orders WHERE status IN ("shipped", "delivered")
SELECT * FROM orders WHERE customer LIKE "A%"

MongoDB syntax reference

MongoDB mode uses JSON-based query objects with operators familiar to MongoDB developers. Comparison operators: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin. Logical operators: $and, $or. Result shaping: $sort, $limit, $project.

// Sample data
{
  "products": [
    { "name": "Widget", "price": 25, "category": "Tools", "rating": 4.5 },
    { "name": "Gadget", "price": 75, "category": "Electronics", "rating": 3.8 },
    { "name": "Gizmo", "price": 150, "category": "Electronics", "rating": 4.9 },
    { "name": "Doohickey", "price": 10, "category": "Tools", "rating": 4.2 }
  ]
}

// Example 1: Simple equality match
{ "category": "Electronics" }
→ [{ "name": "Gadget", ... }, { "name": "Gizmo", ... }]

// Example 2: Comparison operators
{ "price": { "$gte": 25, "$lte": 100 } }
→ [{ "name": "Widget", "price": 25, ... }, { "name": "Gadget", "price": 75, ... }]

// Example 3: $or logical operator
{ "$or": [{ "category": "Tools" }, { "rating": { "$gte": 4.5 } }] }
→ [{ "name": "Widget", ... }, { "name": "Gizmo", ... }, { "name": "Doohickey", ... }]

// Example 4: Sort, limit, and project
{
  "$query": { "category": "Electronics" },
  "$sort": { "price": -1 },
  "$limit": 1,
  "$project": { "name": 1, "price": 1 }
}
→ [{ "name": "Gizmo", "price": 150 }]

JSONPath vs SQL vs MongoDB: which query syntax to use

Each query syntax has strengths. Choose the one that matches your task:

• PATH — best for quickly extracting a specific value or navigating deeply nested structures. If you know exactly where the data lives, dot notation is the fastest way to get there.
• SQL — best for filtering, sorting, and aggregating arrays of objects. If your JSON looks like database rows and you want GROUP BY with COUNT/SUM/AVG, SQL is the natural choice.
• MongoDB — best for complex nested filter conditions with logical operators ($and, $or). If you are already familiar with MongoDB queries, this mode feels like home.

Real-world JSON query examples

Practical examples using a realistic dataset. Paste this sample data into jsonsql.dev and try each query:

// Sample data for all examples below
{
  "employees": [
    { "name": "Alice", "age": 32, "department": "Engineering", "salary": 125000 },
    { "name": "Bob", "age": 28, "department": "Design", "salary": 95000 },
    { "name": "Carol", "age": 35, "department": "Engineering", "salary": 140000 },
    { "name": "David", "age": 41, "department": "Marketing", "salary": 110000 },
    { "name": "Eve", "age": 26, "department": "Engineering", "salary": 105000 },
    { "name": "Frank", "age": 38, "department": "Design", "salary": 115000 },
    { "name": "Grace", "age": 30, "department": "Marketing", "salary": 98000 },
    { "name": "Hank", "age": 45, "department": "Engineering", "salary": 155000 }
  ]
}

Find all users older than 30

// PATH
employees[age > 30]
→ [{ "name": "Alice", "age": 32, ... }, { "name": "Carol", "age": 35, ... },
   { "name": "David", "age": 41, ... }, { "name": "Frank", "age": 38, ... },
   { "name": "Hank", "age": 45, ... }]

// SQL
SELECT name, age FROM employees WHERE age > 30 ORDER BY age
→ Alice (32), Carol (35), Frank (38), David (41), Hank (45)

// MongoDB
{ "age": { "$gt": 30 } }
→ same 5 employees

Get average salary by department

// SQL (best syntax for aggregation)
SELECT department, COUNT(*) as headcount, AVG(salary) as avg_salary,
       MIN(salary) as min_salary, MAX(salary) as max_salary
FROM employees GROUP BY department

→ Engineering:  headcount=4, avg_salary=131250, min=105000, max=155000
→ Design:       headcount=2, avg_salary=105000, min=95000, max=115000
→ Marketing:    headcount=2, avg_salary=104000, min=98000, max=110000

Find employees with salary between $100K and $130K

// PATH
employees[salary >= 100000]
// then visually filter (PATH has single-condition filters)

// SQL
SELECT name, department, salary FROM employees
WHERE salary >= 100000 AND salary <= 130000
ORDER BY salary DESC
→ [{ "name": "Alice", "salary": 125000 }, { "name": "Frank", "salary": 115000 },
   { "name": "David", "salary": 110000 }, { "name": "Eve", "salary": 105000 }]

// MongoDB
{ "salary": { "$gte": 100000, "$lte": 130000 } }
→ same 4 employees

Get top 5 highest-paid employees

// SQL
SELECT name, department, salary FROM employees
ORDER BY salary DESC LIMIT 5
→ Hank (155000), Carol (140000), Alice (125000), Frank (115000), David (110000)

// MongoDB
{
  "$query": {},
  "$sort": { "salary": -1 },
  "$limit": 5,
  "$project": { "name": 1, "department": 1, "salary": 1 }
}
→ same top 5

Querying JSON without installing anything

The most popular command-line tool for querying JSON is jq. It is powerful but requires installation, terminal access, and learning a unique filter syntax. jsonsql.dev provides the same core capabilities directly in your browser with syntaxes you already know.

For quick, one-off queries on API responses or config files, jsonsql.dev is faster than installing jq. For automated pipelines and shell scripts, jq remains the right tool.

jq vs jsonsql.dev examples

// Task: Get names of employees older than 30

// jq (CLI)
cat data.json | jq '.employees[] | select(.age > 30) | .name'

// jsonsql.dev — PATH mode
employees[age > 30]
// then: employees[*].name (to extract names only)

// jsonsql.dev — SQL mode
SELECT name FROM employees WHERE age > 30

// jsonsql.dev — MongoDB mode
{ "age": { "$gt": 30 } }

// Task: Count employees per department

// jq (CLI)
cat data.json | jq '.employees | group_by(.department) | map({department: .[0].department, count: length})'

// jsonsql.dev — SQL mode
SELECT department, COUNT(*) as count FROM employees GROUP BY department

JSON Query vs other tools

Related tools

Frequently asked questions