So what you have is a JSON object, so JsonNode.Parse will really return a JsonObject, so first we need to cast it:

var jsonObject = JsonNode.Parse(input)!.AsObject(); // null check omitted for brevity

Now let's do the rename. A rename is really a removal of the object with the old property followed by readding it with the new name. So:

var node = jsonObject["foo"]; // take a reference to foo so we don't lose it
jsonObject.Remove("foo"); // detach from parent
jsonObject.Add("bar", node); // attach with new name

The reason why you need to first remove it and then add it back, is that JsonNode objects have parents, and you're not allowed to add a node to an object or array if it already has a parent. So you first need to detach it from its parent with Remove, and then you can add it back under the new name with Add.

Now, this modifies the original JSON object. If you want to instead keep the original intact you'll have to clone it first. This is a problem, because there is no way to clone a JsonNode. You could do this:

var clone = new JsonObject(jsonObject);

And it will compile, but then at runtime you'll hit an exception because this just adds the nodes from one object to the next and as we've already established you can't add an object that already has a parent to another one. You would have to first clone each child node and add those instead.

As far as I'm aware, the JsonNodes namespace has no way to do a deep clone of JSON nodes. It seems like an oversight. You could either do it by hand by recursively enumerating the nodes in the document and creating them, or just parse the document twice.

You should convert it to ObjectNode first like this :

ObjectNode value = ((ObjectNode) JsonNode.get(0)).get("ObjectIWantToRetrieve")

Perhaps you're looking for:

mapper.convertValue(jsonNode, MyPojo.class)

Javadoc: ObjectMapper.convertValue(Object, Class)

Convenience method for doing two-step conversion from given value, into instance of given value type, by writing value into temporary buffer and reading from the buffer into specified target type. This method is functionally similar to first serializing given value into JSON, and then binding JSON data into value of given type, but should be more efficient since full serialization does not (need to) occur. However, same converters (serializers, deserializers) will be used as for data binding, meaning same object mapper configuration works.

There's more to the Javadoc, but that's the gist of it.