Quick answer: Jupyter’s IOPub rate warning means the kernel is sending output faster than the client connection allows. Reduce noisy output first, then tune data or message limits for a known workload and monitor the resulting client load.
The Jupyter iopub data rate exceeded message appears when a notebook sends too much output from the kernel to the browser too quickly. It often happens after printing huge objects, displaying large tables, rendering heavy plots, or repeatedly updating output in a loop. Large output and missing widget progress support are different Jupyter front-end failures; Fix iprogress Not Found in Jupyter covers the ipywidgets side.
The best first fix is to reduce output. Show a sample, save large results to a file, summarize the data, or display fewer rows. Raising the server limit can help trusted local workflows, but it should not be the default response to every noisy cell.
IOPub is part of the Jupyter messaging path between the kernel and frontend. When the frontend is flooded, the server rate limit protects the session from becoming unresponsive. That protection is useful, so tune it only after checking whether the output can be made smaller.
The error can look like a server outage, but the cause is usually one notebook cell producing more output than the browser can process. Start by rerunning the most recent cell and checking whether it prints a full list, a complete DataFrame, a large nested structure, or many progress messages. If the notebook becomes responsive after interrupting that cell, the fix should focus on output discipline before any server setting is changed.
A good recovery flow is to save the notebook, restart the kernel, and run cells one at a time until the noisy step is clear. Replace full prints with counts, samples, and summaries. For long-running jobs, write logs to disk and show only the current status in the notebook. That keeps the notebook useful for exploration while avoiding a page filled with thousands of browser-rendered messages.
The Jupyter Server configuration documentation, Jupyter Notebook configuration overview, Jupyter directories documentation, IPython display documentation, and Jupyter messaging documentation are useful references.
Print A Small Sample
Do not print an entire large collection in a notebook cell. Print a small slice or summary.
rows = [f"row {number}" for number in range(10000)]
for row in rows[:10]:
print(row)
print(f"showing 10 of {len(rows)} rows")
This keeps the notebook responsive and still proves that the data exists.
Write Large Output To A File
When output is large, save it and display the path instead of sending everything to the browser.
from pathlib import Path
rows = [f"row {number}" for number in range(10000)]
path = Path("notebook-output.txt")
path.write_text("\n".join(rows), encoding="utf-8")
print(f"wrote {len(rows)} rows to {path}")
This is safer for logs, generated text, model output, and large debug dumps.
Limit DataFrame Display
For tabular data, display the head, tail, shape, or summary instead of the whole DataFrame.
import pandas as pd
frame = pd.DataFrame({"value": range(10000)})
print(frame.shape)
print(frame.head(10))
Most debugging questions can be answered with a small sample and basic dimensions.
Clear Repeated Output
Loops that update output repeatedly can flood IOPub. Use display cleanup for progress-style output.
from IPython.display import clear_output
for step in range(5):
clear_output(wait=True)
print(f"step {step + 1} of 5")
This replaces prior output instead of appending many messages to the notebook.
This pattern is especially helpful when a loop reports progress, retries a network call, or processes batches. Without cleanup, every iteration creates another output message. With cleanup, the notebook shows the latest state and the browser does far less rendering work.
Build A Config Command Carefully
If you truly need a higher local limit, generate the command deliberately and document why the project needs it.
import shlex
command = [
"jupyter",
"notebook",
"--NotebookApp.iopub_data_rate_limit=10000000",
]
print(" ".join(shlex.quote(part) for part in command))
Use higher limits carefully on shared servers. Large outputs can still make browsers slow even when the server allows them.
Store A Local Setting
For repeat local work, write a config snippet that can be reviewed before use.
from pathlib import Path
config_line = "c.NotebookApp.iopub_data_rate_limit = 10000000\n"
path = Path("jupyter_notebook_config.py")
path.write_text(config_line, encoding="utf-8")
print(path.read_text(encoding="utf-8"))
Check which Jupyter server version your environment uses, because modern deployments may use Jupyter Server configuration names instead of older NotebookApp names.
NotebookApp examples still appear in many older guides, but current Jupyter installs may read ServerApp settings instead. Keep the limit change in a reviewed local config file, note why it is needed, and prefer a project-specific environment over a global system change. If a hosted notebook platform manages these settings for you, use its documented control panel or support path instead of editing files blindly.
Fix Checklist
First, identify the noisy cell. Look for large prints, full DataFrame displays, heavy plots, or loops that repeatedly append output.
Next, reduce the output. Sample rows, save large results to a file, clear repeated output, or display a summary. Only raise the rate limit when the large output is expected and useful.
Finally, rerun the notebook from a clean kernel. That confirms the notebook is stable without relying on hidden state from earlier cells.
Reduce Output At The Source
Printing every row, displaying large objects repeatedly, or updating a progress widget too frequently can saturate the IOPub channel. Return summaries, sample records, write large results to a file, or update progress at a controlled interval instead of increasing a limit immediately.
for index, value in enumerate(records):
process(value)
if index % 100 == 0:
print("processed", index)
Know Which Limit You Hit
Jupyter Server exposes separate data and message rate limits. The data limit measures bytes per second; the message limit measures messages per second. A small message repeated thousands of times can hit the message limit, while a few large displays can hit the data limit.
from pathlib import Path
output_path = Path("results.txt")
output_path.write_text("large result stored outside notebook output\n", encoding="utf-8")
print(output_path)Configure Only A Controlled Increase
For a trusted server and a workload that genuinely needs more output, set the current Jupyter Server connection options such as ZMQChannelsWebsocketConnection.iopub_data_rate_limit in the appropriate configuration. Treat the value as an operational setting, not a code-level repair, and restart or reload the server as its configuration model requires.
# Example command-line configuration for a controlled session:
# jupyter lab --ServerApp.iopub_data_rate_limit=5000000
# Prefer reducing output before using a larger limit.Jupyter Server’s configuration reference distinguishes the IOPub data and message rate limits and their defaults.
For notebook execution and diagnostics, compare controlled progress output, traceback inspection, and unbuffered output.
Frequently Asked Questions
What does IOPub data rate exceeded mean?
Jupyter Server is limiting the rate of output messages or bytes sent from the kernel to the client over IOPub.
How do I fix IOPub data rate exceeded in a notebook?
Reduce per-iteration printing, display summaries instead of every record, and batch or throttle progress updates.
Can I increase iopub_data_rate_limit?
Yes, for a trusted workload you can configure the Jupyter Server connection limit, but raising it does not fix an output loop and can increase client load.
What is the difference between data and message rate limits?
The data limit controls bytes per second, while the message limit controls the number of messages per second; either can throttle a noisy kernel.