iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
The Jackson error Cannot deserialize from Object value (no delegate- or property-based Creator) means Jackson received a JSON object but could not find a supported way to construct the requested Java type from it. Matching JSON keys to fields is not enough when the class only has a parameterized constructor: Jackson needs a recognized creator and, for property-based construction, a mapping from JSON properties to constructor parameters.
Why Jackson cannot construct the object
Jackson needs a usable construction route before it can populate a target type. A mutable bean can be created with a no-argument constructor and then filled through writable properties. An immutable class generally needs an explicitly mapped constructor or factory method. Without one of those routes, Jackson may report that it has no delegate- or property-based creator.
The exact exception class and surrounding text can vary. Treat the wording as a creator or instantiation clue, not proof of one specific defect. First check that the input is actually an object with the shape the target type expects. A delegating creator may exist but expect a scalar or another value shape rather than an object.
Free tools Windows power users keep installed
One-click scans. No signup required.
Choose a construction method that fits the class
Mutable DTO: no-argument constructor and writable properties
If the class is designed to be populated after construction, provide an accessible no-argument constructor and setters or other writable properties. Jackson can instantiate the object and then assign the JSON values.
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; }
}A no-argument constructor alone is not sufficient if the properties are inaccessible, read-only, or named differently from the input under the mapper’s visibility and naming rules.
Immutable class: property-based constructor
For constructor-initialized fields, annotate the constructor with @JsonCreator and each parameter with the matching @JsonProperty. This explicitly tells Jackson how object properties map to constructor arguments.
Rank #2
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;
}
}Use annotations from com.fasterxml.jackson.annotation. The legacy org.codehaus.jackson package is not the annotation package for this Jackson setup. Match each annotation value to the actual JSON property name, accounting for any aliases or naming strategy used by the application.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteOne-argument creators: choose property-based or delegating deliberately
A one-argument creator can be ambiguous in intent. A delegating creator treats the incoming JSON value as a whole value to convert to the argument type; a property-based creator binds named properties of an object to constructor parameters. For example, a creator expecting a String as the entire input does not necessarily accept an object containing a string property. Make the intended input shape explicit and check that it matches the JSON token Jackson is reading.
Static factory creator
A static factory can provide the construction route when creation is controlled or constructor visibility is unsuitable. Annotate the factory with @JsonCreator, map its parameters with @JsonProperty, and return the target type.
@JsonCreator
public static Notification create(
@JsonProperty("message") String message,
@JsonProperty("priority") int priority) {
return new Notification(message, priority);
}When constructor parameter names are inferred
Per-parameter @JsonProperty annotations are the clearest way to make the mapping explicit. If you rely on inferred names instead, check the build and mapper setup:
Rank #4
- For Jackson 2.x, Baeldung documents use of
ParameterNamesModulewhen code is compiled with javac’s-parametersoption, which retains constructor parameter names at runtime. - Baeldung states that this behavior is built into Jackson 3.x and enabled by default. Confirm the exact version and defaults used by your project rather than assuming inference is active.
- Verify the intended module is registered on the
ObjectMapperused for the failing call. Registering it on a different mapper will not affect that deserialization.
Parameter-name inference depends on retained metadata and library configuration. Explicit annotations avoid that dependency and document the JSON-to-constructor mapping. Baeldung also mentions Paranamer as a Jackson 2.x option, but reports it as discontinued; it is not a sensible default for a new implementation.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteDiagnose the failure in a practical order
- Confirm the target and input shape. Identify the exact Java type requested at the failing call and inspect the JSON value at that location. Confirm it is an object, not a scalar or a differently shaped nested value.
- Inspect constructors and factories. Check for an accessible no-argument constructor, parameterized constructors, and static factory methods. An explicit parameterized constructor may leave the class without a usable no-argument route.
- Match the remedy to the design. For a mutable bean, confirm Jackson can call a no-argument constructor and write the relevant properties. For an immutable type, designate a property-based creator and map its parameters.
- Check binding details. Verify annotation imports, JSON property spelling, access visibility, mapper configuration, generated-code behavior, and any aliases or naming strategies.
- Validate inferred names if used. Check the
-parameterscompiler option, runtime parameter metadata, registration of the intended module on the actual mapper, and the Jackson version. - Reduce upgrade-related failures. If the issue began after a dependency change, make a minimal reproduction containing the target class, annotations, mapper configuration, and JSON. Compare the working and failing dependency versions before changing constructor semantics or downgrading.
If the exception started after a Jackson upgrade
Record the exact versions of jackson-databind, jackson-annotations, and any related modules, then compare them with the last working build. A FasterXML issue opened January 15, 2025 describes a report on Jackson 2.18.2 involving a legacy class with @JsonCreator and @ConstructorProperties; the issue lists milestone 2.18.3. That report shows that creator-introspection differences can arise in an upgrade context, but it does not establish that every similar error is a Jackson defect or that the same behavior affects every release. Check the issue details at FasterXML issue 4919 and reproduce the behavior against the versions your application supports.
Best Value
Pick the fix by design, not by symptom alone
| Situation | Suitable route | Important check |
|---|---|---|
| Mutable DTO populated after creation | No-argument constructor plus writable properties | Constructor access and property writability |
| Immutable class initialized through named values | @JsonCreator with matching @JsonProperty parameters |
Names must match the JSON contract |
| Controlled or non-public construction design | Annotated static factory | Factory parameters and return type must describe the intended mapping |
| Constructor names inferred from metadata | Parameter-name module or version-supported inference | Compiler flags, mapper registration, and exact Jackson version |
For an immutable class whose invariants are established in its constructor, adding setters merely to silence the exception may weaken the design. Conversely, a mutable DTO does not need a constructor-based creator if ordinary post-construction property assignment is the intended model.
Version context and references
Baeldung’s example of this exception uses Jackson 2.17.2 and explains the constructor, annotation, factory, and parameter-name approaches. Its article was last updated September 14, 2026: Jackson exception: no delegate- or property-based Creator.
For annotation behavior and creator configuration, see the FasterXML Jackson annotations wiki. Its publication date is not established here, so confirm release-specific behavior against the versions in your build.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Quick Recap
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.
