The -r option should not be used if the output will be fed into another JSON parser; only the last jq in the pipeline should use it – otherwise you risk feeding non-JSON data into the second jq instance.

Your last example with .[0].t seems correct and works with jq 1.6.

$ cat json | jq '.tx' | jq -r '.[0].t'
t for a

But this can be simplified to a single jq invocation, first incrementally to:

$ cat json | jq -r '.tx | .[0].t'
t for a

and then finally to:

$ cat json | jq -r '.tx[0].t'
t for a

EDIT: After clarification in the comments, to retrieve the states of devices whose key begins with "dimmer", use

Copyjq '[ .devices | to_entries[] | select(.key | startswith("dimmer")) | .value = .value.state ] | from_entries' filename.json

Output:

{
  "dimmer1": "off",
  "dimmer2": "off"
}

This works as follows:

• .devices selects the .devices attribute of the JSON object
• to_entries explodes the object into an array of key-value pairs describing its attributes (the devices), which is to say that an attribute "foo": "bar" becomes an object { "key": "foo", "value": "bar" }, and the exploded object is expanded into an array of such objects (one for each attribute)
• to_entries[] unpacks that array, in order to pipe it through
• select(.key | startswith("dimmer")), which selects of the devices those whose key begins with dimmer
• .value = .value.state restructures the key-value pair that describes the device so that the value is replaced with just its state attribute
• [ all that ] makes a JSON array of all that, and
• [ all that ] | from_entries converts the array of key-value pairs back to JSON objects.

Old answer (shortened), now obsolete but possibly of interest:

To retrieve the keys of the attributes of devices in an array:

Copyjq '.devices | keys' filename.json

To retrieve the values (also in an array),

Copyjq '[ .devices[] ]' filename.json

I wasn't entirely sure which of those two you meant.

Adapted from this post on Processing JSON with jq, you can use the select(bool) like this:

$ jq '.[] | select(.location=="Stockholm")' json
{
  "location": "Stockholm",
  "name": "Walt"
}
{
  "location": "Stockholm",
  "name": "Donald"
}

I think this is fairly easy to achieve for this inner list. The values seem to be all zero's so...

jq  '.[][1]' < yourjsonfile

Just to provide another approach. When working with lists, dicts and other types python is the right tool. To give you an idea on how you could retrieve the values from the list you'd do something lik:

#!/usr/bin/env python

mylist = [[1645128660000,0],[1645128720000,0],[1645128780000,0],[1645128840000,0],[1645128900000,0],[1645128960000,0],[1645129020000,0],[1645129080000,0],[1645129140000,0],[1645129200000,0]]

for k,v in mylist:
    print("Key":,k)
    print("Value":v)

Or using list comprehension

[v for k,v in mylist]

should be sufficient. There is also this awesome page where you can play around with jq: https://jqplay.org/#

This jq query works for me with the JSON for Docker:

.artifacts[] | arrays[0] | select(endswith(".app"))

The arrays filter selects arrays from elements of artifacts, and then we can look for the first elements of these arrays for one which ends with .app.

With

jq 'map_values(select(.value == "auto"))' file

... you pull out the parts of the top-level object that you are interested in:

{
  "package2": {
    "name": "package_2",
    "value": "auto"
  }
}

With map_values(expression), you apply expression to each sub-part of the input object. In this case, the part is kept if the test in the select() statement evaluates to true, and discarded otherwise. It's similar to map(expression), but you'd use map() on arrays and map_values() on objects.

From there, you can choose to get the top-level key:

$ jq -r 'map_values(select(.value == "auto"))|keys[]' file
package2

The keys function creates an array of all keys in the input object, and the [] at the end expands the array into a set of strings.

Note that if there are multiple sub-objects with auto as their .value key's value, you will get multiple strings out of this command.

For a brief moment, I was unsure whether you wanted the value of the .name key or the top-level key. Once I spotted that you only wanted the top-level key, I had already written the text below. I'm leaving it in as a sort of comment.

$ jq -r 'map_values(select(.value == "auto"))[].name' file
package_2

Using [].name at the end, expand the top-level object into a set of sub-objects and then extract the .name key's value from each.

This last one could also have been written

$ jq -r 'map_values(select(.value == "auto").name)[]' file
package_2

... which reduces the original object to only

{
  "package2": "package_2"
}

... and then extracts the values of all remaining keys with the trailing [].

Evidently one of the items in the array is a string. If your jq supports "?", then one possibility would be to use it:

.response[].text?

Another would be to check the type explicitly, e.g.:

.response[] | objects | .text

Yet another possibility:

.response[] | select(type=="object" and has("text")) | .text

If you want to have a placeholder value when there is no "text" field:

 .response[] | if type=="object" and has("text") then .text else null end

So it really depends on your requirements and perhaps the version of jq that you are using.