Unix command-line JSON parser?

Can anyone recommend a Unix (choose your flavor) JSON parser that could be used to introspect values from a JSON response in a pipeline?

I prefer python -m json.tool which seems to be available per default on most *nix operating systems per default.

$ echo '{"foo":1, "bar":2}' | python -m json.tool
{
    "bar": 2, 
    "foo": 1
}

Note: Depending on your version of python, all keys might get sorted alphabetically, which can or can not be a good thing. With python 2 it was the default to sort the keys, while in python 3.5+ they are no longer sorted automatically, but you have the option to sort by key explicitly:

$ echo '{"foo":1, "bar":2}' | python3 -m json.tool --sort-keys
{
    "bar": 2, 
    "foo": 1
}

If you're looking for a portable C compiled tool:

http://stedolan.github.com/jq/

From the website:

> jq is like sed for JSON data - you can use it to slice and filter and map and transform structured data with the same ease that sed, awk, grep and friends let you play with text. > > jq can mangle the data format that you have into the one that you want with very little effort, and the program to do so is often shorter and simpler than you’d expect.

Tutorial: http://stedolan.github.com/jq/tutorial/<br/> Manual: http://stedolan.github.com/jq/manual/<br/> Download: http://stedolan.github.com/jq/download/

I have created a module specifically designed for command-line JSON manipulation:

https://github.com/ddopson/underscore-cli

• FLEXIBLE - THE "swiss-army-knife" tool for processing JSON data - can be used as a simple pretty-printer, or as a full-powered Javascript command-line
• POWERFUL - Exposes the full power and functionality of underscore.js (plus underscore.string)
• SIMPLE - Makes it simple to write JS one-liners similar to using "perl -pe"
• CHAINED - Multiple command invokations can be chained together to create a data processing pipeline
• MULTI-FORMAT - Rich support for input / output formats - pretty-printing, strict JSON, etc [coming soon]
• DOCUMENTED - Excellent command-line documentation with multiple examples for every command

It allows you to do powerful things really easily:

cat earthporn.json | underscore select '.data .title'



[ 'Fjaðrárgljúfur canyon, Iceland [OC] [683x1024]',


'New town, Edinburgh, Scotland [4320 x 3240]',


'Sunrise in Bryce Canyon, UT [1120x700] [OC]',


...


'Kariega Game Reserve, South Africa [3584x2688]',


'Valle de la Luna, Chile [OS] [1024x683]',


'Frosted trees after a snowstorm in Laax, Switzerland [OC] [1072x712]' ]



cat earthporn.json | underscore select '.data .title' | underscore count



25



underscore map --data '[1, 2, 3, 4]' 'value+1'



prints: [ 2, 3, 4, 5 ]



underscore map --data '{"a": [1, 4], "b": [2, 8]}' '_.max(value)'



[ 4, 8 ]



echo '{"foo":1, "bar":2}' | underscore map -q 'console.log("key = ", key)'



key = foo


key = bar



underscore pluck --data "[{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}]" name



[ 'moe', 'larry', 'curly' ]



underscore keys --data '{name : "larry", age : 50}'



[ 'name', 'age' ]



underscore reduce --data '[1, 2, 3, 4]' 'total+value'



10

And it has one of the best "smart-whitespace" JSON formatters available:

https://raw.github.com/ddopson/underscore-cli/master/doc/example.png"/>

If you have any feature requests, comment on this post or add an issue in github. I'd be glad to prioritize features that are needed by members of the community.

You can use this command-line parser (which you could put into a bash alias if you like), using modules built into the Perl core:

perl -MData::Dumper -MJSON::PP=from_json -ne'print Dumper(from_json($_))'

Checkout TickTick.

It's a true Bash JSON parser.

#!/bin/bash
. /path/to/ticktick.sh

# File
DATA=`cat data.json`
# cURL
#DATA=`curl http://foobar3000.com/echo/request.json`

tickParse "$DATA"

echo ``pathname``
echo ``headers["user-agent"]``

There is also JSON command line processing toolkit if you happen to have node.js and npm in your stack.

And another "json" command for massaging JSON on your Unix command line.

And here are the other alternatives:

• jq: <http://stedolan.github.io/jq/>
• fx: <https://github.com/antonmedv/fx>
• json:select: <https://github.com/dominictarr/json-select>
• json-command: <https://github.com/zpoley/json-command>
• JSONPath: <http://goessner.net/articles/JsonPath/>;, <http://code.google.com/p/jsonpath/wiki/Javascript>
• jsawk: <https://github.com/micha/jsawk>
• jshon: <http://kmkeen.com/jshon/>
• json2: <https://github.com/vi/json2>

---

Related: Command line tool for parsing JSON input for Unix?

Anyone mentioned Jshon or JSON.sh?

https://github.com/keenerd/jshon

pipe json to it, and it traverses the json objects and prints out the path to the current object (as a JSON array) and then the object, without whitespace.

http://kmkeen.com/jshon/
Jshon loads json text from stdin, performs actions, then displays the last action on stdout and also was made to be part of the usual text processing pipeline.

You could try jsawk as suggested in this answer.

Really you could whip up a quick python script to do this though.

For Bash/Python, here is a basic wrapper around python's simplejson:

json_parser() {
    local jsonfile="my_json_file.json"
    local tc="import simplejson,sys; myjsonstr=sys.stdin.read(); "`
            `"myjson=simplejson.loads(myjsonstr);"
    # Build python print command based on $@
    local printcmd="print myjson"
    for (( argn=1; argn<=$#; argn++ )); do
        printcmd="$printcmd['${!argn}']"
    done
    local result=$(python -c "$tc $printcmd.keys()" <$jsonfile 2>/dev/null \
        || python -c "$tc $printcmd" <$jsonfile 2>/dev/null)
    # For returning space-separated values
    echo $result|sed -e "s/[]|[|,|']//g"
    #echo $result 
}

It really only handles the nested-dictionary style of data, but it works for what I needed, and is useful for walking through the json. It could probably be adapted to taste.

Anyway, something homegrown for those not wanting to source in yet another external dependency. Except for python, of course.

Ex. json_parser {field1} {field2} would run print myjson['{field1}']['{field2}'], yielding either the keys or the values associated with {field2}, space-separated.

I just made jkid which is a small command-line json explorer that I made to easily explore big json objects. Objects can be explored "transversally" and a "preview" option is there to avoid console overflow.

$  echo '{"john":{"size":20, "eyes":"green"}, "bob":{"size":30, "eyes":"brown"}}' > test3.json
$  jkid . eyes test3.json 
object[.]["eyes"]
{
  "bob": "brown", 
  "john": "green"
}