Repository files navigation

MQTT.js is a client library for theMQTT protocol, writtenin JavaScript for node.js and the browser.

• Upgrade notes
• Installation
• Example
• React Native
• Import Styles
• Command Line Tools
• API
• Browser
• About QoS
• TypeScript
• Weapp and Ali support
• Contributing
• Sponsor
• License

MQTT.js is an OPEN Open Source Project, see theContributing section to find out what this means.

v5.0.0 (07/2023)

• Removes support for all end of life node versions (v12 and v14), and now supports node v18 and v20.
• Completely rewritten in Typescript 🚀.
• When creatingMqttClient instancenew is now required.

v4.0.0 (Released 04/2020) removes support for all end of life node versions, and now supports node v12 and v14. It also adds improvements todebug logging, along with some feature additions.

As abreaking change, by default a error handler is built into the MQTT.js client, so if anyerrors are emitted and the user has not created an event handler on the client for errors, the client willnot break as a result of unhandled errors. Additionally, typical TLS errors likeECONNREFUSED,ECONNRESET have beenadded to a list of TLS errors that will be emitted from the MQTT.js client, and so can be handled as connection errors.

v3.0.0 adds support for MQTT 5, support for node v10.x, and many fixes to improve reliability.

Note: MQTT v5 support is experimental as it has not been implemented by brokers yet.

v2.0.0 removes support for node v0.8, v0.10 and v0.12, and it is 3x faster in sendingpackets. It also removes all the deprecated functionality in v1.0.0,mainlymqtt.createConnection andmqtt.Server. From v2.0.0,subscriptions are restored upon reconnection ifclean: true.v1.x.x is now inLTS, and it will keep being supported as long asthere are v0.8, v0.10 and v0.12 users.

As abreaking change, theencoding option in the old client isremoved, and now everything is UTF-8 with the exception of thepassword in the CONNECT message andpayload in the PUBLISH message,which areBuffer.

Anotherbreaking change is that MQTT.js now defaults to MQTT v3.1.1,so to support old brokers, please read theclient options doc.

v1.0.0 improves the overall architecture of the project, which is nowsplit into three components: MQTT.js keeps the Client,mqtt-connection includes the bareboneConnection code for server-side usage, andmqtt-packetincludes the protocol parser and generator. The new Client improvesperformance by a 30% factor, embeds Websocket support(MOWS is now deprecated), and it has a bettersupport for QoS 1 and 2. The previous API is still supported butdeprecated, as such, it is not documented in this README.

npm install mqtt --save

For the sake of simplicity, let's put the subscriber and the publisher in the same file:

constmqtt=require("mqtt");constclient=mqtt.connect("mqtt://test.mosquitto.org");client.on("connect",()=>{client.subscribe("presence",(err)=>{if(!err){client.publish("presence","Hello mqtt");}});});client.on("message",(topic,message)=>{// message is Bufferconsole.log(message.toString());client.end();});

output:

Hello mqtt

MQTT.js can be used in React Native applications. To use it, see theReact Native example

If you want to run your own MQTT broker, you can useMosquitto orAedes-cli, and launch it.

You can also use a test instance: test.mosquitto.org.

If you do not want to install a separate broker, you can try using theAedes.

constmqtt=require("mqtt")// require mqttconstclient=mqtt.connect("mqtt://test.mosquitto.org")// create a client

importmqttfrom"mqtt";// import namespace "mqtt"letclient=mqtt.connect("mqtt://test.mosquitto.org");// create a client

import{connect}from"mqtt";// import connect from mqttletclient=connect("mqtt://test.mosquitto.org");// create a client

MQTT.js bundles a command to interact with a broker.In order to have it available on your path, you should install MQTT.jsglobally:

npm install mqtt -g

Then, on one terminal

mqtt sub -t'hello' -h'test.mosquitto.org' -v

On another

mqtt pub -t'hello' -h'test.mosquitto.org' -m'from MQTT.js'

Seemqtt help <command> for the command help.

MQTT.js uses thedebug package for debugging purposes. To enable debug logs, add the following environment variable on runtime :

#(example using PowerShell, the VS Code default)$env:DEBUG='mqttjs*'

An important part of any websocket connection is what to do when a connectiondrops off and the client needs to reconnect. MQTT has built-in reconnectionsupport that can be configured to behave in ways that suit the application.

When an mqtt connection drops and needs to reconnect, it's common to requirethat any authentication associated with the connection is kept current withthe underlying auth mechanism. For instance some applications may pass an authtoken with connection options on the initial connection, while other cloudservices may require a url be signed with each connection.

By the time the reconnect happens in the application lifecycle, the originalauth data may have expired.

To address this we can use a hook calledtransformWsUrl to manipulateeither of the connection url or the client options at the time of a reconnect.

Example (update clientId & username on each reconnect):

consttransformWsUrl=(url,options,client)=>{client.options.username=`token=${this.get_current_auth_token()}`;client.options.clientId=`${this.get_updated_clientId()}`;return`${this.get_signed_cloud_url(url)}`;}constconnection=awaitmqtt.connectAsync(<wssurl>,{      ...,transformWsUrl:transformUrl,});

Now every time a new WebSocket connection is opened (hopefully not too often),we will get a fresh signed url or fresh auth token data.

Note: Currently this hook doesnot support promises, meaning that in order touse the latest auth token, you must have some outside mechanism running thathandles application-level authentication refreshing so that the websocketconnection can simply grab the latest valid token or signed url.

When you need to add a custom websocket subprotocol or header to open a connectionthrough a proxy with custom authentication this callback allows you to create your owninstance of a websocket which will be used in the mqtt client.

constcreateWebsocket=(url,websocketSubProtocols,options)=>{constsubProtocols=[websocketSubProtocols[0],'myCustomSubprotocolOrOAuthToken',]returnnewWebSocket(url,subProtocols)}constclient=awaitmqtt.connectAsync(<wssurl>,{    ...,createWebsocket:createWebsocket,});

To ensure that the mqtt client automatically tries to reconnect when theconnection is dropped, you must set the client optionreconnectPeriod to avalue greater than 0. A value of 0 will disable reconnection and then terminatethe final connection when it drops.

The default value is 1000 ms which means it will try to reconnect 1 secondafter losing the connection.

Note that this will only enable reconnects after either a connection timeout, orafter a successful connection. It willnot (by default) enable retryingconnections that are actively denied with a CONNACK error by the server.

To also enable automatic reconnects for CONNACK errors, setreconnectOnConnackError: true.

If the client sets the optionautoUseTopicAlias:true then MQTT.js uses existing topic alias automatically.

example scenario:

1. PUBLISH topic:'t1', ta:1                   (register)2. PUBLISH topic:'t1'       -> topic:'', ta:1 (auto use existing map entry)3. PUBLISH topic:'t2', ta:1                   (register overwrite)4. PUBLISH topic:'t2'       -> topic:'', ta:1 (auto use existing map entry based on the receent map)5. PUBLISH topic:'t1'                         (t1 is no longer mapped to ta:1)

User doesn't need to manage which topic is mapped to which topic alias.If the user want to register topic alias, then publish topic with topic alias.If the user want to use topic alias, then publish topic without topic alias. If there is a mapped topic alias then added it as a property and update the topic to empty string.

If the client sets the optionautoAssignTopicAlias:true then MQTT.js uses existing topic alias automatically.If no topic alias exists, then assign a new vacant topic alias automatically. If topic alias is fully used, then LRU(Least Recently Used) topic-alias entry is overwritten.

example scenario:

The broker returns CONNACK (TopicAliasMaximum:3)1. PUBLISH topic:'t1' ->'t1', ta:1 (auto assign t1:1 and register)2. PUBLISH topic:'t1' ->''  , ta:1 (auto use existing map entry)3. PUBLISH topic:'t2' ->'t2', ta:2 (auto assign t1:2 and register. 2 was vacant)4. PUBLISH topic:'t3' ->'t3', ta:3 (auto assign t1:3 and register. 3 was vacant)5. PUBLISH topic:'t4' ->'t4', ta:1 (LRU entry is overwritten)

Also user can manually register topic-alias pair using PUBLISH topic:'some', ta:X. It works well with automatic topic alias assign.

• mqtt.connect()
• mqtt.connectAsync()
• mqtt.Client()
• mqtt.Client#connect()
• mqtt.Client#publish()
• mqtt.Client#publishAsync()
• mqtt.Client#subscribe()
• mqtt.Client#subscribeAsync()
• mqtt.Client#unsubscribe()
• mqtt.Client#unsubscribeAsync()
• mqtt.Client#end()
• mqtt.Client#endAsync()
• mqtt.Client#removeOutgoingMessage()
• mqtt.Client#reconnect()
• mqtt.Client#handleMessage()
• mqtt.Client#connected
• mqtt.Client#reconnecting
• mqtt.Client#getLastMessageId()
• mqtt.Store()
• mqtt.Store#put()
• mqtt.Store#del()
• mqtt.Store#createStream()
• mqtt.Store#close()

Connects to the broker specified by the given url and options andreturns aClient.

The URL can be on the following protocols: 'mqtt', 'mqtts', 'tcp','tls', 'ws', 'wss', 'wxs', 'alis'. If you are trying to connect to a unix socket just append the+unix suffix to the protocol (ex:mqtt+unix). This will set theunixSocket property automatically.

The URL can also be an object as returned byURL.parse(),in that case the two objects are merged, i.e. you can pass a singleobject with both the URL and the connect options.

You can also specify aservers options with content:[{ host: 'localhost', port: 1883 }, ... ], in that case that array is iteratedat every connect.

For all MQTT-related options, see theClientconstructor.

Asynchronous wrapper around theconnect function.

Returns aPromise that resolves to amqtt.Client instance when the clientfires a'connect' or'end' event, or rejects with an error if the'error'is fired.

Note that themanualConnect option will cause the promise returned by thisfunction to never resolve or reject as the underlying client never fires anyevents.

TheClient class wraps a client connection to anMQTT broker over an arbitrary transport method (TCP, TLS,WebSocket, ecc).Client is anEventEmitter that has it's ownevents

Client automatically handles the following:

• Regular server pings
• QoS flow
• Automatic reconnections
• Start publishing before being connected

The arguments are:

• streamBuilder is a function that returns a subclass of theStream class that supportstheconnect event. Typically anet.Socket.
• options is the client connection options (see: theconnect packet). Defaults:

  • wsOptions: is the WebSocket connection options. Default is{}.It's specific for WebSockets. For possible options have a look at:https://github.com/websockets/ws/blob/master/doc/ws.md.

  • keepalive:60 seconds, set to0 to disable

  • reschedulePings: reschedule ping messages after sending packets (defaulttrue)

  • clientId:'mqttjs_' + Math.random().toString(16).substr(2, 8)

  • protocolId:'MQTT'

  • protocolVersion:4

  • clean:true, set to false to receive QoS 1 and 2 messages whileoffline

  • reconnectPeriod:1000 milliseconds, interval between tworeconnections. Disable auto reconnect by setting to0.

  • reconnectOnConnackError:false, whether to also reconnect if a CONNACKis received with an error.

  • connectTimeout:30 * 1000 milliseconds, time to wait before aCONNACK is received

  • username: the username required by your broker, if any

  • password: the password required by your broker, if any

  • socksProxy: establish TCP and TLS connections via a socks proxy (URL, supported protocols aresocks5://,socks5h://,socks4://,socks4a://)

  • socksTimeout: timeout for connecting to the socks proxy

  • incomingStore: aStore for the incoming packets

  • outgoingStore: aStore for the outgoing packets

  • queueQoSZero: if connection is broken, queue outgoing QoS zero messages (defaulttrue)

  • customHandleAcks: MQTT 5 feature of custom handling puback and pubrec packets. Its callback:

      customHandleAcks:function(topic,message,packet,done){/*some logic with calling done(error, reasonCode)*/}

  • autoUseTopicAlias: enabling automatic Topic Alias using functionality

  • autoAssignTopicAlias: enabling automatic Topic Alias assign functionality

  • properties: properties MQTT 5.0.object that supports the following properties:

    • sessionExpiryInterval: representing the Session Expiry Interval in secondsnumber,
    • receiveMaximum: representing the Receive Maximum valuenumber,
    • maximumPacketSize: representing the Maximum Packet Size the Client is willing to acceptnumber,
    • topicAliasMaximum: representing the Topic Alias Maximum value indicates the highest value that the Client will accept as a Topic Alias sent by the Servernumber,
    • requestResponseInformation: The Client uses this value to request the Server to return Response Information in the CONNACKboolean,
    • requestProblemInformation: The Client uses this value to indicate whether the Reason String or User Properties are sent in the case of failuresboolean,
    • userProperties: The User Property is allowed to appear multiple times to represent multiple name, value pairsobject,
    • authenticationMethod: the name of the authentication method used for extended authenticationstring,
    • authenticationData: Binary Data containing authentication databinary

  • authPacket: settings for auth packetobject

  • will: a message that will sent by the broker automatically whenthe client disconnect badly. The format is:

    • topic: the topic to publish
    • payload: the message to publish
    • qos: the QoS
    • retain: the retain flag
    • properties: properties of will by MQTT 5.0:
      • willDelayInterval: representing the Will Delay Interval in secondsnumber,
      • payloadFormatIndicator: Will Message is UTF-8 Encoded Character Data or notboolean,
      • messageExpiryInterval: value is the lifetime of the Will Message in seconds and is sent as the Publication Expiry Interval when the Server publishes the Will Messagenumber,
      • contentType: describing the content of the Will Messagestring,
      • responseTopic: String which is used as the Topic Name for a response messagestring,
      • correlationData: The Correlation Data is used by the sender of the Request Message to identify which request the Response Message is for when it is receivedbinary,
      • userProperties: The User Property is allowed to appear multiple times to represent multiple name, value pairsobject

  • transformWsUrl : optional(url, options, client) => url functionFor ws/wss protocols only. Can be used to implement signingurls which upon reconnect can have become expired.

  • createWebsocket : optionalurl, websocketSubProtocols, options) => Websocket functionFor ws/wss protocols only. Can be used to implement a custom websocket subprotocol or implementation.

  • resubscribe : if connection is broken and reconnects,subscribed topics are automatically subscribed again (defaulttrue)

  • messageIdProvider: custom messageId provider. whennew UniqueMessageIdProvider() is set, then non conflict messageId is provided.

  • log: custom log function. Default usesdebug package.

  • manualConnect: prevents the constructor to callconnect. In this case after themqtt.connect is called you should callclient.connect manually.

  • timerVariant: defaults toauto, which tries to determine which timer is most appropriate for you environment, if you're having detection issues, you can set it toworker ornative. If none suits you, you can pass a timer object with set and clear properties:

    timerVariant:{set:(func,timer)=>setInterval(func,timer),clear:(id)=>clearInterval(id)}

  • forceNativeWebSocket: set to true if you're having detection issues (i.e. thews does not work in the browser exception) to force the use of native WebSocket. It is important to note that if set to true for the first client created, then all the clients will use native WebSocket. And conversely, if not set or set to false, all will use the detection result.

  • unixSocket: if you want to connect to a unix socket, set this to true

Instead of settingsocksProxy you can also supple the same parameter via the environment variableMQTTJS_SOCKS_PROXY.

In case mqtts (mqtt over tls) is required, theoptions object is passed through totls.connect(). If using aself-signed certificate, setrejectUnauthorized: false. However, be cautious as this exposes you to potential man in the middle attacks and isn't recommended for production.

For those supporting multiple TLS protocols on a single port, like MQTTS and MQTT over WSS, utilize theALPNProtocols option. This lets you define the Application Layer Protocol Negotiation (ALPN) protocol. You can setALPNProtocols as a string array, Buffer, or Uint8Array based on your setup.

If you are connecting to a broker that supports only MQTT 3.1 (not3.1.1 compliant), you should pass these additional options:

{protocolId:'MQIsdp',protocolVersion:3}

This is confirmed on RabbitMQ 3.2.4, and on Mosquitto < 1.3. Mosquittoversion 1.3 and 1.4 works fine without those.

function (connack) {}

Emitted on successful (re)connection (i.e. connack rc=0).

• connack received connack packet. Whenclean connection option isfalse and server has a previous sessionforclientId connection option, thenconnack.sessionPresent flag istrue. When that is the case,you may rely on stored session and prefer not to send subscribe commands for the client.

function () {}

Emitted when a reconnect starts.

function () {}

Emitted after a disconnection.

function (packet) {}

Emitted after receiving disconnect packet from broker. MQTT 5.0 feature.

function () {}

Emitted when the client goes offline.

function (error) {}

Emitted when the client cannot connect (i.e. connack rc != 0) or when aparsing error occurs.

The following TLS errors will be emitted as anerror event:

• ECONNREFUSED
• ECONNRESET
• EADDRINUSE
• ENOTFOUND

function () {}

Emitted whenmqtt.Client#end() is called.If a callback was passed tomqtt.Client#end(), this event is emitted once thecallback returns.

function (topic, message, packet) {}

Emitted when the client receives a publish packet

• topic topic of the received packet
• message payload of the received packet
• packet received packet, as defined inmqtt-packet

function (packet) {}

Emitted when the client sends any packet. This includes .published() packetsas well as packets used by MQTT for managing subscriptions and connections

• packet received packet, as defined inmqtt-packet

function (packet) {}

Emitted when the client receives any packet. This includes packets fromsubscribed topics as well as packets used by MQTT for managing subscriptionsand connections

• packet received packet, as defined inmqtt-packet

By default client connects when constructor is called. To prevent this you can setmanualConnect option totrue and callclient.connect() manually.

Publish a message to a topic

• topic is the topic to publish to,String
• message is the message to publish,Buffer orString
• options is the options to publish with, including:
  • qos QoS level,Number, default0
  • retain retain flag,Boolean, defaultfalse
  • dup mark as duplicate flag,Boolean, defaultfalse
  • properties: MQTT 5.0 propertiesobject
    • payloadFormatIndicator: Payload is UTF-8 Encoded Character Data or notboolean,
    • messageExpiryInterval: the lifetime of the Application Message in secondsnumber,
    • topicAlias: value that is used to identify the Topic instead of using the Topic Namenumber,
    • responseTopic: String which is used as the Topic Name for a response messagestring,
    • correlationData: used by the sender of the Request Message to identify which request the Response Message is for when it is receivedbinary,
    • userProperties: The User Property is allowed to appear multiple times to represent multiple name, value pairsobject,
    • subscriptionIdentifier: representing the identifier of the subscriptionnumber,
    • contentType: String describing the content of the Application Messagestring
  • cbStorePut -function (), fired when message is put intooutgoingStore if QoS is1 or2.
• callback -function (err, packet), fired when the QoS handling completes,or at the next tick if QoS 0. An error occurs if client is disconnecting.

Asyncpublish. Returns aPromise<Packet | undefined>.

Subscribe to a topic or topics

• topic is aString topic to subscribe to or anArray oftopics to subscribe to. It can also be an object, it has as objectkeys the topic name and as value the QoS, like{'test1': {qos: 0}, 'test2': {qos: 1}}.MQTTtopic wildcard characters are supported (+ - for single level and# - for multi level)
• options is the options to subscribe with, including:
  • qos QoS subscription level, default 0
  • nl No Local MQTT 5.0 flag (If the value is true, Application Messages MUST NOT be forwarded to a connection with a ClientID equal to the ClientID of the publishing connection)
  • rap Retain as Published MQTT 5.0 flag (If true, Application Messages forwarded using this subscription keep the RETAIN flag they were published with. If false, Application Messages forwarded using this subscription have the RETAIN flag set to 0.)
  • rh Retain Handling MQTT 5.0 (This option specifies whether retained messages are sent when the subscription is established.)
  • properties:object
    • subscriptionIdentifier: representing the identifier of the subscriptionnumber,
    • userProperties: The User Property is allowed to appear multiple times to represent multiple name, value pairsobject
• callback -function (err, granted)callback fired on suback where:
  • err a subscription error or an error that occurs when client is disconnecting
  • granted is an array of{topic, qos} where:
    • topic is a subscribed to topic
    • qos is the granted QoS level on it

Asyncsubscribe. Returns aPromise<ISubscriptionGrant[]>.

Unsubscribe from a topic or topics

• topic is aString topic or an array of topics to unsubscribe from
• options: options of unsubscribe.
  • properties:object
    • userProperties: The User Property is allowed to appear multiple times to represent multiple name, value pairsobject
• callback -function (err), fired on unsuback. An error occurs if client is disconnecting.

Asyncunsubscribe. Returns aPromise<void>.

Close the client, accepts the following options:

• force: passing it to true will close the client right away, withoutwaiting for the in-flight messages to be acked. This parameter isoptional.
• options: options of disconnect.
  • reasonCode: Disconnect Reason Codenumber
  • properties:object
    • sessionExpiryInterval: representing the Session Expiry Interval in secondsnumber,
    • reasonString: representing the reason for the disconnectstring,
    • userProperties: The User Property is allowed to appear multiple times to represent multiple name, value pairsobject,
    • serverReference: String which can be used by the Client to identify another Server to usestring
• callback: will be called when the client is closed. This parameter isoptional.

Asyncend. Returns aPromise<void>.

Remove a message from the outgoingStore.The outgoing callback will be called with Error('Message removed') if the message is removed.

After this function is called, the messageId is released and becomes reusable.

• mId: The messageId of the message in the outgoingStore.

Connect again using the same options as connect()

Handle messages with backpressure support, one at a time.Override at will, butalways callcallback, or the clientwill hang.

Boolean : set totrue if the client is connected.false otherwise.

Number : get last message id. This is for sent messages only.

Boolean : set totrue if the client is trying to reconnect to the server.false otherwise.

In-memory implementation of the message store.

• options is the store options:
  • clean:true, clean inflight messages when close is called (defaulttrue)

Other implementations ofmqtt.Store:

• mqtt-jsonl-store which usesjsonl-db to store inflight data, it works only on Node.
• mqtt-level-store which usesLevel-browserify to store the inflightdata, making it usable both in Node and the Browser.
• mqtt-nedb-store whichusesnedb to store the inflightdata.
• mqtt-localforage-store which useslocalForage to store the inflightdata, making it usable in the Browser without browserify.

Adds a packet to the store, a packet isanything that has amessageId property.The callback is called when the packet has been stored.

Creates a stream with all the packets in the store.

Removes a packet from the store, a packet isanything that has amessageId property.The callback is called when the packet has been removed.

Closes the Store.

While thews module is used in NodeJS,WebSocket is used in browsers. This is totally transparent to users except for the following:

• ThewsOption is not supported in browsers.

• Browsers doesn't allow to catch many WebSocket errors forsecurity reasons as:

  Access to this information could allow a malicious Web page to gain information about your network, so they require browsers report all connection-time errors in an indistinguishable way.

  So listening forclient.on('error') may not catch all the errors you would get in NodeJS env.

MQTT.js is bundled usingesbuild. It is tested working with all bundlers like Webpack, Vite and React.

You can find all mqtt bundles versions indist folder:

• mqtt.js - iife format, not minified
• mqtt.min.js - iife format, minified
• mqtt.esm.js - esm format minified

Starting from MQTT.js > 5.2.0 you can import mqtt in your code like this:

importmqttfrom'mqtt'

This will be automatically handled by your bundler.

Otherwise you can choose to use a specific bundle like:

import*asmqttfrom'mqtt/dist/mqtt'import*asmqttfrom'mqtt/dist/mqtt.min'importmqttfrom'mqtt/dist/mqtt.esm'

The MQTT.js bundle is available throughhttp://unpkg.com, specificallyathttps://unpkg.com/mqtt/dist/mqtt.min.js.Seehttp://unpkg.com for the full documentation on version ranges.

Here is how QoS works:

• QoS 0 : receivedat most once : The packet is sent, and that's it. There is no validation about whether it has been received.
• QoS 1 : receivedat least once : The packet is sent and stored as long as the client has not received a confirmation from the server. MQTT ensures that itwill be received, but there can be duplicates.
• QoS 2 : receivedexactly once : Same as QoS 1 but there is no duplicates.

About data consumption, obviously, QoS 2 > QoS 1 > QoS 0, if that's a concern to you.

Starting from v5 this project is written in TypeScript and the type definitions are included in the package.

Example:

import{connect}from"mqtt"constclient=connect('mqtt://test.mosquitto.org')

SupportsWeChat Mini Program. Use thewxs protocol. Seethe WeChat docs.

import'abortcontroller-polyfill/dist/abortcontroller-polyfill-only'// import before mqtt.import'esbuild-plugin-polyfill-node/polyfills/navigator'constmqtt=require("mqtt");constclient=mqtt.connect("wxs://test.mosquitto.org",{timerVariant:'native'// more info ref issue: #1797});

SupportsAli Mini Program. Use thealis protocol. Seethe Alipay docs.

constmqtt=require("mqtt");constclient=mqtt.connect("alis://test.mosquitto.org");

MQTT.js is anOPEN Open Source Project. This means that:

Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.

See theCONTRIBUTING.md file for more details.

MQTT.js is only possible due to the excellent work of the following contributors:

If you would like to support MQTT.js, please consider sponsoring the author and active maintainers:

• Matteo Collina: author of MQTT.js
• Daniel Lando: active maintainer

MIT