MQTT Broker Free Tier: How to Compare Free Plans Before You Commit

An MQTT broker free tier lets you build and test a real IoT project on hosted infrastructure without paying anything or running a server. This guide shows you which limits actually matter when you compare free plans, how to test a free tier in ten minutes, and how to avoid picking a plan that blocks you at the exact moment the project starts working.

What an MQTT Broker Free Tier Usually Includes

Almost every managed MQTT service now offers some kind of no-cost entry point. The shape varies, but most free plans fall into one of three patterns:

• A public test broker. Anyone can connect, usually without credentials, and every topic is visible to every other user. Great for learning and quick experiments, unsuitable for anything private.
• A free shared-cluster plan. You get your own credentials on a multi-tenant broker, with quotas on connections, message size and features. This is what most people mean by a free tier.
• A time-limited trial. Full features for a fixed period, after which the broker stops or converts to a paid plan. Useful for evaluation, risky for a long-lived hobby project.

The distinction matters because the first and the third look free but behave differently once you have devices in the field. A public broker never gives you privacy. A trial eventually forces a decision on a deadline you did not choose. A permanent free plan on a shared cluster is the only one of the three you can leave running indefinitely.

If you are still learning what an MQTT broker does, start with a public broker. If you are building something you want to keep, look for a permanent free plan with private credentials.

The Limits That Matter When You Compare Free MQTT Plans

Headline numbers such as "free for up to N devices" hide most of the detail. When you put two free plans side by side, check each of these dimensions on the provider's current documentation rather than relying on a blog post or a forum answer, because quotas change.

Two rows deserve extra attention.

Connections are counted per client, not per device. A single sensor node is one connection, but so is your Node-RED instance, your Grafana data source, your phone app and each open browser tab running an MQTT client. A 25-connection plan comfortably covers a home lab or a small pilot, but count your backend clients as well as your devices.

Message size and QoS are design constraints, not just quotas. If you plan to send camera snapshots, you need to know the maximum payload before you write firmware. If your commands must arrive exactly once, check whether QoS 2 is available on the tier you choose, or design idempotent commands that tolerate QoS 1 duplicates. Our MQTT QoS levels explained article walks through that trade-off.

Public Test Broker vs Free Plan

ConnectMQ offers both a public MQTT test broker at broker.connectmq.com and a free Serverless plan. They solve different problems:

The public broker is ideal for the first afternoon. Once you are sending data you would not post on a public website, such as your home location, energy usage or anything from a customer, move to private credentials.

How to Test a Free Tier in Ten Minutes

Before committing firmware to any provider, run the same quick test on each candidate. It checks connectivity, TLS, round-trip behavior and whether the limits are enforced the way the documentation says.

Step 1: Connect anonymously to the public broker

Use the Mosquitto command-line clients and a random topic prefix so you do not collide with anyone else.

# Terminal 1: subscribe
mosquitto_sub -h broker.connectmq.com -p 1883 -i freetier-sub-7k2q \
  -t "connectmq/demo/7k2q/#" -v

# Terminal 2: publish
mosquitto_pub -h broker.connectmq.com -p 1883 -i freetier-pub-7k2q \
  -t "connectmq/demo/7k2q/temp" -m '{"c":21.4}'

Step 2: Repeat with your free plan credentials over TLS

After you sign up and create a broker in the portal, copy the generated credentials and connect on port 8883.

mosquitto_sub -h broker.connectmq.com -p 8883 --capath /etc/ssl/certs \
  -u YOUR_USERNAME -P YOUR_PASSWORD -i YOUR_CLIENT_ID \
  -t "home/#" -v -V mqttv5

On Windows or macOS, replace --capath /etc/ssl/certs with --cafile pointing to a CA bundle that includes the Let's Encrypt roots.

Step 3: Probe the payload limit

Generate a payload just under and just over the documented size and see what happens. A well-behaved broker on MQTT 5 should reject the oversized publish or disconnect with a reason code rather than silently dropping it.

import os
import paho.mqtt.client as mqtt

def on_connect(client, userdata, flags, reason_code, properties):
    print("connected:", reason_code)
    for size_kb in (200, 300):
        payload = os.urandom(size_kb * 1024)
        info = client.publish("home/limit-test", payload, qos=1)
        print(f"queued {size_kb} KB, mid={info.mid}")

def on_publish(client, userdata, mid, reason_code, properties):
    print("ack for mid", mid, reason_code)

def on_disconnect(client, userdata, flags, reason_code, properties):
    print("disconnected:", reason_code)

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2,
                     client_id="YOUR_CLIENT_ID", protocol=mqtt.MQTTv5)
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()
client.on_connect = on_connect
client.on_publish = on_publish
client.on_disconnect = on_disconnect
client.connect("broker.connectmq.com", 8883)
client.loop_forever()

Watching how a provider signals a limit tells you a lot about how painful debugging will be later. Explicit reason codes are far easier to handle in firmware than silent drops.

Step 4: Check the tooling

A free plan is more useful when you can see what is happening. In the ConnectMQ portal you can open the in-browser MQTT client, watch the live topic explorer and check the dashboard while your test runs. Compare that with whatever visibility the other candidates give you.

Choosing a Free Tier That Will Not Box You In

The cheapest mistake is picking a free tier that works today. The expensive mistake is picking one that forces a migration in six months. Use this checklist before you flash firmware to more than a handful of devices:

1. Count every client. Devices, gateways, dashboards, scripts and test tools all hold connections.
2. Write down your largest payload. Include worst cases such as a backlog flush after an outage.
3. Decide which messages need QoS 1 or 2. Commands usually need at least QoS 1.
4. Confirm the transports you need. Browser dashboards need Secure WebSocket; constrained devices may prefer plain TLS on 8883.
5. Check the upgrade path. Moving from free to paid on the same provider should not change your hostname, port or topic structure.
6. Read the expiry terms. Know whether the free plan is permanent, and what happens to an idle broker.
7. Keep credentials out of firmware source control. Free credentials still protect real data.

The fifth point is where many projects get stuck. A free plan that lives on a completely separate product from the paid tiers means re-provisioning every device when you grow. With ConnectMQ, the free Serverless plan sits at the bottom of the same ladder as the paid Serverless, Dedicated and BYOC options, so upgrading keeps you on the same portal, protocols and topic design rather than forcing a move to a different platform. For the bigger cost picture, read MQTT broker pricing and moving an MQTT prototype to production.

When You Have Outgrown the Free Tier

Signs it is time to move up:

• You are approaching the connection ceiling and still adding devices.
• You need QoS 2 for commands or larger payloads up to 1 MB.
• You want several backend consumers to share a stream using shared subscriptions.
• Customers or colleagues depend on the system and you need isolation from other tenants.

The paid Serverless plan covers the first three with up to 1,000 connections, QoS 2, 1 MB messages and shared subscriptions. Isolation from other tenants' workloads is what the Dedicated and BYOC plans are for. Our guide to MQTT broker connection quotas explains how to design clients that stay inside whichever plan you pick, and the cloud MQTT broker guide covers the wider hosting landscape.

Start on the ConnectMQ Free Tier

ConnectMQ is a fully managed MQTT broker with a free Serverless plan that supports MQTT 3.1.1 and 5.0, TLS and Secure WebSocket out of the box. Create an account at app.connectmq.com, choose the free plan, create a broker and copy your generated credentials. No credit card is required, and you can move to a paid plan when the project grows.

Frequently Asked Questions

Is a free MQTT broker plan safe for production?

A free plan with private credentials and TLS is fine for personal projects and small pilots. For customer-facing systems, choose a paid tier that matches your connection count and isolation needs.

How many devices can I connect on the free Serverless plan?

The Serverless (Free) plan allows up to 25 concurrent connections. Remember that dashboards, scripts and browser clients count toward that number as well as devices.

What is the difference between the public broker and the free plan?

The public broker at broker.connectmq.com is anonymous and readable by everyone, so it suits tests and tutorials. The free plan gives you generated credentials and a private broker for your own data.

Do I need to change my firmware when I upgrade from the free tier?

Staying with the same provider keeps your protocols, ports and topic structure unchanged, so at most you update the credentials or endpoint shown in the portal. Switching providers usually means re-provisioning hostnames and credentials on every device, which is why the upgrade path is worth checking early.