What you are trying to do is also called as Xpath in technical terms. It is used for html, xml based languages as well as now available in json

You can try jsonpath for this case:

https://www.baeldung.com/guide-to-jayway-jsonpath https://github.com/json-path/JsonPath

With Jackson's tree model (JsonNode), you have both "literal" accessor methods (get), which returns null for missing value, and "safe" accessors (path), which allow you to traverse "missing" nodes. So, for example:

JsonNode root = mapper.readTree(inputSource);
int h = root.path("response").path("history").getValueAsInt();

which would return the value at the given path, or, if the path is missing, 0 (default value).

But more conveniently, you can just use JSON pointer expression:

int h = root.at("/response/history").getValueAsInt();

There are other ways too, and often it is more convenient to model your structure as a Plain Old Java Object (POJO). Your content could fit something like:

public class Wrapper {
  public Response response;
} 
public class Response {
  public Map<String,Integer> features; // or maybe Map<String,Object>
  public List<HistoryItem> history;
}
public class HistoryItem {
  public MyDate date; // or just Map<String,String>
  // ... and so forth
}

and if so, you would traverse the resulting objects just like any Java object.

If you want a node directly underneath the root use .get()

jsonNode.get("id").textValue();

If you want to get "name" but you have problems with ambiguity you can do something like

jsonNode.findPath("metaData").findPath("name").textValue();

But then of course you know have to know something about the schema.

I'm not familiar with Ready API or the json-path and json-smart libraries, but with pure groovy you can just do:

import groovy.json.*

def str  = """<the json string in your question>"""
def json = new JsonSlurper().parseText(str)
def memberNames = json.members*.name

println memberNames.join(", ")

which when executed will print:

Molecule Man, Madame Uppercut, Eternal Flame

JsonSlurper returns a java.util.Map of maps structure which can be navigated using normal groovy findAll, collect, etc operations or the spead operator (*.) as in the above.

Using the path is currently (.NET 7) not supported. It might be supported in a later version.

From documentation:

The JsonDocument DOM doesn't support querying by using JSON Path.

In a JsonNode DOM, each JsonNode instance has a GetPath method that returns a path to that node. But there is no built-in API to handle queries based on JSON Path query strings.

If you need very flexible Json support, use the Newtonsoft.Json Nuget package.