Google Sheets File Size Limit: What You Can and Can't Upload

Every Google Sheets user eventually runs into the same wall: you try to upload a file, and it either fails, freezes your browser, or makes the spreadsheet unbearably slow. The Google Sheets file size limit is one of the most misunderstood aspects of working with spreadsheets in the cloud. It’s not just one number — it’s a combination of cell limits, upload limits, and practical performance thresholds that all work together to determine what you can and can’t do.

In this guide, I’ll break down every limit you need to know, explain why they exist, what happens when you hit them, and — most importantly — how to work around them so you can keep getting things done.

Key Takeaways:Google Sheets has a hard cap of 10 million cells per spreadsheetUpload limit is 100MB for XLSX/CSV files via the web interfacePerformance starts degrading around 50,000-100,000 rows, well before hitting hard limitsSmoothSheet handles large imports server-side, bypassing browser memory constraints entirely

What Are Google Sheets’ File Size Limits?

Google Sheets doesn’t have a single “file size limit.” Instead, there are several overlapping constraints that determine whether your file will import successfully — and whether it’ll actually be usable once it’s in. Let’s go through each one.

Upload file size limit

When you import a file through File > Import or drag-and-drop, Google Sheets accepts CSV and Excel (XLSX) files up to 100MB. This is a hard limit enforced by Google’s official file size documentation. Files larger than 100MB will simply refuse to upload.

Keep in mind that this is the raw file size on disk. A 90MB CSV file might technically be under the limit, but it can still fail during processing because your browser needs 2-3x more memory than the file size to parse and transmit the data. So the practical upload limit for a smooth experience is closer to 50MB.

Cell limit: 10 million cells

This is the big one. Every Google Sheets spreadsheet is capped at 10,000,000 cells total. That includes every cell across all sheet tabs in the workbook — not just the ones with data in them, but any cell within the used range.

Why does this matter more than file size? Because a small file can still exceed the cell limit. A CSV with 500 columns and 25,000 rows uses 12.5 million cells — that’s only a few MB on disk, but it blows right past the 10 million cell cap.

You can check whether your file will fit before uploading with our free Google Sheets Limits Calculator.

Column limit: 18,278 columns

Google Sheets supports a maximum of 18,278 columns, which corresponds to column ZZZ. Most users never come close to this limit, but it can be an issue with wide datasets from analytics platforms, sensor data exports, or pivot-style reports that generate hundreds of columns.

For context, Excel’s column limit is 16,384 (column XFD), so Google Sheets actually has slightly more columns available — though neither is designed for data that wide.

Row limit: it depends

This is where people get confused. Google Sheets doesn’t have a fixed row limit — your maximum rows depend on how many columns you’re using. The formula is straightforward:

Maximum rows = 10,000,000 / number of columns

So with 10 columns, you can theoretically have 1,000,000 rows. With 50 columns, you max out at 200,000 rows. We covered this in detail in our Google Sheets Row Limit Explained guide, which includes a full reference table for different column counts.

Performance degradation thresholds

Here’s the part Google doesn’t advertise: just because your data fits within the limits doesn’t mean it’ll work well. In practice, Google Sheets performance degrades on a sliding scale:

These thresholds shift depending on the number of columns, formula complexity, and how many people are editing simultaneously. A spreadsheet with 80,000 rows and no formulas will perform better than one with 30,000 rows full of ARRAYFORMULA and IMPORTRANGE calls.

Why Does Google Sheets Have These Limits?

Understanding why these limits exist helps you work smarter within them — and makes the workarounds more intuitive.

Browser-based processing

Unlike Excel, which runs as a desktop application with direct access to your computer’s CPU and RAM, Google Sheets runs entirely in your browser. Every calculation, every cell render, every formula evaluation happens inside a browser tab. That tab has strict memory limits — typically 1-4GB depending on your browser and operating system.

When you import a large file, your browser has to load the entire dataset into memory, parse it, validate it, and then send it to Google’s servers. A 50MB CSV can easily consume 200-300MB of browser memory during this process. Add in your other open tabs and applications, and you can see why crashes happen.

Memory constraints

Google’s servers also have to manage your spreadsheet in memory for real-time editing. Every open spreadsheet consumes server resources, and Google has to balance this across hundreds of millions of users. The 10 million cell limit keeps individual spreadsheets from consuming an outsized share of resources.

This is also why performance degrades before you hit the hard limit. Google throttles resource allocation as spreadsheets grow larger to maintain system-wide stability.

Collaborative editing overhead

One of Google Sheets’ biggest selling points is real-time collaboration — multiple people editing the same spreadsheet simultaneously. But this feature has a significant computational cost. Every edit needs to be synchronized across all connected clients, conflicts need to be resolved, and revision history needs to be maintained.

With a small spreadsheet, this overhead is negligible. With a 5-million-cell spreadsheet and three editors, the synchronization engine is doing serious work. The file size limits help keep this overhead manageable.

What Happens When You Hit the Limit?

Depending on which limit you’re bumping up against, you’ll see different symptoms. Here’s what to expect.

Common error messages

When your file exceeds Google Sheets’ hard limits, you’ll typically see one of these messages:

• “This file is too large to edit in Google Sheets” — Your file exceeds the 10 million cell limit or the 100MB upload threshold
• “Your spreadsheet is too large. Please reduce the number of cells.” — You’ve hit the cell cap, often after adding data to a spreadsheet that was already near the limit
• “The file could not be uploaded” — Usually a file size issue during import, especially with files over 100MB
• “Unable to parse the file” — The file may be corrupted, have encoding issues, or be too complex for the import parser to handle within browser memory

Browser crashes and “Page Unresponsive”

This is the most common symptom for files in the gray zone — technically within the limits but too large for comfortable browser processing. You’ll see Chrome’s “Page Unresponsive” dialog, or the tab will simply go white and crash.

Browser crashes during import are particularly frustrating because they often happen partway through the process. You might wait five minutes for an upload to process, only to have the tab crash at 80% progress with no way to resume. This is the exact problem that SmoothSheet was built to solve — by moving the processing to the server, your browser never has to handle the heavy lifting.

Slow performance symptoms

Sometimes you won’t hit a wall — you’ll just notice everything getting gradually slower:

• Formulas take 10-30 seconds to calculate instead of being instant
• Scrolling becomes choppy with visible lag between your scroll input and the screen updating
• Saving shows “Working...” for extended periods
• Undo/redo stops working reliably or takes several seconds
• Collaborators see stale data because sync can’t keep up
• Conditional formatting bogs everything down when applied to large ranges

If you’re experiencing these symptoms, your spreadsheet hasn’t technically failed, but it’s no longer practical to work with. You need to reduce the data volume or move to a more capable tool.

How to Work Around Google Sheets File Size Limits

You don’t have to abandon Google Sheets when your data gets large. Here are five practical strategies that cover different scenarios and skill levels.

Split your file before uploading

The most straightforward fix: break your large file into smaller pieces before importing. If you have a 200MB CSV with 2 million rows, splitting it into four 50MB chunks of 500,000 rows each means each piece imports cleanly.

You can do this manually in a text editor, but it’s much faster with our free CSV Splitter. It runs entirely in your browser (no data uploaded anywhere), lets you split by row count or into equal parts, and preserves header rows in every chunk. You can download all the pieces as a ZIP file.

If your data has natural categories — regions, departments, product lines — you might also consider splitting by column value using the CSV Splitter by Column tool. This way each file contains a logical subset of your data rather than an arbitrary chunk.

Remove unnecessary columns and rows

Before fighting with import limits, ask yourself: do you actually need all this data in Google Sheets? In many cases, a significant portion of a large file is irrelevant to your current task.

Common sources of unnecessary bulk:

• Empty rows and columns at the end of the file (especially common in Excel exports)
• Metadata columns you don’t need for analysis (internal IDs, audit timestamps, system fields)
• Historical data outside your analysis window — if you only need Q4 2025, don’t import all of 2024
• Duplicate rows from data pipeline issues

Cleaning your data before import can reduce file size by 30-70%. Use Excel, a text editor, or our CSV Analyzer to understand your file’s structure before deciding what to trim.

Use Google Apps Script for larger imports

For files that are too large for the standard import dialog but still within the 10 million cell limit, Google Apps Script offers a programmatic workaround. Instead of your browser processing the entire file at once, a script can read and write data in batches.

The basic approach:

1. Upload your CSV to Google Drive
2. Create a Google Apps Script that reads the file in chunks (e.g., 50,000 rows at a time)
3. Write each chunk to the spreadsheet with a short pause between batches
4. The script runs server-side, bypassing browser memory limits

The downside is that this requires JavaScript knowledge and has a 6-minute execution time limit per run. For very large files, you’ll need to implement checkpoint logic to resume across multiple runs. It’s powerful but not practical for everyone.

Use SmoothSheet for server-side processing

If you regularly work with large files and don’t want to deal with splitting, cleaning, or scripting, SmoothSheet is the simplest solution. It’s a Google Sheets add-on that processes CSV and Excel imports on the server instead of in your browser.

Here’s what that means in practice:

• No browser crashes — your browser sends the file to SmoothSheet’s server, which handles all the parsing and writing
• Full 10 million cell capacity — you can use every cell Google Sheets allows without worrying about browser memory
• No file splitting required — upload your file as-is, and SmoothSheet handles the rest
• Column mapping and preview — see exactly how your data will land before committing

At $9/month, it pays for itself the first time you skip an hour of manually splitting and re-importing files. We covered this workflow in detail in our guide on uploading large CSVs without browser crashes.

Consider BigQuery for truly massive datasets

If your data regularly exceeds 10 million cells — think millions of rows with dozens of columns — Google Sheets simply isn’t the right tool, regardless of workarounds. Google BigQuery is built for exactly this scale.

BigQuery can handle billions of rows and petabytes of data. It uses SQL for queries, integrates natively with the Google ecosystem, and offers a Connected Sheets feature that lets you analyze BigQuery datasets through a familiar spreadsheet interface. Your data lives in BigQuery while you interact with it through Google Sheets — best of both worlds.

The tradeoff: BigQuery has a learning curve, requires SQL knowledge, and has its own pricing model based on data storage and query volume. But for enterprise-scale data, it’s the appropriate Google-native solution.

Frequently Asked Questions

What is the maximum file size for Google Sheets?

Google Sheets allows CSV and Excel file uploads up to 100MB through the web interface. However, the more important limit is the 10 million cell cap per spreadsheet. A file can be well under 100MB in size but still exceed the cell limit if it has many columns. For reliable imports without browser issues, aim to keep files under 50MB.

How many rows can Google Sheets handle?

There’s no single row limit — it depends on how many columns your data has. Google Sheets allows 10 million total cells per spreadsheet, so your maximum rows equal 10,000,000 divided by your column count. With 10 columns, that’s 1,000,000 rows. With 26 columns, it’s about 384,615 rows. In practice, performance degrades significantly above 100,000 rows regardless of the theoretical maximum.

Can Google Sheets handle 1 million rows?

Only if you have 10 or fewer columns (10 columns times 1,000,000 rows equals exactly 10 million cells). Even then, the spreadsheet will be extremely slow. Formulas, sorting, and filtering will take a long time, and browser crashes are likely during editing. For datasets of this size, you’re better off using SmoothSheet for the import process and limiting your active working set to a subset of the data.

Why is my Google Sheets file so slow?

Slow performance usually comes from one or more of these factors: too many rows of data (above 50,000-100,000), complex formulas like VLOOKUP or QUERY running across large ranges, heavy conditional formatting, many collaborators editing simultaneously, or too many sheet tabs with data. Start by reducing your data volume, simplifying formulas where possible, and removing conditional formatting from large ranges.

How do I import a file larger than 100MB to Google Sheets?

You can’t directly upload a file over 100MB to Google Sheets — it’s a hard limit. Your options are: split the file into smaller chunks using a CSV Splitter and import each piece separately, remove unnecessary data to get the file under 100MB, use Google Apps Script to process the file from Google Drive in batches, or use SmoothSheet’s server-side import to handle large files without browser limitations. If your data also exceeds 10 million cells, consider Google BigQuery instead.

Conclusion

Google Sheets’ file size limits aren’t a single number you can memorize. They’re a combination of the 100MB upload cap, the 10 million cell ceiling, the 18,278-column maximum, and — perhaps most importantly — the practical performance thresholds that make large spreadsheets painful to use well before you hit any hard limit.

For most users, the real constraint isn’t the theoretical maximum but the point where Google Sheets stops being a productive tool. That tends to happen somewhere around 50,000-100,000 rows, depending on your formula complexity and column count.

The good news is that you have options. Splitting files, trimming unnecessary data, and using tools built for the job can keep you productive even when your datasets outgrow what Google Sheets handles comfortably. If large file imports are a regular part of your workflow, SmoothSheet takes the pain out of the process entirely — server-side processing means no more browser crashes, no more file splitting, and no more staring at frozen tabs. Try it for $9/month and spend your time on analysis instead of fighting with upload limits.