You have .xls files. You need them in .xlsx. Simple problem, right? Until you realize that most converters silently strip your VBA macros, some have hard file size limits, and a few require uploading your confidential business data to someone else's server.
This is an honest comparison of every major option for converting .xls to .xlsx in 2026. No affiliate links, no vague "best overall" picks. Just what each tool actually does — and what it quietly doesn't do.
Before comparing tools, ask yourself: do my .xls files have VBA macros?
If yes: your options collapse dramatically. Only one tool on this list preserves macros during conversion.
If no: your options are wider. Data conversion without macros is a solved problem that several tools handle well.
To check: open any .xls file in Excel, press Alt+F11. If you see any modules, forms, or code in the Project Explorer, you have VBA.
| Tool | Preserves VBA? | Local (no upload)? | Batch conversion? | File size limit? | Free? |
|---|---|---|---|---|---|
| Excel Save As | No (.xlsx strips VBA) | Yes | No (manual) | None | Requires Office |
| CloudConvert | No | No (cloud upload) | Paid plans | 1GB (paid) | 25 conversions/day |
| Zamzar | No | No (cloud upload) | No | 1GB (paid) | 50MB free |
| PowerShell + Excel | No (uses Save As) | Yes | Yes | None | Yes (requires Office) |
| LibreOffice CLI | No | Yes | Yes | None | Yes |
| LegacyLeaps | Yes | Yes | Yes | None | Free scan |
The obvious first choice. Open the .xls file, click File → Save As, choose "Excel Workbook (.xlsx)". Done.
The catch: .xlsx is a macro-free format by design. When you save .xls as .xlsx, Excel silently drops all VBA code and ActiveX controls. You get the data and formatting, nothing else. Excel will warn you with a dialog — it's easy to click through without reading it.
To keep macros when using Save As, you'd need to save as .xlsm (Macro-Enabled Workbook). But .xlsm doesn't fix compatibility issues that caused .xls to break in the first place — it's still a macro-enabled format with its own set of trust settings.
For files without macros and no batch requirements, Save As is perfectly fine. For anything else, look elsewhere.
A popular online conversion service that supports Excel formats among hundreds of others. The UI is clean, the free tier gives you 25 conversions per day, and paid plans start at $9/month.
VBA: Stripped. CloudConvert uses a server-side conversion engine for Excel conversions. LibreOffice does not support VBA preservation — it either drops the code or attempts a Basic translation that breaks most real-world macros.
Privacy: Your file is uploaded to CloudConvert's servers. For most businesses, this is a non-starter for financial models, customer data, or proprietary business logic embedded in macros. CloudConvert's privacy policy states files are deleted after a few hours, but they're processed on cloud infrastructure you don't control.
Size limits: Free tier limits vary; paid plans go up to 1GB. Most legacy .xls files are small, so this rarely matters.
Batch: Available on API and paid plans, not the free web interface.
One of the oldest online converters. Zamzar supports Excel conversion and has a straightforward web interface. Free tier: 50MB per file, email delivery. Paid plans start around $16/month for 1GB files and API access.
VBA: Stripped. Same situation as CloudConvert — the conversion engine doesn't preserve VBA.
Privacy: Files are uploaded to Zamzar's servers. Same concerns as above.
Batch: No batch conversion on the web interface. API access on paid plans.
Verdict: Similar to CloudConvert but with lower file limits and less development investment. If you're choosing between the two for data-only conversion, CloudConvert's UI is cleaner and the limits are more generous.
If you have Excel installed and need to convert hundreds or thousands of .xls files, PowerShell automation is a legitimate option. The script opens each file silently via COM, saves as .xlsx, closes. No upload, no external service, free.
$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false
Get-ChildItem "C:\Files" -Filter "*.xls" | ForEach-Object {
$wb = $excel.Workbooks.Open($_.FullName)
$newPath = $_.FullName -replace "\.xls$", ".xlsx"
$wb.SaveAs($newPath, 51) # 51 = xlOpenXMLWorkbook
$wb.Close($false)
}
$excel.Quit()VBA: Stripped — SaveAs with format 51 is .xlsx, which drops macros. You'd need format 52 (.xlsm) to keep them, but that still doesn't fix the underlying compatibility issues.
Error handling: The script above has no error handling. A single corrupt or password-protected file will crash the loop. Production-grade batch scripts need try/catch blocks and logging.
Performance: COM automation is slow. Opening, saving, and closing via COM takes 2-5 seconds per file. For 1,000 files, plan on 30-90 minutes.
We have a full guide to PowerShell batch conversion with production-ready error handling if this is the route you're taking.
LibreOffice is free, open-source, and has a headless conversion mode that can batch-convert .xls to .xlsx without a GUI:
libreoffice --headless --convert-to xlsx *.xlsNo upload. Runs on Windows, macOS, Linux. Handles large files. Fast.
VBA: LibreOffice has its own macro language (Basic) and will attempt to keep macro code — but the translation from Excel VBA to LibreOffice Basic is unreliable. Complex VBA doesn't survive. Object model differences, API gaps, and syntax differences mean most real-world Excel VBA either errors out or behaves differently.
Formatting fidelity: LibreOffice handles basic formatting well but sometimes loses complex conditional formatting rules, named ranges, and advanced chart types.
Best use case: Bulk conversion of data-only .xls files where you have no VBA and just need the data in modern format for archival or import into another system.
LegacyLeaps is a Windows desktop application built specifically for legacy Office file migration. Unlike the tools above, it was designed from the ground up for the problem of converting .xls files that have macros, ActiveX controls, and compatibility issues.
VBA: Preserved. LegacyLeaps reads the VBA project directly from the .xls binary format and writes it into the .xlsx (as .xlsm if macros are present). It also audits the code for known compatibility issues — PtrSafe declarations for 64-bit, deprecated methods, Jet-specific references — and flags them with fix recommendations.
Local processing: Your files never leave your machine. There's no cloud component. This matters for financial models, customer databases, and any file with business-critical logic embedded in macros.
Batch conversion: Point it at a folder, it converts everything. Handles nested subdirectories. Generates a report showing what was converted, what was flagged, and what needs manual review.
Free scan: Before you pay anything, LegacyLeaps runs a free analysis of your files and shows you exactly what's inside — macro count, ActiveX controls, formula complexity, potential compatibility issues. You know what you're getting before you commit.
Pricing: Token-based. You buy conversion tokens and use them as needed. No subscription. A single .xls conversion uses one token. Bulk packages are available for IT teams.
Run LegacyLeaps's free scan first. You'll see exactly what's in your files — macro count, complexity, compatibility issues — before converting a single one.
Try the Free ScanThe answer depends on one question: do your files have VBA macros?
Use Excel's Save As. It's already installed, it's instant, and it handles data-only files perfectly.
Use PowerShell + Excel COM. It's free, local, and handles large batches. Use our production-ready script template with proper error handling.
Use LibreOffice headless. Free, fast, handles bulk, works without Office.
CloudConvert works. Clean UI, 25 free conversions per day, no install required.
Use LegacyLeaps. It's the only option on this list that preserves VBA code. The free scan shows you what's there before you pay anything.
Still LegacyLeaps — but budget extra time for the ActiveX audit. Many legacy ActiveX controls (calendar pickers, grid controls, third-party charts) don't work in 64-bit Office and will need replacing regardless of what converter you use. LegacyLeaps's scan identifies all of them upfront.
Some people ask: can I just save my .xls as .xlsm to keep the macros? Yes, but it doesn't actually solve the compatibility problem.
.xlsm is "Macro-Enabled Workbook" format — it's the modern container for files with VBA. But if your .xls was failing because of 64-bit compatibility issues, PtrSafe declarations, deprecated API calls, or macro trust settings, just re-saving as .xlsm preserves the broken code in a new container.
The point of conversion isn't just the file extension. It's making the code work in modern Excel on modern Windows. That's what LegacyLeaps does that the other tools don't.
You'll find tools like Stellar Repair for Excel and similar "repair" utilities in searches related to .xls problems. These tools solve a different problem — they reconstruct corrupted files where the binary structure is damaged.
If you can open your .xls file in Excel today, it's not corrupted. It's a format compatibility problem, not a file damage problem. Repair tools won't help and may make things worse. See our post on the difference between corruption and format obsolescence.
Among the tools tested, LegacyLeaps preserves VBA macros automatically during conversion. Online tools like CloudConvert and Zamzar strip all VBA code. Excel's built-in Save As also strips macros when converting to .xlsx — you'd need to save as .xlsm, which still doesn't fix underlying compatibility issues.
Yes, for data-only files. PowerShell can automate Excel's Save As for bulk conversion, but it uses the same Save As engine that strips VBA. It also requires Excel installed and doesn't handle corrupted or password-protected files without additional error handling.
No. CloudConvert uses LibreOffice for Excel conversions, which does not preserve VBA. Your files are also uploaded to CloudConvert's servers during processing.
Zamzar's free tier is limited to 50MB per file. Their paid Business plan supports up to 1GB. No bulk batch conversion on the free tier.
Use a desktop tool that processes files locally — no upload. LegacyLeaps runs entirely on your Windows machine, preserves VBA macros, and never sends your files anywhere.
Download LegacyLeaps and run a free scan. See exactly what's in your files before you convert anything — macros, ActiveX controls, compatibility issues, all of it.
Download Free ScannerPractical fixes for legacy Excel and Access problems. No spam.