# MQRC 2030: Message too large for the queue Source: https://wndsoftware.com/mainframe-errors/mqrc-2030 ### MQRC 2030: Message too large for the queue MQRC 2030 (MQRC_MSG_TOO_BIG_FOR_Q, hex 07EE) means an MQPUT or MQPUT1 failed because the message is longer than the queue's maximum message length (MAXMSGL) and the queue manager couldn't split it into segments. #### Other names for this code Also written as `RC2030`, `reason code 2030`, `MQ 2030`, `MQ error 2030`, `MQRC_MSG_TOO_BIG_FOR_Q`, `07EE`, `0x07EE`, `message too big for queue`, `MAXMSGL`, `MQJE001 Reason 2030`. ### What it means Each queue has a MAXMSGL attribute, and so does the queue manager. A message put without segmentation can't be longer than the smaller of the two. If it is, the put fails with MQCC_FAILED and reason 2030, and nothing is written to the queue. On distributed MQ, an application can set MQMF_SEGMENTATION_ALLOWED in the MsgFlags field of the MQMD. The queue manager then splits a long message into segments that fit. Segmentation can still fail if the segments would be too small to hold the data, so 2030 is still possible with the flag set. IBM MQ for z/OS doesn't support segmentation. It accepts the flag and ignores it, so on z/OS the message must fit the limits as it is. The code also turns up on channels. When a message channel agent can't put an arriving message on the target queue because it is too long, the reason goes into the Feedback field of a report message, or into the dead-letter header if the message goes to the dead-letter queue. ### Common causes - The application sends a larger payload than the queue was sized for, such as a file, an image or a batch of records in one message. The default MAXMSGL on a new queue is 4 MB. - The local queue allows the size, but the target queue on the remote queue manager has a lower MAXMSGL. The receiving channel then reports 2030 and sends the message to its dead-letter queue. - The queue's MAXMSGL was raised but the queue manager's MAXMSGL was not. The smaller limit still applies, so the put can fail with 2030 or with 2031. - The program passes a wrong BufferLength, larger than the real data, so MQ sees a much longer message than intended. - On z/OS, the queue is a shared queue in a coupling facility structure that can't hold the message size. Shared queue messages over about 63 KB need a structure at CFLEVEL(4) or later with offload to SMDS or Db2. ### How to find the problem - Check the limits on both objects with `DISPLAY QLOCAL(PAYMENTS.OUT) MAXMSGL` and `DISPLAY QMGR MAXMSGL` in runmqsc. On z/OS use the same commands with the command prefix. - Log the message length the program passes on MQPUT. Compare it with both limits and with what the program meant to send. - If the failure is on a channel, look at the dead-letter queue on the receiving side. The MQDLH header holds reason 2030 and the original destination. Browse it with `amqsbcg` or `dmpmqmsg` on distributed MQ. - For a shared queue on z/OS, display the queue's CFSTRUCT and then `DISPLAY CFSTRUCT(...)` to check CFLEVEL and OFFLOAD. ### How to fix it - Check BufferLength first. If it is wrong, fix the program and nothing else needs to change. - If large messages are expected, raise the queue's MAXMSGL with `ALTER QLOCAL(...) MAXMSGL(n)`. Raise the queue manager's MAXMSGL and every channel's MAXMSGL along the route too, on both ends. The highest value is 100 MB. - Split the data into several smaller messages, ideally in a message group so the receiver can put them back together. - On distributed MQ only, set MQMF_SEGMENTATION_ALLOWED so the queue manager can segment the message. - For a message on a dead-letter queue, fix the limit and then replay it with the dead-letter handler (`runmqdlq` on distributed, CSQUDLQH on z/OS). ### IBM documentation [IBM documentation: MQRC 2030](https://www.ibm.com/docs/en/ibm-mq/9.4.x?topic=acrc-2030-07ee-rc2030-mqrc-msg-too-big-q). Use the documentation for your installed release. [Report a correction to WND Software](https://wndsoftware.com/contact#message). Technical reviewer: [Albert Joseph](https://wndsoftware.com/authors/albert-joseph), WND Software. Last reviewed 2026-10-18 by the WND Software team. Written in our own words. For the full reference, check IBM’s MQ documentation for your version. ### Related codes [MQRC 2053 MQRC_Q_FULL Read →](https://wndsoftware.com/mainframe-errors/mqrc-2053) [MQRC 2080 MQRC_TRUNCATED_MSG_FAILED Read →](https://wndsoftware.com/mainframe-errors/mqrc-2080) [MQRC 2087 MQRC_UNKNOWN_REMOTE_Q_MGR Read →](https://wndsoftware.com/mainframe-errors/mqrc-2087) [MQRC 2085 MQRC_UNKNOWN_OBJECT_NAME Read →](https://wndsoftware.com/mainframe-errors/mqrc-2085) [MQRC 2009 MQRC_CONNECTION_BROKEN Read →](https://wndsoftware.com/mainframe-errors/mqrc-2009) ### Questions #### What is the difference between 2030 and 2031? 2030 means the message is too long for the queue. 2031 (MQRC_MSG_TOO_BIG_FOR_Q_MGR) means it is too long for the queue manager's MAXMSGL. Fix whichever limit is the smaller one. #### Why did a client application get 2010 instead of 2030? A client connection has its own limit, the MAXMSGL of the channel. When a message is bigger than the channel allows, the client usually sees 2010 (MQRC_DATA_LENGTH_ERROR) before the queue limit is ever checked. #### Does segmentation work on z/OS? No. IBM MQ for z/OS ignores MQMF_SEGMENTATION_ALLOWED, so messages must fit the queue and queue manager limits as they are. [IBM MQ reason codes](https://wndsoftware.com/mainframe-errors/mq-reason-codes) · [MQRC 2027](https://wndsoftware.com/mainframe-errors/mqrc-2027) · [MQRC 2031](https://wndsoftware.com/mainframe-errors/mqrc-2031) [← All error codes](https://wndsoftware.com/mainframe-errors/)