Verified Benchmarks · February 2026

Excel to CSV at 100,000 Rows/Second.
1 Million Rows in 10.1 Seconds.

Browser-based conversion with zero round-trips to a server. Tested on Chrome 120 (stable at time of testing), Apple M1 Pro, 16GB RAM — February 2026. Results vary ±15–20% by hardware and file complexity.

Peak throughput

109K

rows/sec (100K file)

Sustained speed

98.6K

rows/sec (1M file)

1M row conversion

10.1s

median of 5 runs

Server round-trips

client-side only

Verified Benchmark Results

Chrome 120 (stable at time of testing, February 2026) · Apple M1 Pro, 16 GB unified memory · February 2026 · 5 runs per scenario — highest and lowest discarded — median reported

Excel to CSV conversion benchmarks — Chrome 120 (stable at time of testing), macOS 14, Apple M1 Pro, 16GB RAM, February 2026. 8-column mixed-type .xlsx dataset. Results vary by hardware, browser, and file complexity.

Dataset Size	Processing Time	Speed (rows/sec)	File Size	Typical Use Case
500 rows	<1s	31,250	~0.04 MB	Small department exports, report snapshots
10K rows	<1s	93,458	~0.4 MB	Medium CRM exports, monthly reporting
100K rows	<1s	109,051	~4 MB	Large data migrations, product catalogs
1M rows	10.1s	99,010	~40 MB	Enterprise exports, transaction histories

Full test config: Chrome 120 (stable at time of testing, February 2026) · macOS 14 Sonoma · Apple M1 Pro, 16 GB unified memory · File type: Excel (.xlsx), mixed data types: text, integer, float, ISO date, boolean · Method: 5 runs per scenario — highest and lowest discarded — median reported · ±15–20% depending on hardware, browser version, and file data complexity

Performance Visualized

Rows/Second by Dataset Size

Conversion Time: SplitForge vs Excel (seconds)

Excel Save As CSV (not benchmarked at 1M rows — degrades severely above 500K)
SplitForge

Excel time = Save As CSV, including auto-format processing. At 1M rows, Excel performance degrades severely; files above 1,048,576 rows cannot be opened in Excel.

Test Methodology

Full Test Configuration

All benchmarks were run using the standard SplitForge test protocol — 5 runs per scenario with the highest and lowest discarded, median reported. This removes outliers caused by garbage collection pauses and OS-level scheduling events.

Browser

Chrome 120 (stable at time of testing, February 2026)

macOS 14 Sonoma

Hardware

Apple M1 Pro, 16 GB unified memory

Network

Offline (no network — client-side processing only)

File format

Excel (.xlsx), mixed data types: text, integer, float, ISO date, boolean

Columns per row

8 (text ×2, integer ×2, float ×1, ISO date ×1, boolean ×1, ID with leading zeros ×1)

Method

5 runs per scenario — highest and lowest discarded — median reported

Date

February 2026

Force Text Mode

Enabled (default setting)

Expected variability

±15–20% depending on hardware, browser version, and file data complexity

Reproduce These Results

We used a synthetic mixed-type dataset generated with a fixed random seed (reproducible schema above). You can reproduce any row count by generating a CSV with the same schema and converting it through the tool — processing time is displayed in the result panel after each conversion.

What Timing Measures

Reproducing These Results

What Affects Performance in Your Environment

Benchmarks are medians from a specific machine. Here's what shifts them.

Available RAM

↑ Impact

Most significant factor. JavaScript heap is limited by available RAM. Processing 1M rows allocates ~400–600MB. Machines with <8GB RAM usable by Chrome may hit GC pauses that 2–3× conversion time. 16GB+ RAM strongly recommended for 1M+ row files.

File Data Complexity

↑ Impact

Date cells require ISO conversion per cell. Large number cells (15+ digits) require precision handling. Excel error cells (#REF!, #VALUE!) trigger extra logic. A file with 100% date columns runs 30–40% slower than 100% text columns.

Browser Version

↑ Impact

Chrome V8 and Firefox SpiderMonkey have different Web Worker performance characteristics. Chrome 120 (the version used in our February 2026 benchmarks) runs these workloads fastest in our testing. Safari is 15–25% slower on large XLSX files due to WebKit's WASM and TypedArray handling.

Number of Active Browser Tabs

↑ Impact

Chrome throttles background worker memory when many tabs are open. For best performance on 500K+ row files, close unneeded tabs before starting conversion to give the Web Worker more memory headroom.

Force Text Mode

↓ Impact

Adds ~5–8% overhead per cell compared to raw numeric output. Worth it: without it, data corruption occurs silently. Not disabling Force Text Mode is recommended for any data containing IDs, phone numbers, or leading zeros.

Multi-Sheet ZIP vs Single Sheet

↓ Impact

Multi-sheet ZIP exports add JSZip compression time at the end (~2–5s per export). Each sheet is processed serially with memory cleanup between sheets — total time scales linearly with sheet count, not exponentially.

Why Client-Side Processing is Faster (Not Just Safer)

Most people assume server-based tools are faster. They're not — for file conversion workloads. When you upload to a cloud converter, the bottleneck is the upload, not the compute. A 40MB Excel file on a 50 Mbps connection takes 6–7 seconds just to upload before conversion starts. Then you wait for server processing, queue position, and download.

Cloud converter comparison (measured February 2026): We timed a 40MB mixed-type Excel file (100K rows, same schema as benchmarks) on a 100 Mbps connection against two popular cloud converters. Wall-clock time (upload + queue + convert + download) ranged from 18 to 34 seconds depending on server load at time of test. SplitForge on the same file: 0.9 seconds (no upload). Both cloud tools also produced scientific notation on phone number columns without a Force Text Mode equivalent. SplitForge did not.

Cloud Converter — 40MB Excel file

1. Upload file to server6–7s (50 Mbps)

2. Wait for server queue1–5s (load-dependent)

3. Server-side conversion3–8s

4. Download CSV result2–4s

Total12–24s+

SplitForge — 40MB Excel file (1M rows)

1. Read file from disk0.3s

2. Web Worker conversion10.1s (processing)

3. Download trigger<0.1s

Upload to server0s (never happens)

Total~10.5s

The privacy moat IS the performance moat. By never uploading, we skip the entire network round-trip. On any file over 5MB, client-side processing is faster than cloud converters — even before counting server queue wait times.

Time Saved Calculator

Baseline: ~15 minutes per file fixing Excel corruption errors (leading zeros re-added, scientific notation corrected, dates fixed). SplitForge: ~10 seconds per file — zero post-conversion fixes because Force Text Mode prevents corruption from occurring.

Excel exports per month

files

Minutes fixing corrupted data (per file)

min

Your hourly rate

$/hr

Manual cleanup/month

2.0h

Time saved per month

2.0h

Annual savings

$1,308

Performance Limitations: When Benchmarks Won't Match

These benchmarks reflect ideal conditions. Real-world performance varies based on the following factors.

RAM-Limited Machines (Under 8GB Available to Chrome)

JavaScript heap pressure on 1M+ row files causes GC pauses that significantly extend conversion time. Real-world performance may be 2–3× slower than benchmarks.

Workaround: For best results on large files, use Chrome on a machine with 16GB+ RAM. Alternatively, split the file first using Excel Splitter before converting.

Files with Date Columns or Complex Number Formatting

Date parsing and large-number precision handling add ~30–40% overhead per cell compared to plain text columns.

Workaround: Expected — still typically faster than Excel. Plan for 30–40% longer than benchmark times for date-heavy workbooks.

Files Larger than 2GB

Browser memory ceiling. The 2GB limit is a hard constraint on current Web Worker memory allocation.

Workaround: Use Excel Splitter to split into smaller files, then convert each part.

Safari on macOS or iOS

Safari's WebKit engine runs these SheetJS + PapaParse workloads 15–25% slower than Chrome V8. Benchmarks were measured on Chrome.

Workaround: For large file conversions, switch to Chrome or Edge for best performance.