Jackson’s Cannot deserialize from Object value (no delegate- or property-based Creator) error means it could not find a usable way to construct the target Java type from the JSON object. Matching JSON keys to Java fields is not enough when the class only has a parameterized constructor: Jackson also needs a recognized creator and, for property-based construction, a mapping from JSON names to constructor parameters.
First check what Jackson is trying to construct
The exception’s central clue is a missing or unusable creator: Jackson cannot instantiate the requested type from the input it received. Confirm the exact target class and that the failing value is a JSON object. An object-shaped input will not work with a creator that expects the entire input to be a scalar, such as a String. The exception class name and surrounding text can vary, so diagnose the construction route rather than relying on the wording alone.
As an Amazon Associate I earn from qualifying purchases.
Inspect the target class’s constructors and static factory methods, then choose a creation pattern that fits the class design.
Choose a construction pattern that fits the class
Mutable DTO: no-argument constructor and writable properties
If the class is intended to be populated after creation, give Jackson an accessible no-argument constructor and writable properties. Jackson can instantiate the object, then set each value from the JSON.
#1 Best Overall
public class Notification {
private String message;
private int priority;
public Notification() {}
public void setMessage(String message) { this.message = message; }
public void setPriority(int priority) { this.priority = priority; }
}Check that the properties are writable and visible under the mapper’s configuration. A no-argument constructor alone does not fix inaccessible, read-only, or mismatched properties. This approach is suitable for mutable beans, but may be a poor fit when constructor-only initialization enforces class invariants.
Immutable class: property-based constructor
For an immutable class, designate the constructor with Jackson’s @JsonCreator and associate each parameter with its JSON property using @JsonProperty. Import both annotations from com.fasterxml.jackson.annotation, not the legacy org.codehaus.jackson package.
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
public class Notification {
private final String message;
private final int priority;
@JsonCreator
public Notification(
@JsonProperty("message") String message,
@JsonProperty("priority") int priority) {
this.message = message;
this.priority = priority;
}
}The names in @JsonProperty must match the incoming JSON properties as interpreted by your application, including any aliases or naming strategy. This makes the mapping explicit and preserves constructor-based initialization.
Static factory creator
A static factory can provide the creation route when construction needs to go through a controlled method. Mark it as a creator, map its parameters, and return the target type.
@JsonCreator
public static Notification create(
@JsonProperty("message") String message,
@JsonProperty("priority") int priority) {
return new Notification(message, priority);
}One-argument creators: property-based versus delegating
Decide deliberately how Jackson should interpret a single-argument creator. A delegating creator converts the entire incoming JSON value to that argument’s type; a property-based creator binds a named property from an object to the parameter. A creator for a scalar String, for example, does not automatically accept an object token. The expected input shape must agree with the creator’s mode.
When constructor parameter names are inferred
Instead of annotating every parameter, some Jackson setups can discover constructor parameter names from compiled metadata. Baeldung’s example, using Jackson 2.17.2, describes registering ParameterNamesModule in Jackson 2.x and compiling with javac’s -parameters option so names remain available at runtime. It says this support is built into Jackson 3.x and enabled by default. Because behavior depends on the precise dependencies and configuration, verify the project’s versions and ensure the module is registered on the ObjectMapper that actually performs deserialization. Explicit @JsonProperty annotations avoid reliance on inferred names. Baeldung’s Jackson exception guide also mentions Paranamer for Jackson 2.x, but describes it as discontinued; it is not a sensible default for a new implementation.
Use this diagnostic sequence
- Confirm the input and target. Check the actual JSON value at the failure point, the target Java type, and whether the token is an object, scalar, or nested value.
- Inspect creation routes. Look for accessible constructors and annotated static factories. A class with an explicit parameterized constructor may not have a usable no-argument constructor.
- Match the design to the fix. For a mutable bean, verify a no-argument constructor and writable properties. For an immutable class, declare a property-based creator and map its parameters.
- Verify mapping details. Check annotation imports, property spelling, aliases, visibility rules, mapper configuration, and whether generated code changes the class shape.
- Validate any inferred names. Check compilation with
-parameters, registration of the intended module on the active mapper, and the exact Jackson version. - Reduce upgrade failures. If the error started after a dependency change, capture the versions of
jackson-databind,jackson-annotations, and related modules. Reproduce with the target class, annotations, mapper configuration, and input JSON before changing dependencies or constructor behavior.
If the error began after a Jackson upgrade
Creator introspection can be version-sensitive, but a similar message does not by itself prove a Jackson defect. A FasterXML issue opened January 15, 2025 records a report on Jackson 2.18.2 involving a legacy class with @JsonCreator and @ConstructorProperties; the issue lists milestone 2.18.3. That report is a reason to compare a minimal reproduction across the versions in your own dependency tree, not evidence that every occurrence has the same cause or is fixed by that milestone.
For release-specific annotation behavior, consult FasterXML’s annotations wiki alongside the documentation for the versions actually used by your application.
Quick Recap
Best Value
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
