How to plot a large CSV file with millions of rows

A data logger, a test rig or a busy web server can write millions of rows in an afternoon. Then you try to chart them: Excel stops at 1,048,576 rows, a Python plot takes a minute to appear, and an online plotter wants you to upload a 2 GB file. This guide explains why big files are hard to plot, why some charts hide the very spikes you are looking for, and which options work today.

Why big CSV files are hard to plot

• Spreadsheet row limits. An Excel worksheet holds 1,048,576 rows and Google Sheets 10 million cells per spreadsheet. A chart can only use rows that made it onto the sheet, so the rest of the file never appears.
• Drawing cost. Every point becomes a line segment that has to be drawn again on every zoom, pan and resize. SVG-based chart libraries put every point into the page as path data or as separate elements; canvas is faster, but tens of millions of segments per redraw still take seconds. In our tests, gnuplot needed 30 to 60 seconds to draw 5 million points into a PNG.
• Memory. A CSV is text. Parsed into one object per row, as many tools do, it can take several times the file size in memory, and a browser tab runs out long before your computer does.
• Pixels. Five million rows on a chart 1,500 pixels wide means more than 3,000 points per pixel column. Most of them are painted on top of each other.

Why spikes vanish when data is thinned out

Since the screen can’t show every point anyway, many tools and scripts quietly draw fewer of them. How they choose matters. The obvious shortcut, keeping every Nth row, is blind: a spike shorter than N rows disappears unless it happens to land on a kept row, noise looks calmer than it is, and regular signals can turn into slow waves that aren’t there. Averaging each block of rows has the same problem, because it flattens peaks.

In our test with 5 million rows and a spike just three rows long, plotting every 2,500th row produced a clean wave with no spike at all. The same file reduced to each block’s lowest and highest value showed the spike at full height. Before you trust a tool with big files, try it on data with a known short spike and check that it still shows when you are fully zoomed out.

Option 1: The MegaRows plotter

The MegaRows plotter opens CSV, TSV, TXT, Excel (.xlsx), JSON and MATLAB .mat files with millions of rows in your browser and draws them as zoomable line charts. A 10-million-row file opens in about three seconds on a recent laptop. Short peaks stay visible however far you zoom out, and when you zoom in, the full detail for that range reloads instantly. The file never leaves your device.

1. 1Open your file. Open the plotter and click “Choose a file”, or drop a CSV, Excel, TXT, JSON or MATLAB .mat file onto it. Separators, decimal commas, dates and header lines are detected for you, and the file is read on your device.
2. 2Pick the columns. The plotter suggests an x column, such as a time column, and a first series. Add up to eight series, and move any of them to the right-hand y-axis when their units differ.
3. 3Zoom, check and export. Drag across the chart to zoom: the full detail for that range reloads straight away. Double-click to reset, open a column’s statistics, and export the chart as a PNG.

The statistics panel shows the count, missing values, minimum, maximum, mean and standard deviation of a column, calculated from every row.

Option 2: Excel

Excel is fine for charts of a few thousand points and great for polishing a final chart. For big files it runs into two walls. The data must sit on a worksheet, which stops at 1,048,576 rows. And although Microsoft lists the points per chart series as limited only by available memory (with up to 255 series per chart), charts with hundreds of thousands of points get slow to draw, resize and edit. Excel also draws every point, so a dense series turns into a solid block.

The workaround is to chart a summary. A PivotChart built from the Data Model can show one value per minute or hour; include the minimum and maximum alongside the average, or spikes vanish. Or reduce the file first with DuckDB or Python, as shown below, and chart the result.

Option 3: Python with matplotlib or Plotly

matplotlib can draw a few million points, but slowly, and very long line plots sometimes fail with an “Exceeded cell block limit” error (raising the agg.path.chunksize setting helps). Reducing the data first is much faster and looks practically the same. Keeping the lowest and highest value of each of 2,000 blocks means no spike can slip through the gaps. In a few lines of NumPy:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("big.csv", usecols=["time", "value"]).dropna()
x = df["time"].to_numpy()
y = df["value"].to_numpy()


def min_max_downsample(x, y, buckets=2000):
    """Keep the lowest and highest point of each bucket, in order."""
    if len(y) <= 2 * buckets:
        return x, y
    edges = np.linspace(0, len(y), buckets + 1).astype(int)
    keep = []
    for start, end in zip(edges[:-1], edges[1:]):
        lo = start + np.argmin(y[start:end])
        hi = start + np.argmax(y[start:end])
        keep.extend(sorted({lo, hi}))
    return x[keep], y[keep]


xs, ys = min_max_downsample(x, y)
plt.figure(figsize=(12, 4))
plt.plot(xs, ys, linewidth=0.8)
plt.xlabel("time")
plt.ylabel("value")
plt.savefig("plot.png", dpi=150)

On our 5-million-row test file this kept 4,000 points, including the three-row spike, and the whole script ran in under two seconds. Drop rows with missing values first, as above: argmin and argmax return the position of the first NaN instead of the real extreme.

Plotly gives interactive charts in a browser or notebook. Its WebGL traces (go.Scattergl) handle far more points than the default SVG ones, and the open-source plotly-resampler package downsamples again as you zoom. Saved as HTML, a chart contains every point it draws, so reduce the data before sharing it.

Option 4: gnuplot

gnuplot is a free command-line plotting program that reads CSV files directly:

set datafile separator ","
set key autotitle columnhead
set terminal pngcairo size 1600,500
set output "plot.png"
plot "big.csv" using 1:3 with lines

It draws every point it reads, so the result is accurate, but slow for big files: our 5-million-row file took 30 to 60 seconds. Its every option (plot "big.csv" every 100 using 1:3 with lines) is fast because it is the every-Nth-point method, with the same blind spots. The interactive windows let you zoom with the mouse, but each redraw goes through all the points again.

Option 5: DuckDB and any charting tool

DuckDB is a free, single-file database that queries CSV files directly. Let it shrink the data, then chart the small result in anything, even Excel:

COPY (
  SELECT date_trunc('minute', ts) AS minute,
         min(value) AS low,
         max(value) AS high,
         avg(value) AS mean
  FROM 'big.csv'
  GROUP BY minute
  ORDER BY minute
) TO 'per_minute.csv' (HEADER, DELIMITER ',');

On our 5-million-row test file the query took well under a second and returned 834 rows with each minute’s low, high and mean. Plot low and high as two lines and the spike is still there. Use time_bucket for other intervals, or floor(x / 10) for a numeric x column.

Option 6: Online CSV plotters

Plenty of websites plot a CSV for free. Before you drop a big or sensitive file into one, check three things: whether it uploads the file (most do; watch the Network tab of your browser’s developer tools), what size or row cap it has (often a few megabytes), and how it reduces the data (many sample every Nth point or simply stop at a limit).

Which option should you choose?

To explore a file and find the interesting part, use a tool that zooms to full detail. For a report, reduce the data with min and max per bucket and chart the result wherever you like.