JSON Path Finder: Query & Extract JSON Data with JSONPath

$.status.containerStatuses[0].restartCount
# Returns: 42

// JSON document
const store = {
  "store": {
    "book": [
      { "category": "reference", "author": "Nigel Rees",       "title": "Sayings",               "price": 8.95  },
      { "category": "fiction",   "author": "Evelyn Waugh",     "title": "Sword of Honour",        "price": 12.99 },
      { "category": "fiction",   "author": "Herman Melville",  "title": "Moby Dick",              "price": 8.99,  "isbn": "0-553-21311-3" },
      { "category": "fiction",   "author": "J. R. R. Tolkien", "title": "The Lord of the Rings",  "price": 22.99, "isbn": "0-395-19395-8" }
    ],
    "bicycle": { "color": "red", "price": 19.95 }
  }
}

// $.store.book[*].author      → All book authors (array)
// ["Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"]

// $..author                   → All authors via recursive descent (same result here)

// $.store.book[2]             → Third book (0-indexed)
// {"category":"fiction","author":"Herman Melville",...}

// $.store.book[-1]            → Last book
// {"author":"J. R. R. Tolkien",...}

// $.store.book[0,1]           → First and second book (union)

// $.store.book[?(@.isbn)]     → Only books with an isbn field
// [Moby Dick, Lord of the Rings]

// $.store.book[?(@.price<10)] → Books under $10
// [Sayings ($8.95), Moby Dick ($8.99)]

// $..price                    → All prices anywhere in doc (books + bicycle)
// [8.95, 12.99, 8.99, 22.99, 19.95]

// $.store.book[*]['title','price']  → Title and price for every book (union in bracket)

// Comparison operators (type-safe — mixing types returns false, not coerced)
$[?(@.price == 8.95)]        // Equal
$[?(@.price != 8.95)]        // Not equal
$[?(@.price < 10)]           // Less than
$[?(@.price >= 10)]          // Greater than or equal
$[?(@.status == "active")]   // String comparison

// Existence test (no operator = boolean — does the key exist?)
$[?(@.isbn)]                 // Items that HAVE an isbn field
$[?([email protected])]                // Items that do NOT have isbn

// Logical operators
$[?(@.price < 10 && @.category == "fiction")]    // AND
$[?(@.price < 10 || @.category == "reference")]  // OR

// RFC 9535 built-in functions
$[?(length(@.title) > 10)]          // length(): string length or array count
$[?(count(@.tags) > 0)]             // count(): number of nodes in nodelist
$[?(match(@.title, "Moby.*"))]      // match(): full-string I-Regexp match
$[?(search(@.title, "Lord"))]       // search(): substring I-Regexp search
// value(): extracts a value from a nodelist for comparison (e.g. nested path)

// Nested path in filter
$[?(@.address.city == "London")]    // Compare nested field
$[?(@.scores[0] >= 90)]             // Compare first array element

import { JSONPath } from 'jsonpath-plus'

const data = {
  users: [
    { id: 1, name: 'Alice', role: 'admin', score: 92, active: true  },
    { id: 2, name: 'Bob',   role: 'user',  score: 74, active: false },
    { id: 3, name: 'Charlie', role: 'admin', score: 88, active: true },
  ]
}

// Extract all names
const names = JSONPath({ path: '$.users[*].name', json: data })
// ['Alice', 'Bob', 'Charlie']

// Filter: active admins only
const activeAdmins = JSONPath({
  path: '$.users[?(@.role=="admin" && @.active==true)]',
  json: data,
})
// [{id:1, name:'Alice',...}, {id:3, name:'Charlie',...}]

// Single value (wrap: false returns first result instead of array)
const topScorer = JSONPath({
  path: '$.users[?(@.score > 90)].name',
  json: data,
  wrap: false,
})
// 'Alice'

// resultType: 'path' — returns the path of each match, not the value
const paths = JSONPath({ path: '$..name', json: data, resultType: 'path' })
// ["$['users'][0]['name']", "$['users'][1]['name']", "$['users'][2]['name']"]

// resultType: 'all' — returns {path, value, parent, parentProperty} for each match
const matches = JSONPath({ path: '$.users[*]', json: data, resultType: 'all' })
matches.forEach(m => console.log(m.path, m.value.name))

from jsonpath_ng import parse
# For filter expressions: import the ext subpackage
from jsonpath_ng.ext import filter  # noqa: F401 — enables [?(...)] support

data = {
    "orders": [
        {"id": "A1", "status": "shipped",   "total": 59.99,  "items": 3},
        {"id": "A2", "status": "pending",   "total": 129.50, "items": 7},
        {"id": "A3", "status": "delivered", "total": 29.99,  "items": 1},
        {"id": "A4", "status": "pending",   "total": 449.00, "items": 12},
    ]
}

# Extract all order IDs
expr = parse("$.orders[*].id")
ids = [m.value for m in expr.find(data)]
# ['A1', 'A2', 'A3', 'A4']

# Filter: pending orders over $100
expr = parse("$.orders[?(@.status == 'pending' & @.total > 100)].id")
large_pending = [m.value for m in expr.find(data)]
# ['A2', 'A4']

# Access full match context: value, path, and parent
expr = parse("$.orders[*]")
for match in expr.find(data):
    print(f"Path: {match.full_path} | Status: {match.value['status']}")
# Path: orders.[0] | Status: shipped
# Path: orders.[1] | Status: pending

# In-place update: set all pending order statuses to 'processing'
expr = parse("$.orders[?(@.status == 'pending')].status")
expr.update(data, "processing")
# data["orders"][1]["status"] == "processing" ✓

package main

import (
    "fmt"
    "github.com/tidwall/gjson"
)

const json = `{
    "users": [
        {"id": 1, "name": "Alice", "role": "admin", "score": 92},
        {"id": 2, "name": "Bob",   "role": "user",  "score": 74},
        {"id": 3, "name": "Charlie","role":"admin",  "score": 88}
    ]
}`

func main() {
    // gjson uses dot notation — no $ prefix, simpler than JSONPath
    name := gjson.Get(json, "users.0.name")
    fmt.Println(name.String()) // "Alice"

    // Array wildcard: #.field
    names := gjson.Get(json, "users.#.name")
    fmt.Println(names)         // ["Alice","Bob","Charlie"]

    // Filter with #[condition]# syntax (not RFC 9535)
    admins := gjson.Get(json, `users.#[role=="admin"]#`)
    admins.ForEach(func(_, v gjson.Result) bool {
        fmt.Println(v.Get("name").String())
        return true
    })
    // Alice, Charlie

    // GetMany: extract multiple paths in one pass (efficient for large JSON)
    results := gjson.GetMany(json, "users.0.name", "users.0.role", "users.#")
    fmt.Println(results[0], results[1], results[2])
    // "Alice" "admin" 3
}

// gjson is ~5-10× faster than encoding/json for extraction because
// it does not unmarshal the entire document. Trade-off: gjson uses
// its own path syntax, not RFC 9535.
//
// For RFC 9535-compatible JSONPath in Go: github.com/PaesslerAG/jsonpath

// Goal: get names of all active users from a JSON document

// JSONPath (RFC 9535) — use in app code (Node.js, Python, Go)
$.users[?(@.active == true)].name

// JMESPath — use in AWS CLI or AWS SDK --query flag
users[?active == `true`].name

// jq — use in bash scripts and CI/CD
# echo "$JSON" | jq '[.users[] | select(.active == true) | .name]'

// JSONata — use in IBM App Connect / Node-RED flows
users[active = true].name

# Get all pod names in a namespace
kubectl get pods -o jsonpath='{.items[*].metadata.name}'

# Get pods that are Running (filter by phase)
kubectl get pods -o jsonpath='{.items[?(@.status.phase=="Running")].metadata.name}'

# Get restart count for first container in a specific pod
kubectl get pod my-app-abc123 -o jsonpath='{.status.containerStatuses[0].restartCount}'

# Extract all container images across all pods (with namespace prefix)
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}/{.metadata.name}: {range .spec.containers[*]}{.image} {end}{"
"}{end}'

# NOTE: kubectl uses a pre-RFC 9535 JSONPath variant.
# Filter expression syntax may differ from RFC 9535 in edge cases.

import { JSONPath } from 'jsonpath-plus'
import { test, expect } from 'vitest'

async function fetchOrders(): Promise<unknown> {
  const res = await fetch('/api/orders')
  return res.json()
}

test('all orders have valid status', async () => {
  const data = await fetchOrders()
  const statuses = JSONPath({ path: '$..status', json: data }) as string[]
  const valid = new Set(['pending', 'processing', 'shipped', 'delivered', 'cancelled'])

  const invalid = statuses.filter(s => !valid.has(s))
  expect(invalid).toHaveLength(0)
})

test('no single order exceeds business limit', async () => {
  const data = await fetchOrders()
  const totals = JSONPath({ path: '$.orders[*].total', json: data }) as number[]
  const oversized = totals.filter(t => t > 10_000)
  expect(oversized).toHaveLength(0)
})

test('every order has at least one line item', async () => {
  const data = await fetchOrders()
  // get count of items in each order
  const itemCounts = JSONPath({ path: '$.orders[*].items', json: data }) as unknown[][]
  const empty = itemCounts.filter(items => items.length === 0)
  expect(empty).toHaveLength(0)
})