O limite de tamanho de mensagem MQTT na especificação é de cerca de 256 MB por pacote, mas o limite que realmente importa é o definido pelo seu broker, pela sua biblioteca de cliente e pela memória do seu dispositivo, que costuma ser muito menor. Este guia explica cada um desses limites, o que acontece quando uma mensagem é grande demais e três estratégias para transportar payloads grandes, como imagens de câmeras de inspeção, logs de CLP ou firmware, sem derrubar suas conexões MQTT.
O Teto do Protocolo: 256 MB
O MQTT codifica o tamanho do variable header e do payload de cada pacote em um campo "remaining length" de até quatro bytes, com sete bits úteis cada. O maior valor que cabe é 268.435.455 bytes, aproximadamente 256 MB. Descontando o nome do topic e os cabeçalhos, esse é o payload máximo teórico. A codificação é explicada byte a byte no guia sobre a estrutura de pacotes MQTT.
Ninguém roda sistemas em produção perto desse teto. Um broker que aceitasse mensagens de 256 MB de qualquer cliente seria fácil de esgotar: ele precisa colocar o pacote em buffer, possivelmente armazená-lo para sessões offline ou como valor retido, e copiá-lo para cada assinante. O MQTT foi projetado para muitas mensagens pequenas, e cada camada de uma implantação real reflete isso.
Onde Estão os Limites Reais
| Camada | Limite típico | Quem define |
|---|---|---|
| Especificação MQTT | 268.435.455 bytes por pacote | Codificação do remaining length |
| Broker | Tamanho máximo de mensagem ou pacote configurado | Configuração ou plano do broker |
| Negociação MQTT 5 | Property Maximum Packet Size | Cliente e broker anunciam o que aceitam |
| Biblioteca de cliente | Tamanho do buffer interno | Padrões da biblioteca, por exemplo 256 bytes no Arduino PubSubClient |
| Dispositivo | RAM livre | Um microcontrolador pode ter apenas dezenas de KB disponíveis |
| Rede | Vazão e estabilidade | Mensagens grandes demoram mais e falham com mais frequência em links fracos |
O menor limite da cadeia é o que vale. Um broker que aceita 1 MB é irrelevante se um assinante ESP8266 só consegue armazenar alguns kilobytes em buffer. Se você trabalha com hardware da classe Arduino, o guia sobre o tamanho do buffer do PubSubClient trata dessa armadilha específica.
Limites de Tamanho de Mensagem MQTT na ConnectMQ
Estes são os limites atuais por tipo de broker:
| Broker | Tamanho máximo de mensagem |
|---|---|
| Servidor MQTT público (broker.connectmq.com) | 64 KB |
| Plano Serverless (Free) | 256 KB |
| Plano Serverless (Paid) | 1 MB |
| Dedicated, BYOC e Self Managed Enterprise | Depende da implantação |
Para a maioria das telemetrias, alarmes e comandos, até 64 KB é generoso: uma leitura de sensor em JSON costuma ficar bem abaixo de 1 KB. Se você se aproxima desses limites com frequência, geralmente é sinal de que o payload deveria estar em outro lugar, como descrito a seguir.
Maximum Packet Size no MQTT 5
O MQTT 5 tornou os limites de tamanho explícitos com a property Maximum Packet Size (0x27):
- No CONNECT, o cliente informa ao broker o maior pacote que está disposto a receber. O broker não pode enviar nada maior; em vez disso, descarta essas mensagens para aquele cliente.
- No CONNACK, o broker informa ao cliente o maior pacote que aceita. Um cliente que envia mais do que isso viola o protocolo.
Observe que esse é o tamanho do pacote inteiro, incluindo fixed header, topic e properties, e não apenas do payload. Deixe uma margem.
Lendo o limite do broker no MQTT.js:
const mqtt = require("mqtt");
const client = mqtt.connect("mqtts://broker.connectmq.com:8883", {
clientId: "size-check-8b4d",
protocolVersion: 5,
properties: { maximumPacketSize: 64 * 1024 }, // o que este cliente aceita
});
client.on("connect", (connack) => {
const max = connack.properties?.maximumPacketSize;
console.log("Broker maximum packet size:", max ?? "not announced");
client.end();
});
Se a property estiver ausente, o broker não anunciou um limite no CONNACK, mas ainda pode aplicar um. Sempre conheça o limite documentado do seu broker.
O Que Acontece Quando uma Mensagem É Grande Demais
O comportamento depende da versão do protocolo e da direção:
- Cliente para broker, MQTT 5. O broker normalmente desconecta o cliente com o reason code
0x95 Packet too large. - Cliente para broker, MQTT 3.1.1. Não há reason code; o broker fecha a conexão. O cliente vê uma perda de conexão genérica.
- Broker para cliente. Se um assinante anunciou um Maximum Packet Size menor, o broker descarta a mensagem para esse assinante. No 3.1.1, a biblioteca do assinante pode falhar ao fazer o parsing ou se desconectar.
- Dentro do cliente. Algumas bibliotecas se recusam a enviar e retornam um erro; o Arduino PubSubClient simplesmente retorna
falseempublish().
O padrão perigoso é um cliente que coloca a mensagem grande demais na fila, reconecta e tenta reenviá-la imediatamente. O resultado é um loop de desconexão, um dos motivos clássicos pelos quais um cliente MQTT fica desconectando. Valide o tamanho antes de publicar e descarte ou redirecione mensagens grandes demais.
Estratégias para Payloads Grandes
1. Diminua o Payload
Antes de dividir qualquer coisa, reduza o tamanho. Os nomes de campos em JSON se repetem em cada mensagem; chaves curtas, codificações binárias como CBOR ou Protobuf e compressão gzip costumam reduzir os payloads drasticamente. Enviar apenas os valores alterados em vez do estado completo também ajuda. O guia sobre o formato de payload MQTT compara as opções.
2. Divida a Mensagem em Partes
Quando um payload é moderadamente grande, por exemplo algumas centenas de kilobytes de logs, você pode dividi-lo em partes numeradas e remontá-las no lado receptor. Este publicador em Python divide um arquivo em partes de 32 KB com um pequeno cabeçalho JSON em cada parte:
import base64, hashlib, json, math, time, uuid
import paho.mqtt.client as mqtt
CHUNK = 32 * 1024
TOPIC = "connectmq/demo/8b4d/files"
def send_file(client, path):
data = open(path, "rb").read()
transfer_id = uuid.uuid4().hex[:8]
total = math.ceil(len(data) / CHUNK)
sha = hashlib.sha256(data).hexdigest()
for i in range(total):
part = data[i * CHUNK:(i + 1) * CHUNK]
msg = {"id": transfer_id, "seq": i, "total": total, "sha256": sha,
"data": base64.b64encode(part).decode()}
client.publish(f"{TOPIC}/{transfer_id}", json.dumps(msg), qos=1).wait_for_publish()
time.sleep(0.15) # respeita os limites de taxa por cliente
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="chunker-8b4d")
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_start()
send_file(client, "report.csv")
client.loop_stop()
client.disconnect()
O Base64 acrescenta cerca de um terço ao tamanho, então 32 KB de dados binários viram aproximadamente 43 KB na rede, confortavelmente abaixo do limite de 64 KB do servidor MQTT público. O assinante agrupa as partes por id, ordena por seq e verifica o SHA-256 quando todas as total partes chegam. Use QoS 1 para que nenhuma parte se perca silenciosamente e projete o sistema para lidar com duplicatas e partes ausentes usando um timeout. No servidor MQTT público, lembre-se do limite de 10 mensagens por segundo, que é o que o sleep resolve.
O chunking adiciona complexidade, então reserve-o para payloads grandes demais para uma única mensagem, mas pequenos o bastante para que o MQTT continue sendo o transporte certo.
3. Envie o Arquivo Fora de Banda
Para imagens, vídeos, imagens de firmware e exportações grandes, o padrão mais robusto é manter os bytes totalmente fora do MQTT. Faça upload do arquivo para um object storage ou servidor web via HTTPS e publique uma pequena mensagem MQTT que aponte para ele:
{
"type": "firmware",
"version": "2.4.1",
"url": "https://files.example.com/fw/sensor-2.4.1.bin",
"sha256": "9f2c...e81a",
"size": 1048576
}
Os dispositivos baixam o arquivo com requisições HTTP range e suporte a retomada, verificam o hash e informam o progresso de volta via MQTT. Você mantém os pontos fortes do MQTT, notificação instantânea e distribuição para muitos dispositivos, enquanto o HTTP e os serviços de armazenamento cuidam da transferência em massa.
Checklist para Decidir pelo Tamanho
- Abaixo de 10 KB: envie como uma mensagem, sem tratamento especial.
- De 10 KB até o limite do seu broker: comprima ou use uma codificação compacta e confirme que todos os assinantes conseguem armazená-la em buffer.
- Acima do limite, mas só de vez em quando: divida em partes com números de sequência e checksums.
- Arquivos binários grandes ou transferências em massa frequentes: faça upload fora de banda e publique uma referência.
- Em todos os casos: verifique o tamanho no código antes de chamar o publish.
Envie Mensagens na ConnectMQ
A ConnectMQ oferece limites claros por plano, de mensagens de 256 KB no plano Serverless gratuito a 1 MB no plano Serverless pago, com as opções Dedicated, BYOC e Self Managed Enterprise para implantações maiores. Experimente primeiro no servidor MQTT público (gratuito), pensado para testes e protótipos e não para dados de produção, e depois passe para um broker MQTT gerenciado quando precisar de credenciais privadas e limites maiores. O tutorial de MQTT cobre os fundamentos se você está começando agora.
Comece com a ConnectMQ
Crie um broker Serverless gratuito em app.connectmq.com, sem cartão de crédito, e obtenha usuário, senha e client ID em minutos. Para comparar opções de hospedagem, leia nosso guia sobre como escolher um broker MQTT na nuvem.
Perguntas frequentes
Qual é o tamanho máximo de uma mensagem MQTT?
O protocolo permite pacotes de até 268.435.455 bytes, cerca de 256 MB. Na prática, os brokers definem limites bem menores; na ConnectMQ são 64 KB no servidor MQTT público, 256 KB no plano gratuito e 1 MB no plano Serverless pago.
O que acontece se eu publicar uma mensagem grande demais?
O broker a rejeita, geralmente fechando a conexão. Clientes MQTT 5 recebem o reason code 0x95 Packet too large, enquanto clientes MQTT 3.1.1 apenas veem a conexão cair.
Devo enviar arquivos por MQTT?
Arquivos pequenos podem ser enviados diretamente ou em partes. Para arquivos grandes, faça upload via HTTPS para um armazenamento e publique uma pequena mensagem MQTT com a URL e o checksum.
O limite de tamanho inclui o nome do topic?
Os limites dos brokers costumam ser expressos por mensagem ou por pacote, e o Maximum Packet Size do MQTT 5 conta o pacote inteiro, incluindo topic e properties. Deixe uma margem acima do tamanho do seu payload.
