Skip to content


MIT 3 1 236
58.1 thousand (month) Oct 15 2019 v1.3.3(8 months ago)
529 5 65 Apache 2.0
1.6.1(2 months ago) Feb 09 2022 29.8 million (month)

jsonquery is a Go library that allows you to parse and extract data from JSON documents using JSONPath expressions. JSONPath is similar to XPath, but it is designed specifically for working with JSON documents.

The jsonquery library allows you to traverse the JSON tree structure and extract values using JSONPath expressions. It provides a simple and intuitive API for querying the JSON data, and it is built on top of the popular jsoniter library.

jsonpath-ng is a Python library for parsing and querying JSON data.
It is a powerful tool for extracting and manipulating data from JSON structures,

The library uses a syntax similar to XPath, which is a well-known language for querying and manipulating XML data, to query and extract data from JSON structures. This makes it familiar and intuitive for many developers who have worked with XML in the past. JSONPath implementation in Python.

JSONPath is a JSON query path language inspired by XPath (path language for querying XML/HTML). For more see the initial syntax proposal.

jsonpath-ng is implemented in pure Python and can be easily extended with additional python functions if needed. Most commonly used JSONPath feature in web scraping is the recursive key lookup ($..key) which is a convenient way to find specific data fields in large datasets.

Example Use

package main

import (


func main() {
  // Parse the JSON string
  doc, err := jsonquery.Parse([]byte(`
      "name": "John Doe",
      "age": 30,
      "address": {
        "street": "Main St",
        "city": "Anytown",
        "state": "CA",
        "zip": "12345"
      "phones": [
  if err != nil {

  // Extract the name
  name := jsonquery.FindOne(doc, "name")
  fmt.Println(name.InnerText())  // "John Doe"

  // Extract the city
  city := jsonquery.FindOne(doc, "")
  fmt.Println(city.InnerText())  // "Anytown"

  // Extract all phone numbers
  phones := jsonquery.Find(doc, "phones[*]")
  for _, phone := range phones {
  // "555-555-5555"
  // "555-555-5556"
from jsonpath_ng import jsonpath, parse

# A robust parser, not just a regex. (Makes powerful extensions possible; see below)
jsonpath_expr = parse('foo[*].baz')

# Extracting values is easy
[match.value for match in jsonpath_expr.find({'foo': [{'baz': 1}, {'baz': 2}]})]
[1, 2]

# Matches remember where they came from
[str(match.full_path) for match in jsonpath_expr.find({'foo': [{'baz': 1}, {'baz': 2}]})]
['foo.[0].baz', 'foo.[1].baz']

# And this can be useful for automatically providing ids for bits of data that do not have them (currently a global switch)
jsonpath.auto_id_field = 'id'
[match.value for match in parse('foo[*].id').find({'foo': [{'id': 'bizzle'}, {'baz': 3}]})]
['foo.bizzle', 'foo.[1]']

# A handy extension: named operators like `parent`
[match.value for match in parse('a.*.b.`parent`.c').find({'a': {'x': {'b': 1, 'c': 'number one'}, 'y': {'b': 2, 'c': 'number two'}}})]
['number two', 'number one']

# You can also build expressions directly quite easily
from jsonpath_ng.jsonpath import Fields
from jsonpath_ng.jsonpath import Slice

jsonpath_expr_direct = Fields('foo').child(Slice('*')).child(Fields('baz'))  # This is equivalent

Alternatives / Similar