paho-mqtt-cpp repository

Repository Summary

Checkout URI
VCS Type git
VCS Version master
Last Updated 2021-04-30
CI status No Continuous Integration
Tags No category tags.
Contributing Help Wanted (0)
Good First Issues (0)
Pull Requests to Review (0)


No packages found.


Eclipse Paho MQTT C++ Client Library

Build Status

This repository contains the source code for the Eclipse Paho MQTT C++ client library on memory-managed operating systems such as Linux/Posix and Windows.

This code builds a library which enables C++11 applications to connect to an MQTT broker, publish messages to the broker, and to subscribe to topics and receive published messages.

The library has the following features:

  • Support for MQTT v3.1, v3.1.1, and v5.
  • Network Transports:
    • Standard TCP
    • Secure sockets with SSL/TLS
    • WebSockets
      • Secure and insecure
      • Proxy support
  • Message persistence
    • User configurable
    • Built-in File persistence
    • User-defined key/value persistence easy to implement
  • Automatic Reconnect
  • Offline Buffering
  • High Availability
  • Blocking and non-blocking API's
  • Modern C++ interface (C++11 and better)

This code requires the Paho C library by Ian Craggs, et al., specifically version 1.3.8 or possibly later.

Latest News

To keep up with the latest announcements for this project, or to ask questions:

Twitter: @eclipsepaho and @fmpagliughi

EMail: Eclipse Paho Mailing List

Mattermost: Eclipse Mattermost Paho Channel

Unreleased features in this branch

  • Added Session Expiry Interval to v5 chat sample
  • Minor tweaks to prepare for C++20
  • Minor cleanup of the tests #317 String constructor using just len instead of end iterator. #337 Copy and move constructors/assignment of ssl_options not handling CA path.

What's new in Version 1.2.0

This release brings in some missing MQTT v5 features, support for websocket headers and proxies, ALPN protocol lists, adds the builder pattern for options, and fixes a number of bugs in both the C++ library and the underlying C lib.

Requires Paho C v1.3.8

  • Missing MQTT v5 features:
    • Ability to add properties to Subscribe and Unsubscribe packets (i.e. subscription identifiers)
    • "Disconnected" callback gives reason code and properties for server disconnect
  • New create_options that can be used to construct a client with new features:
    • Send while disconnected before the 1st successful connection
    • Output buffer can delete oldest messages when full
    • Can choose to clear the persistence store on startup
    • Select whether to persist QoS 0 messages
  • Started classes to create options using the Builder Pattern, with the create_options_builder, connect_options_builder, message_ptr_builder, etc.
  • User-defined websocket HTTP headers.
  • HTTP/S proxy support
  • Added ALPN protocol support to SSL/TLS options
  • SSL/TLS error and PSK callback support
  • Update connection callback support (change credentials when using auto-reconnect)
  • Updates to the sample apps:
    • Overall cleanup with better consistency
    • Example of using websockets and a proxy
    • User-based file persistence with simple encoding/encryption
    • Sharing a client between multiple threads
  • Converted the unit tests to use Catch2
  • All library exceptions are now properly derived from the mqtt::exception base class.
  • [#231] Added on_disconnected callback to handle receipt of disconnect packet from server.
  • [#211, #223, #235] Removed use of Log() function from the Paho C library.
  • [#227] Fixed race condition in thread-safe queue
  • [#224] & [#255] Subscribing to MQTT v3 broker with array of one topic causes segfault.
  • [#282] Ability to build Debian/Ubuntu package
  • [#300] Calling reconnect() was hanging forever, even when successful. In addition several of the synchronous client calls were hanging forever on failure. They now properly throw a timeout_error exception.
  • Several memory issues and bug fixes from updated Paho C library support.

Catch2 Unit Tests

Unit tests were converted to use Catch2 for the test framework.

Catch2 can be found here: Catch2


Contributions to this project are gladly welcomed and appreciated Before submitting a Pull Request, please keep three things in mind:

  • This is an official Eclipse project, so it is required that all contributors sign an Eclipse Contributor Agreement (ECA)
  • Please submit all Pull Requests against the develop branch (not master).
  • Please sign all commits.

For full details, see

Building from source

CMake is a cross-platform build system suitable for Unix and non-Unix platforms such as Microsoft Windows. It is now the only supported build system.

The Paho C++ library requires the Paho C library, v1.3.8 or greater, to be built and installed first. More information below.

CMake allows for options to direct the build. The following are specific to Paho C++:

Variable Default Value Description
PAHO_BUILD_SHARED TRUE (Linux), FALSE (Win32) Whether to build the shared library
PAHO_BUILD_STATIC FALSE (Linux), TRUE (Win32) Whether to build the static library
PAHO_BUILD_DOCUMENTATION FALSE Create and install the HTML based API documentation (requires Doxygen)
PAHO_BUILD_SAMPLES FALSE Build sample programs
PAHO_BUILD_TESTS FALSE Build the unit tests. (This requires Catch2)
PAHO_WITH_SSL TRUE (Linux), FALSE (Win32) Flag that defines whether to build ssl-enabled binaries too
PAHO_BUILD_DEB_PACKAGE FALSE Flag that configures cpack to build a Debian/Ubuntu package

In addition, the C++ build might commonly use CMAKE_PREFIX_PATH to help the build system find the location of the Paho C library.

Unix and Linux

On *nix systems CMake creates Makefiles.

The build process currently supports a number of Unix and Linux flavors. The build process requires the following tools:

  • CMake v3.5 or newer
  • GCC v4.8 or newer or Clang v3.9 or newer
  • GNU Make

On Debian based systems this would mean that the following packages have to be installed:

$ sudo apt-get install build-essential gcc make cmake cmake-gui cmake-curses-gui

If you will be using secure sockets (and you probably should):

$ sudo apt-get install libssl-dev 

Building the documentation requires doxygen and optionally graphviz to be installed:

$ sudo apt-get install doxygen graphviz

Unit tests are being built using Catch2.

Catch2 can be found here: Catch2. You must download and install Catch2 to build and run the unit tests locally.

Building the Paho C library

Before building the C++ library, first, build and install the Paho C library, if not already present. Note, this version of the C++ library requires Paho C v1.3.8 or greater.

$ git clone
$ cd paho.mqtt.c
$ git checkout v1.3.8

$ sudo cmake --build build/ --target install
$ sudo ldconfig

This builds with SSL/TLS enabled. If that is not desired, omit the -DPAHO_WITH_SSL=ON.

It also uses the "high performace" option of the C library to disable more extensive internal memory checks. Remove the PAHO_HIGH_PERFORMANCE option (i.e. turn it off) to debug memory issues, but for most production systems, leave it on for better performance.

To install the library to a non-standard location, use the CMAKE_INSTALL_PREFIX to specify a location. For example, to install into under the build directory, perhaps for local testing, do this:


Building the Paho C++ library

An example CMake build session might look like this:

$ git clone
$ cd paho.mqtt.cpp

$ cmake -Bbuild -H. -DPAHO_BUILD_STATIC=ON \
$ sudo cmake --build build/ --target install
$ sudo ldconfig

If you did not install Paho C library to a default system location or you want to build against a different version, use the CMAKE_PREFIX_PATH to specify its install location. Perhaps something like this:


To use another compiler, either the CXX environment variable can be specified in the configuration step:

$ CXX=clang++ cmake ..

or the CMAKE_CXX_COMPILER flag can be used:

$ cmake -DCMAKE_CXX_COMPILER=clang++

Building a Debian/Ubuntu package

$ cmake --build build
$ (cd build && cpack)

will generate a .deb file.


On Windows systems CMake creates Visual Studio project files.

The build process currently supports a number Windows versions. The build process requires the following tools: * CMake GUI v3.5 or newer * Visual Studio 2015 or newer

First install and open the cmake-gui application. This tutorial is based on cmake-gui 3.5.2.

Second, select the path to the Paho MQTT C library (CMAKE_PREFIX_PATH) if not installed in a standard path. Remember that the Paho MQTT C must be installed on the system. Next, choose if it is supposed to build the documentation (PAHO_BUILD_DOCUMENTATION) and/or the sample applications (PAHO_BUILD_SAMPLES).

Once the configuration is done, click on the Configure button, select the version of the Visual Studio, and then click on Generate button.

At the end of this process you have a Visual Studio solution.

Alternately, the libraries can be completely built at an MSBuild Command Prompt. Download the Paho C and C++ library sources, then open a command window and first compile the Paho C library:

> cd paho.mqtt.c
> cmake -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-c
> cmake --build build/ --target install

Then build the C++ library:

> cd ..\paho.mqtt.cpp
> cmake --build build/ --target install

This builds and installs both libraries to a non-standard location under C:\mqtt. Modify this location as desired or use the default location, but either way, the C++ library will most likely need to be told where the C library was built using CMAKE_PREFIX_PATH.

It seems quite odd, but even on a 64-bit system using a 64-bit compiler, MSVC seems to default to a 32-bit build target.

The 64-bit target can be selected using tge CMake generator switch, -G, at configuration time. The full version must be provided. For Visual Studio 2015 which is v14 do this to first build the Paho C library:

> cmake -G "Visual Studio 14 Win64" -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-c

Then use it to build the C++ library:

> cmake -G "Visual Studio 14 Win64" -Bbuild -H. -DCMAKE_INSTALL_PREFIX=C:\mqtt\paho-cpp -DPAHO_WITH_SSL=OFF -DCMAKE_PREFIX_PATH=C:\mqtt\paho-c

Note that it is very important that you use the same generator (target) to build BOTH libraries, otherwise you will get lots of linker errors when you try to build the C++ library.

Supported Network Protocols

The library supports connecting to an MQTT server/broker using TCP, SSL/TLS, and websockets (secure and unsecure). This is chosen by the URI supplied to the connect() call. It can be specified as:

"tcp://<host>:<port>"  - TCP (unsecure)
"ssl://<host>:<port>"  - SSL/TLS
"ws://<host>:<port>"   - Unsecure websockets
"wss://<host>:<port>"  - Secure websockets

Note that to use "ssl://" or "wss://" you must compile the library with OpenSSL, and you must supply a set of ssl_options with the connect_options.


Sample applications can be found in the source repository at src/samples:

This is a partial example of what a typical example might look like:

int main(int argc, char* argv[])
    sample_mem_persistence persist;
    mqtt::client cli(ADDRESS, CLIENT_ID, &persist);

    callback cb;

    auto connOpts = mqtt::connect_options_builder() 

    try {

        // First use a message pointer.

        mqtt::message_ptr pubmsg = mqtt::make_message(PAYLOAD1);
        cli.publish(TOPIC, pubmsg);

        // Now try with itemized publish.

        cli.publish(TOPIC, PAYLOAD2, strlen(PAYLOAD2)+1, 0, false);

        // Disconnect

    catch (const mqtt::persistence_exception& exc) {
        cerr << "Persistence Error: " << exc.what() << " ["
            << exc.get_reason_code() << "]" << endl;
        return 1;
    catch (const mqtt::exception& exc) {
        cerr << "Error: " << exc.what() << " ["
            << exc.get_reason_code() << "]" << endl;
        return 1;

    return 0;

The original API organization and documentation were adapted from:

The Paho Java library by Dave Locke et al. Copyright (c) 2012, IBM Corp

All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at

This code requires:

The Paho C library by Ian Craggs Copyright (c) 2013-2018, IBM Corp.

All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 and Eclipse Distribution License v1.0 which accompany this distribution.

The Eclipse Public License is available at and the Eclipse Distribution License is available at


Contributing to Paho

Thanks for your interest in this project!

You can contribute bugfixes and new features by sending pull requests through GitHub.

In order for your contribution to be accepted, it must comply with the Eclipse Foundation IP policy.

Please read the Eclipse Foundation policy on accepting contributions via Git.

  1. Sign the Eclipse ECA
    1. Register for an Eclipse Foundation User ID. You can register here.
    2. Log into the Eclipse projects forge, and click on 'Eclipse Contributor Agreement'.
  2. Go to your account settings and add your GitHub username to your account.
  3. Make sure that you sign-off your Git commits in the following format:

Signed-off-by: Alex Smith <> This is usually at the bottom of the commit message. You can automate this by adding the '-s' flag when you make the commits. e.g.
git commit -s -m "Adding a cool feature" 4. Ensure that the email address that you make your commits with is the same one you used to sign up to the Eclipse Foundation website with.

Contributing a change

  1. Fork the repository on GitHub
  2. Clone the forked repository onto your computer: git clone<your username>/paho.mqtt.cpp.git 3. Create a new branch from the latest develop branch with git checkout -b YOUR_BRANCH_NAME origin/develop 4. Make your changes 5. If developing a new feature, make sure to include unit tests. 6. Ensure that all new and existing tests pass. 7. Commit the changes into the branch: git commit -s Make sure that your commit message is meaningful and describes your changes correctly. 8. If you have a lot of commits for the change, squash them into a single / few commits. 9. Push the changes in your branch to your forked repository. 10. Finally, go to and create a pull request from your "YOUR_BRANCH_NAME" branch to the develop one to request review and merge of the commits in your pushed branch.

What happens next depends on the content of the patch. If it is 100% authored by the contributor and is less than 1000 lines (and meets the needs of the project), then it can be pulled into the main repository. If not, more steps are required. These are detailed in the legal process poster.

Developer resources:

Information regarding source code management, builds, coding standards, and more.


Contact the project developers via the project's development mailing list.

Search for bugs:

This project uses GitHub Issues here: to track ongoing development and issues.

Create a new bug:

Be sure to search for existing bugs before you create another one. Remember that contributions are always welcome!