Skip to content

Package Managers

Homebrew Homebrew nlohmann-json   Meson Meson nlohmann_json   Bazel Bazel nlohmann_json
Conan Conan nlohmann_json   Spack Spack nlohmann-json   Hunter nlohmann_json
vcpkg vcpkg nlohmann-json   cget nlohmann/json   Swift Package Manager Swift Package Manager nlohmann/json
Nuget NuGet nlohmann.json   Conda Conda nlohmann_json   MacPorts MacPorts nlohmann-json
cpm.cmake CPM.cmake gh:nlohmann/json   xmake xmake nlohmann_json

Running example

Throughout this page, we will describe how to compile the example file example.cpp below.

#include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

When executed, this program should create output similar to

{
    "compiler": {
        "c++": "201103",
        "family": "gcc",
        "version": "12.4.0"
    },
    "copyright": "(C) 2013-2026 Niels Lohmann",
    "name": "JSON for Modern C++",
    "platform": "apple",
    "url": "https://github.com/nlohmann/json",
    "version": {
        "major": 3,
        "minor": 12,
        "patch": 0,
        "string": "3.12.0"
    }
}

Many of the package managers below install a CMake package configuration that exposes the same nlohmann_json::nlohmann_json interface target described in CMake; their CMake examples below link against that target.

Homebrew

Summary

formula: nlohmann-json

  • Homebrew package
  • Available versions: current version and development version (with --HEAD parameter)
  • The formula is updated with every release.
  • Maintainer: Niels Lohmann
  • File issues at the Homebrew issue tracker
  • Homebrew website

If you are using Homebrew, you can install the library with

brew install nlohmann-json

The header can be used directly in your code or via CMake.

Example: Raw compilation

  1. Create the following file:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Install the package:

    brew install nlohmann-json

  3. Compile the code and pass the Homebrew prefix to the include path such that the library can be found:

    c++ example.cpp -I$(brew --prefix nlohmann-json)/include -std=c++11 -o example
Example: CMake

  1. Create the following files:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}
    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

find_package(nlohmann_json CONFIG REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)

  2. Install the package:

    brew install nlohmann-json

  3. Compile the code and pass the Homebrew prefix to CMake to find installed packages via find_package:

    CMAKE_PREFIX_PATH=$(brew --prefix) cmake -S . -B build
cmake --build build

Meson

Summary

wrap: nlohmann_json

If you are using the Meson Build System, add this source tree as a meson subproject. You may also use the include.zip published in this project's Releases to reduce the size of the vendored source tree. Alternatively, you can get a wrap file by downloading it from Meson WrapDB, or use

meson wrap install nlohmann_json

Please see the Meson project for any issues regarding the packaging.

The provided meson.build can also be used as an alternative to CMake for installing nlohmann_json system-wide in which case a pkg-config file is installed. To use it, have your build system require the nlohmann_json pkg-config dependency. In Meson, it is preferred to use the dependency() object with a subproject fallback, rather than using the subproject directly.

Example: Wrap

  1. Create the following files:

    meson.build
    project('json_example', 'cpp',
  version: '1.0',
  default_options: ['cpp_std=c++11']
)

dependency_json = dependency('nlohmann_json', required: true)

executable('json_example',
  sources: ['example.cpp'],
  dependencies: [dependency_json],
  install: true
)
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Use the Meson WrapDB to fetch the nlohmann/json wrap:

    mkdir subprojects
meson wrap install nlohmann_json

  3. Build:

    meson setup build
meson compile -C build

Bazel

Summary

use bazel_dep, git_override, or local_path_override

This repository provides a Bazel MODULE.bazel and a corresponding BUILD.bazel file. Therefore, this repository can be referenced within a MODULE.bazel by rules such as archive_override, git_override, or local_path_override. To use the library, you need to depend on the target @nlohmann_json//:json (i.e., via deps attribute).

Example: Bazel module with bazel_dep

  1. Create the following files:

    BUILD
    cc_binary(
    name = "main",
    srcs = ["example.cpp"],
    deps = ["@nlohmann_json//:json"],
)
    MODULE.bazel
    bazel_dep(name = "nlohmann_json", version = "3.12.0.bcr.2")
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Build and run:

    bazel build //:main
bazel run //:main

Conan

Summary

recipe: nlohmann_json

If you are using Conan to manage your dependencies, merely add nlohmann_json/x.y.z to your conanfile's requires, where x.y.z is the release version you want to use.

Example: CMake with the Conan toolchain

  1. Create the following files:

    Conanfile.txt
    [requires]
nlohmann_json/3.12.0

[generators]
CMakeToolchain
CMakeDeps
    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

find_package(nlohmann_json REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Call Conan:

    conan install . --output-folder=build --build=missing

  3. Build:

    cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE="conan_toolchain.cmake" -DCMAKE_BUILD_TYPE=Release
cmake --build build

Spack

Summary

package: nlohmann-json

If you are using Spack to manage your dependencies, you can use the nlohmann-json package via

spack install nlohmann-json

Please see the Spack project for any issues regarding the packaging.

Example: CMake with a Spack-installed package

  1. Create the following files:

    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

find_package(nlohmann_json REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Install the library:

    spack install nlohmann-json

  3. Load the environment for your Spack-installed packages:

    spack load nlohmann-json

  4. Build the project with CMake:

    cmake -S . -B build -DCMAKE_PREFIX_PATH=$(spack location -i nlohmann-json)
cmake --build build

Hunter

Summary

package: nlohmann_json

If you are using Hunter on your project for external dependencies, then you can use the nlohmann_json package via

hunter_add_package(nlohmann_json)

Please see the Hunter project for any issues regarding the packaging.

Example: CMake with HunterGate

  1. Create the following files:

    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)

include("cmake/HunterGate.cmake")
HunterGate(
    URL "https://github.com/cpp-pm/hunter/archive/v0.23.297.tar.gz"
    SHA1 "3319fe6a3b08090df7df98dee75134d68e2ef5a3"
)

project(json_example)

hunter_add_package(nlohmann_json)
find_package(nlohmann_json CONFIG REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Download required files

    mkdir cmake
wget https://raw.githubusercontent.com/cpp-pm/gate/master/cmake/HunterGate.cmake -O cmake/HunterGate.cmake

  3. Build the project with CMake:

    cmake -S . -B build
cmake --build build

vcpkg

Summary

package: nlohmann-json

If you are using vcpkg on your project for external dependencies, then you can install the nlohmann-json package with

vcpkg install nlohmann-json

and follow the then displayed descriptions. Please see the vcpkg project for any issues regarding the packaging.

Example: CMake with the vcpkg toolchain

  1. Create the following files:

    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

find_package(nlohmann_json CONFIG REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Install package:

    vcpkg install nlohmann-json

  3. Build:

    cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake
cmake --build build

cget

Summary

package: nlohmann/json

  • Available versions: current version and older versions
  • The package is updated with every release.
  • File issues at the cget issue tracker
  • cget website

If you are using cget, you can install the latest master version with

cget install nlohmann/json

A specific version can be installed with cget install nlohmann/json@v3.12.0. Also, the multiple header version can be installed by adding the -DJSON_MultipleHeaders=ON flag (i.e., cget install nlohmann/json -DJSON_MultipleHeaders=ON).

Example: CMake with the cget toolchain

  1. Create the following files:

    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

find_package(nlohmann_json REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Initialize cget

    cget init

  3. Install the library

    cget install nlohmann/json

  4. Build

    cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cget/cget/cget.cmake
cmake --build build

Swift Package Manager

Summary

package: nlohmann/json

If you are using the Swift Package Manager, add this repository as a package dependency and depend on its json product:

dependencies: [
    .package(url: "https://github.com/nlohmann/json", from: "3.12.0")
],
targets: [
    .target(name: "MyTarget", dependencies: [.product(name: "json", package: "json")])
]

The library's own Package.swift publishes single_include/nlohmann (not single_include) as the public headers directory, so include the header without the nlohmann/ prefix:

#include <json.hpp>
Example: a minimal executable package

  1. Create the following files (the source file goes into Sources/json_example/, following Swift Package Manager's directory layout convention):

    Package.swift
    // swift-tools-version: 5.9
import PackageDescription

let package = Package(
    name: "json_example",
    dependencies: [
        .package(url: "https://github.com/nlohmann/json", from: "3.12.0")
    ],
    targets: [
        .executableTarget(
            name: "json_example",
            dependencies: [
                .product(name: "json", package: "json")
            ]
        )
    ]
)
    Sources/json_example/example.cpp
    #include <json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Build and run:

    swift run --build-system native

Warning

On some toolchains, swift run/swift build fail to link an executable target against the header-only json product with an error such as Build input file cannot be found: '.../json.o', because the product itself has no compiled sources; see #4650 and the upstream Swift Package Manager issue. Passing --build-system native (shown above) selects Swift Package Manager's legacy build system, which does not have this problem; depending on the library from a library target instead of an executable is not affected either.

You can also add the dependency from within Xcode via File → Add Package Dependencies… and the same repository URL; see Apple's documentation.

NuGet

Summary

package: nlohmann.json

If you are using NuGet, you can use the package nlohmann.json with

dotnet add package nlohmann.json

NuGet integrates with C++ projects through MSBuild, so it is mainly useful for Visual Studio/MSBuild projects; using it as a dependency from other build systems, such as CMake, is possible but more cumbersome than the other package managers on this page.

Example: Visual Studio project

  1. Right-click the project (any C++ project) in "Solution Explorer" and select "Manage NuGet Packages…"

    Right-clicking a project in Solution Explorer and selecting "Manage NuGet Packages…"

  2. Switch to the "Browse" tab.

  3. Search for nlohmann.json, select it, and click "Install".

    Searching for and selecting the nlohmann.json package in the NuGet package manager

  4. #include <nlohmann/json.hpp> in your code and build the project. The package's build/native/nlohmann.json.targets file adds $(MSBuildThisFileDirectory)include to the project's AdditionalIncludeDirectories, so no further include path configuration is needed.

For further details, see the original discussion this section is based on.

Conda

Summary

package: nlohmann_json

If you are using conda, you can use the package nlohmann_json from conda-forge executing

conda install -c conda-forge nlohmann_json
Example: Raw compilation

  1. Create the following file:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Create and activate an environment json:

    conda create -n json
conda activate json

  3. Install the package:

    conda install -c conda-forge nlohmann_json

  4. Build the code:

    g++ -std=c++11 -I$(conda info --base)/envs/json/include example.cpp -o example

MSYS2

Summary

package: mingw-w64-nlohmann-json

If you are using MSYS2, you can use the mingw-w64-nlohmann-json package; type pacman -S mingw-w64-i686-nlohmann-json or pacman -S mingw-w64-x86_64-nlohmann-json for installation.

Example: Raw compilation

  1. Create the following file:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Install the package (from an MSYS2 MinGW 64-bit shell):

    pacman -S mingw-w64-x86_64-nlohmann-json

  3. Compile the code:

    g++ example.cpp -std=c++11 -o example

MacPorts

Summary

port: nlohmann-json

If you are using MacPorts, execute 

sudo port install nlohmann-json

to install the nlohmann-json package.

Example: Raw compilation

  1. Create the following file:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

  2. Install the package:

    sudo port install nlohmann-json

  3. Compile the code and pass the MacPorts prefix to the include path such that the library can be found:

    c++ example.cpp -I/opt/local/include -std=c++11 -o example
Example: CMake

  1. Create the following files:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}
    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

find_package(nlohmann_json CONFIG REQUIRED)

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)

  2. Install the package:

    sudo port install nlohmann-json

  3. Compile the code:

    cmake -S . -B build
cmake --build build

build2

Summary

package: nlohmann-json library target: nlohmann-json%lib{json} available in package repositories: - cppget.org (recommended) - package's sources (for advanced users)

Note: build2 should not be considered as a standalone package-manager. It is a build-system + package manager + project manager, a set of tools that work hand-in-hand. build2-based projects do not rely on existing CMake scripts and the build scripts defining the project's targets are specific to build2.

To use this package in an existing build2 project, the general steps are:

  1. Make the package available to download from a package repository that provides it.

    Your project's repositories.manifest specifies where the package manager will try to acquire packages by default. Make sure one of the repositories specified in this file provides nlohmann-json package. The recommended open-source repository is cppget.org.

    If the project has been created using bdep new, cppget.org is already specified in repositories.manifest but commented, just uncomment these lines: 

    :
role: prerequisite
location: https://pkg.cppget.org/1/stable

  2. Add this package as dependency of your project.

    In your project's manifest add the dependency to the package using depends: nlohmann-json. You could also add some version constraints. For example, to depend on the latest version available: 

    depends: nlohmann-json

  3. Add this library as dependency of your target that uses it.

    In the buildfile defining the target that will use this library:

    - import the target `lib{json}` from the `nlohmann-json` package, for example:
    ```
    import nljson = nlohmann-json%lib{json}
    ```

- then add the library's target as requirement for your target using it, for example:
    ```
    exe{example} : ... $nljson
    ```

  4. Use the library in your project's code and build it.

    At this point, assuming your project is initialized in a build-configuration, any b or bdep update command that will update/build the project will also acquire the missing dependency automatically, then build it and link it with your target.

    If you just want to synchronize dependencies for all your configurations to download the ones you just added: 

    bdep sync -af

Example: from scratch, using build2's bdep new command

  1. Create a new executable project "example" (see bdep new command details for the various options to create a new project):

    bdep new example

  2. Edit these files by replacing their content:

    • example/repositories.manifest: Enable acquiring packages from https://cppget.org by uncommenting the related lines:

      project's `repositories.manifest`
      : 1
summary: example project repository

:
role: prerequisite
location: https://pkg.cppget.org/1/stable
#trust: ...

#:
#role: prerequisite
#location: https://git.build2.org/hello/libhello.git

    • example/manifest: Add the latest version of the nlohmann-json package as dependency to the project:

      project's `manifest`
      name: example
version: 0.1.0-a.0.z
language: c++
summary: example C++ executable
license: other: proprietary ; Not free/open source.
description-file: README.md
url: https://example.org/example
email: your@emailprovider.com
#build-error-email: your@emailprovider.com
depends: * build2 >= 0.16.0
depends: * bpkg >= 0.16.0
#depends: libhello ^1.0.0

depends: nlohmann-json

    • example/example/buildfile: import the library's target to be used as requirement for building the executable target exe{example}:

      project's `buildfile`
      libs =
import libs = nlohmann-json%lib{json}

exe{example}: {hxx ixx txx cxx}{**} $libs testscript

cxx.poptions =+ "-I$out_root" "-I$src_root"

    • example/example/example.cxx: bdep new generates a "hello world" by default, replace it by this:

      example.cxx
      #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}

    • example/example/testscript: (optional) if you want to be able to test that executable's output is correct using b test:

      `testscript` checking the output of the program
      : json basics
:
$* >>~/EOO/
{
    "compiler": {
/        "c\+\+": "\d+",/
/        "family": "[\w\d]+",/
/        "version": \d+/
    },
/    "copyright": "\(C\) 2013-\d+ Niels Lohmann",/
    "name": "JSON for Modern C++",
/    "platform": "[\w\d]+",/
    "url": "https://github.com/nlohmann/json",
    "version": {
        "major": 3,
/        "minor": \d+,/
/        "patch": \d+,/
/        "string": "3\.\d+\.\d+"/
    }
}
EOO

  3. Initialize the project in a default C/C++ build configuration directory, then build and test:

    cd example/

# create default C/C++ build configuration in ../example-myconfig/, initialize the project in it (downloads it's dependencies in it too)
bdep init -C @myconfig cc

# build only,
b

# or build and test the executable's output, will only work if the `testscript` is correct
b test

CPM.cmake

Summary

package: gh:nlohmann/json

If you are using CPM.cmake, add the CPM.cmake script and the following snippet to your CMake project:

CPMAddPackage("gh:nlohmann/json@3.12.0")
Example: CMake with CPMAddPackage

  1. Create the following files:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}
    CMakeLists.txt
    cmake_minimum_required(VERSION 3.15)
project(json_example)

include(${CMAKE_SOURCE_DIR}/cmake/CPM.cmake)

CPMAddPackage("gh:nlohmann/json@3.12.0")

add_executable(json_example example.cpp)
target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)

  2. Download CPM.cmake

    mkdir -p cmake
wget -O cmake/CPM.cmake https://github.com/cpm-cmake/CPM.cmake/releases/latest/download/get_cpm.cmake

  3. Build

    cmake -S . -B build
cmake --build build

xmake

Summary

package: nlohmann_json

Example: xmake project

  1. Create the following files:

    example.cpp
    #include <nlohmann/json.hpp>
#include <iostream>
#include <iomanip>

using json = nlohmann::json;

int main()
{
    std::cout << std::setw(4) << json::meta() << std::endl;
}
    xmake.lua
    add_requires("nlohmann_json")

add_rules("mode.debug", "mode.release")
target("xm")
    set_kind("binary")
    add_files("example.cpp")
    add_packages("nlohmann_json")
    set_languages("cxx11")

  2. Build

    xmake

  3. Run

    xmake run

Other package managers

The library is also contained in many other package repositories; Repology tracks the packaged versions across repositories.

Buckaroo

If you are using Buckaroo, you can install this library's module with buckaroo add github.com/buckaroo-pm/nlohmann-json. There is a demo repo here.

Warning

The module is outdated as the respective repository has not been updated in years.

CocoaPods

If you are using CocoaPods, you can use the library by adding pod "nlohmann_json", '~>3.1.2' to your podfile (see an example). Please file issues at the repository, as its issue tracker is no longer reachable.

CocoaPods package

Warning

The module is outdated as the respective pod has not been updated in years.

npm

This project does not publish an official npm package. The npm package nlohmann-json (or similarly named packages) is not maintained or endorsed by this project. Use one of the package managers listed above, or integrate the single header directly.

ESP-IDF and PlatformIO

There is no official package published to the ESP-IDF Component Registry or the PlatformIO Registry. A community-maintained fork, Johboh/nlohmann-json, publishes this library to both registries on each new release and can be used as an unofficial component/package for ESP-IDF and PlatformIO projects. As the library is header-only, it can otherwise be used directly by adding its include/ directory to your component's/project's include paths, like any other integration method described on this page.