FasterXML/jackson

Jackson Project Home @github

This is the home page of the Jackson Project.

Table of Contents

• What is New?
• What is Jackson?
• Jackson Versions, Releases
• Active Jackson projects, repos
• Contributing
• Support
  • Community support
  • Enterprise support
  • Version support
    • Community-provided Version support
    • Commercial Version support
• Reporting security vulnerabilities
• Documentation

---

What is New?

• Jun 8, 2026: Jackson 3.2 (non-LTS) released
• Jun 5, 2026: Major update, ToC, Support links
• Feb 23, 2026: Jackson 3.1 (LTS) released
• Jan 18, 2026: Jackson 2.21 (LTS) released
• Oct 3, 2025: Jackson 3.0.0 GA Released!!!
• Sep 30, 2025: Skeletal version of Jackson 3 Migration Guide
• Sep 5, 2025: Added note of jackson-annotations versioning scheme change in 2.20
• Sep 26, 2024: Jackson 2.18 (LTS) released
• Feb 19, 2024: Another OSTIF/AdaLogics Security Audit -- on jackson-dataformat-xxx's and jackson-datatype-xxx's -- released: https://ostif.org/dataformatsdatatypes-audit-complete/
• Dec 17, 2023: contributing/Jackson Coding Style Guide
• Nov 2, 2022: AdaLogics Security Audit for Jackson released -- see Document/Reports
• Oct 1, 2020: Jackson participates in Hacktoberfest2020 and we have a Jackson/Hacktoberfest repo too!
• Oct 9, 2020: Added Contributing

What is Jackson?

Jackson has been known as "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java".

More than that, Jackson is a suite of data-processing tools for Java (and the JVM platform), including the flagship streaming JSON parser / generator library, matching data-binding library (POJOs to and from JSON) and additional data format modules to process data encoded in Avro, BSON, CBOR, CSV, Smile, (Java) Properties, Protobuf, TOML, XML or YAML; and even the large set of data format modules to support data types of widely used data types such as Guava, Joda, PCollections and many, many more (see below).

While the actual core components live under their own projects -- including the three core packages (streaming, databind, annotations); data format libraries; data type libraries; JAX-RS provider; and a miscellaneous set of other extension modules -- this project act as the central hub for linking all the pieces together.

A good companion to this README is the Jackson Project FAQ.

Jackson Versions, Releases

Versioning explains full logic of how branches are maintained and versions released from branches. Release notes for 2.x and 3.x releases, as well as support status (Open/Closed) are found from Jackson Releases page. Here's a brief overview.

Jackson has three major versions:

• 1.x (org.codehaus.jackson) is deprecated and no versions are released (sources available via jackson-1 repo)
• 2.x (com.fasterxml.jackson) is the previous major version, still actively maintained -- and, as of June 2026, the most widely adopted
• 3.x (tools.jackson) is the newer actively developed and maintained version, recommended for new projects

These major versions use different Java packages and Maven groupIds, so they are not plug-in replaceable/upgradable, but can peacefully co-exist: a project can depend on Jackson 1.x and 2.x and even 3.x, without conflicts. This is by design and was chosen as the strategy to allow smoother incremental migration from 1.x to 2.x, and from 2.x to 3.x.

The latest stable versions, released from the current "Latest Release Branches" (2.22, 3.2), are:

• 3.2.0, released on 08-Jun-2026
• 2.22.0, released on 31-May-2026
• 1.9.13, released 14-Jul-2013

Active development happens on the 2.x and 3.x branches; patches ship from the latest release branches, and selected minors (e.g. 2.18, 2.21, 3.1) are kept open as Long-Term Support (LTS) branches. See Versioning for the full branch model, including "Open"/"Closed" (EOL) status.

Recommended way to use Jackson is through Maven repositories; releases are made to Central Maven Repository (Maven Central).

Jackson 2.x to 3.0 migration

With Jackson 3.0.0 GA, some documentation exists to help migration:

• Jackson 3 Migration Guide

Active Jackson projects, repos

Most projects listed below are lead by Jackson development team; but some by other at-large Jackson community members.

We try to keep versioning of modules lined up to reduce confusion regarding which versions work together.

• One exception to this is jackson-annotations which has a different versioning starting from 2.20 -- 2.20 instead of 2.20.0 (no patch digit)
  • See Versioning and JSTEP-1, or issue 294 for details.
• For fully consistent set of versions, consider using Jackson BOM (jackson-bom)

Core modules

Core modules are the foundation on which extensions (modules) build upon. There are 3 such modules currently (as of Jackson 2.x):

• Streaming (docs) ("jackson-core") defines low-level streaming API, and includes JSON-specific implementations
• Annotations (docs) ("jackson-annotations") contains standard Jackson annotations
• Databind (docs) ("jackson-databind") implements data-binding (and object serialization) support on streaming package; it depends both on streaming and annotations packages

In addition:

• Jackson BOM (jackson-bom) is useful for ensuring fully consistent set of versions for all official Jackson components. It is usually used by importing as pom in "managed dependencies" Maven section (or using similar mechanism in Gradle etc).

Third-party datatype modules

These extensions are plug-in Jackson Modules (registered with ObjectMapper.registerModule()), and add support for datatypes of various commonly used Java libraries, by adding serializers and deserializers so that Jackson databind package (ObjectMapper / ObjectReader / ObjectWriter) can read and write these types.

Datatype modules directly maintained by Jackson team are under the following Github repositories:

• Standard Collections datatype modules:
  • jackson-datatype-eclipse-collections: support for Eclipse Collections (added in 2.10)
  • jackson-datatype-guava: support for many of Guava datatypes
  • jackson-datatype-hppc: support for High-Performance Primitive Containers containers
  • jackson-datatype-pcollections: support for PCollections datatypes (since Jackson 2.7)
• Hibernate: support for Hibernate features (lazy-loading, proxies)
• Java 8 Modules: support or JDK 8 features and datatypes through 3 separate modules
  • jackson-module-parameter-names: Module that adds support for using a new JDK8 feature, ability to access names of constructor and method parameters, to allow omitting @JsonProperty.
  • jackson-datatype-jsr310: support for "Java 8 Dates" (ones added in JDK 8)
    • Also, for pre-Java8 users can use one of alternate pre-Java8 backports:
      • joschi/jackson-datatype-threetenbp
      • lldata/jackson-datatype-threetenbp
  • jackson-datatype-jdk8: support for JDK 8 data types other than date/time types, including Optional
  • NOTE: only Jackson 2.x versions exist: functionality merged in jackson-databind in 3.0
• Joda datatypes:
  • jackson-datatype-joda: support for types of Joda-Time date/time library datatypes
  • jackson-datatype-joda-money: support types of Joda-Money datatypes (Money, CurrencyUnit)
• JSON-P ("json processing"): two datatype modules for "old" (javax.json) and "new" (jakarta.json):
  • jackson-datatype-jakarta-jsonp: support for "new" JSON-P types in jakarta.json (added in Jackson 2.13)
  • jackson-datatype-jsr353: support for "old" JSON-P types in javax.json
• jackson-datatype-json-org: support for org.json library types like JSONObject, JSONArray

In addition, we are aware of additional modules that are not directly maintained by core Jackson team:

• jackson-datatype-bolts support for reading/writing types defined by Yandex Bolts collection types (Functional Programming inspired immutable collections)
• jackson-datatype-commons-lang3 for types of Apache Commons Lang v3
• jackson-datatype-money for "Java Money", see javax.money
• vavr-jackson for VAVR support (Feature-rich & self-contained functional programming in Java™ 8 and above)
• jackson-datatype-json-lib for supporting types defined by "net.sf.json" library (aka "json-lib")
• jackson-datatype-jts (JTS Geometry) for GeoJSON support
• jackson-lombok for better support of Lombok classes
• jackson-datatype-mongo for MongoDB types
  • NOTE: there are a few alternatives to handling MongoDB datatypes
• jackson-module-objectify for datatypes of Objectify
• jackson-datatype-protobuf for handling datatypes defined by the standard Java protobuf library, developed by HubSpot
  • NOTE! This is different from jackson-dataformat-protobuf which adds support for encoding/decoding protobuf content but which does NOT depend on standard Java protobuf library
• TinyTypes includes Jackson module (group id com.github.caligin.tinytypes, artifact tinytypes-jackson)
• jackson-datatype-vertx for reading/writing Vert.x org.vertx.java.core.json.JsonObject objects (repackaged org.json node types)

Providers for JAX-RS

Jackson JAX-RS Providers has handlers to add dataformat support for JAX-RS implementations (like Jersey, RESTeasy, CXF). Providers implement MessageBodyReader and MessageBodyWriter. Supported formats currently include JSON, Smile, XML, YAML and CBOR.

Data format modules

Data format modules offer support for data formats other than JSON. Most of them simply implement streaming API abstractions, so that databinding component can be used as is; some offer (and few require) additional databind level functionality for handling things like schemas.

Currently following data format modules are fully usable and supported (version number in parenthesis, if included, is the first Jackson 2.x version to include module; if missing, included from 2.0)

• Avro: supports Avro data format, with streaming implementation plus additional databind-level support for Avro Schemas
• CBOR: supports CBOR data format (a binary JSON variant).
• CSV: supports Comma-separated values format -- streaming api, with optional convenience databind additions
• Ion (2.9): support for Amazon Ion binary data format (similar to CBOR, Smile, i.e. binary JSON - like)
• (Java) Properties (2.8): creating nested structure out of implied notation (dotted by default, configurable), flattening similarly on serialization
• Protobuf (2.6): supported similar to Avro
• Smile: supports Smile (binary JSON) -- 100% API/logical model compatible via streaming API, no changes for databind
• TOML: (added in 2.13) supports TOML, supported with both streaming and databind implementations
• XML: supports XML; provides both streaming and databind implementations. Similar to JAXB' "code-first" mode (no support for "XML Schema first", but can use JAXB beans)
• YAML: supports YAML, which being similar to JSON is fully supported with simple streaming implementation

There are also other data format modules, provided by developers outside Jackson core team:

• BEncode: support for reading/writing BEncode (BitTorrent format) encoded data
• bson4jackson: adds support for BSON data format (by Mongo project).
  • Implemented as full streaming implementation, which allows full access (streaming, data-binding, tree-model)
  • Also see [MongoJack] library below; while not a dataformat module, it allows access to BSON data as well.
• EXIficient supports Efficient XML Interchange
• jackson-dataformat-msgpack adds support MessagePack (aka MsgPack) format
  • Implemented as full streaming implementation, which allows full access (streaming, data-binding, tree-model)
• HOCON: experimental, partial implementation to support HOCON format -- work in progress
• Rison: Jackson backend to support Rison
• jackson-dataformat-spreadsheet: support for reading/writing Excel spreadsheets (XLSX/XLS) using Apache POI and StAX
  • XLSX read path implemented as full streaming implementation via StAX, which allows full access (streaming, data-binding, tree-model)

JVM Language modules

• Kotlin to handle native types of Kotlin
• Scala to handle native Scala types (including but not limited to Scala collection/map types, case classes)
  • Currently (June 2026), Scala 2.12, 2.13 and 3 are supported (2.9 was supported up to Jackson 2.3, 2.10 up to Jackson 2.11 and 2.11 is still supported for Jackson 2.x but not for Jackson 3.x)

Support for Schemas

Jackson annotations define intended properties and expected handling for POJOs, and in addition to Jackson itself using this for reading/writing JSON and other formats, it also allows generation of external schemas. Some of this functionality is included in above-mentioned data-format extensions; but there are also many stand-alone Schema tools, such as:

JSON Schema

• Build tool plug-ins
  • Ant Task for JSON Schema Generation: Generate JSON Schemas from your Java classes with Apache Ant using the Jackson library and extension modules.
• Stand-alone JSON Schema generators
  • Java JSON Schema Generator (supports json schema draft v7!)
  • Jackson jsonSchema Generator (Scala)
  • JSON Schema generator module: programmatically generate JSON Schema, based on Jackson POJO introspection, including annotations (ONLY SUPPORTS json schema v3!!!)
• Code generators based on JSON Schema
  • jsonschema2pojo - Generate Java types from JSON or JSON Schema
• JSON Schema validators
  • Java JSON Schema validator

Other schema languages

• Ember Schema Generator: Generate schemas for Ember.js

Other modules, stable

Other fully usable modules by FasterXML team include:

• Base modules:
  • Afterburner: speed up databinding by 30-40% with bytecode generation to replace use of Reflection for field access, method/constructor calls
  • Blackbird: similar to Afterburner but designed to work well with newer JDKs (JDK 17+)
  • Guice: extension that allows injection values from Guice injectors (and basic Guice annotations), instead of standard @JacksonInject (or in addition to)
  • JAXB Annotations: allow use of JAXB annotations as an alternative (in addition to or instead of) standard Jackson annotations
  • Jakarta XML Bind Annotations: same as JAXB annotations but for newer "Jakarta" variants
  • Mr Bean: "type materialization" -- let Mr Bean generate implementation classes on-the-fly (NO source code generation), to avoid monkey code
  • OSGi: allows injection of values from OSGi registry, via standard Jackson @JacksonInject annotation

Jackson jr

While Jackson databind is a good choice for general-purpose data-binding, its footprint and startup overhead may be problematic in some domains, such as mobile phones; and especially for light usage (couple of reads or writes). In addition, some developers find full Jackson API overwhelming.

For all these reasons, we decided to create a much simpler, smaller library, which supports a subset of functionality, called Jackson jr. It builds on Jackson Streaming API, but does not depend on databind. As a result its size (both jar, and runtime memory usage) is considerably smaller; and its API is very compact.

Third-party non-module libraries based on Jackson

Jackson helper libraries

• Jackson Ant path filter adds powerful filtering of properties to serialize, using Ant Path notation for hierarchic filtering

Support for datatypes

• MongoJack supports efficient handling of BSON encoded data store in MongoDB.

Event processing

• json-events -- Event processing for JSON, similar to SAX (for XML), based on jackson-core.

Other things related to or inspired by Jackson

• Jackson-js is a Javascript/Node object serialization/deserialization library with API inspired by Jackson
• Pyckson is a Python library that aims for same goals as Java Jackson, such as Convention over Configuration
• Rackson is a Ruby library that offers Jackson-like functionality on Ruby platform

Contributing

If you would like to help with Jackson project, please check out Contributing.

You may also want to check out:

• Jackson Coding Style

Support

Community support

Jackson components are supported by the Jackson community through mailing lists, Gitter forum, Github issues. See Contributing for full details.

Enterprise support

In addition to free (for all) community support, enterprise support is available as part of the Tidelift Subscription for (most) Jackson components.

The maintainers of Jackson and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

Version support

Versioning explains logic of how branches are maintained and versions released from branches, as well as concepts "Open"/"Closed"/"Long-Term Support" (LTS) branches.

Full status (Open / Closed (aka EOL)) of various versions and branches can be found from Jackson Releases page.

Community Version Support

Jackson project itself supports "Open" branches by releasing new versions from them; many fixes are backported to a set of "Long-Term Support" branches.

Project does not support "Closed" (aka EOL) maintenance branches.

Commercial Version Support

In addition to Community-provided support, commercial vendors offer optional extended support.

HeroDevs provides Never-Ending Support (NES) for end-of-life (EOL) versions of Jackson: NES for Jackson -- drop-in replacement packages that preserve the original group ID, artifact ID, and public API. HeroDevs is a founding member of the Commonhaus Foundation Open Source Sustainability Initiative (OSSI)

Reporting security vulnerabilities

The recommended mechanism for reporting possible security vulnerabilities follows so-called "Coordinated Disclosure Plan" (see definition of DCP for general idea). The first step is to file a Tidelift security contact: Tidelift will route all reports via their system to maintainers of relevant package(s), and start the process that will evaluate concern and issue possible fixes, send update notices and so on. Note that you do not need to be a Tidelift subscriber to file a security contact.

Alternatively you may also report possible vulnerabilities to info at fasterxml dot com mailing address. Note that filing an issue to go with report is fine, but if you do that please DO NOT include details of security problem in the issue but only in email contact. This is important to give us time to provide a patch, if necessary, for the problem.

Note on reporting Bugs

Jackson bugs need to be reported against component they affect: for this reason, issue tracker is not enabled for this project. If you are unsure which specific project issue affects, the most likely component is jackson-databind, so you would use Jackson Databind Issue Tracker.

For suggestions and new ideas, try Jackson Future Ideas

Documentation

Web sites

• jackson-docs is our Github Jackson documentation hub
• Wiki of this repo contains:
  • Jackson Releases
  • FAQ
• Blogs
  • CowTalk (deprecated) -- Blog with lots of Jackson-specific content. Not updated since 2013.
  • Cowtowncoder@medium -- More recent blogging about Jackson

Tutorials

For first-time users there are many good Jackson usage tutorials, including general usage / JSON tutorials:

• Baeldung Jackson JSON Tutorial
• Javarevisited Jackson JSON Tutorial
• Jenkov.com Jackson Tutorial
• JournalDev Jackson Tutorial
• LogicBig.com Jackson Tutorial
• StudyTrails Jackson Introduction

and more specific tutorials:

• Java67 Javakcson CSV Tutorial (CSV)

Reports

Following reports have been published about Jackson components

• AdaLogics Jackson Security Audit (2022) (jackson-core, jackson-databind)

Java JSON library comparisons

Since you probably want opinions by Java developers NOT related to Jackson project, regarding which library to use, here are links to some of existing independent comparisons:

• Top 7 Open-Source JSON-binding providers (April 2014)
• Be a Lazy but a Productive Android Developer, Part 3: JSON Parsing Library (April 2014)
• "Can anyone recommend a good Java JSON library" (Linked-In group) (March 2013)
• "Which JSON library to use on Android?" (September 2012)