openpyxl vs xlsxwriter in Python: Choosing the Right Excel Library
Compare openpyxl and xlsxwriter for creating Excel files in Python. Learn their read/write capabilities, memory behavior, and how to choose the right library for your workflow.

Choosing between openpyxl and xlsxwriter starts with one question: do you need to read or modify an existing .xlsx file, or are you only creating a new workbook? Both libraries can write .xlsx files, but they take different approaches. openpyxl can read and write Excel files; xlsxwriter is write-only. That difference drives most of the decision.
Core Design Differences
openpyxl's default mode loads the entire workbook into memory. This makes it easy to read existing files, modify cells, and save updated copies. Because the workbook is an in-memory object graph, you can inspect and manipulate almost any part of it before saving. For large write-only jobs, openpyxl also offers a write-only mode, but the default model is built around in-memory access.
xlsxwriter is write-only. It starts from a blank workbook and is optimized for creating new files, so it cannot read or modify existing workbooks. For large exports, you can enable the constant_memory option so worksheet data is written as it goes, keeping memory usage lower. That option is useful when you do not need to revisit or modify cells after writing them.
Feature Comparison
The two libraries overlap heavily for writing features, but openpyxl adds read and modify capabilities. Here is a high-level comparison:
| Feature | openpyxl | xlsxwriter |
|---|---|---|
| Read existing files | Yes | No |
| Write new files | Yes | Yes |
| Modify existing files | Yes | No |
| Formulas | Yes | Yes |
| Formatting | Yes | Yes |
| Charts | Yes | Yes |
| Images | Yes | Yes |
| Memory model | In-memory by default; write-only mode available | Write-only; constant-memory option available |
Both libraries support cell styles, merged cells, conditional formatting, data validation, and most common Excel features. The key differentiator is that openpyxl can load, modify, and save an existing file, while xlsxwriter always starts from a blank workbook.
Performance and Memory Behavior
openpyxl's default mode keeps cell values and styles in memory, so memory use tends to grow with the amount of data. For a few thousand rows this is rarely a problem. For hundreds of thousands of rows, the in-memory object graph can consume significant RAM. If you only need to write a new file, openpyxl's write-only mode (Workbook(write_only=True)) can reduce memory use, though it trades away full in-memory flexibility.
xlsxwriter is write-only and offers a constant_memory mode through the Workbook options, for example xlsxwriter.Workbook('large.xlsx', {'constant_memory': True}). In that mode, it writes worksheet data as it goes rather than building the whole workbook in memory. Without that mode, memory use is higher for large worksheets. Like openpyxl's write-only mode, constant_memory is best when you do not need to revisit or modify cells after writing.
Speed depends on data size, formatting, formulas, and which Excel features you use. Choose based on whether you need to read or modify files, and on the memory mode that fits your export job.
Practical Example: Writing a Workbook with Both
Here is a simple example that writes a header row and a few data rows with basic formatting.
openpyxl
from openpyxl import Workbook
from openpyxl.styles import Font
wb = Workbook()
ws = wb.active
ws.title = 'Products'
headers = ['Name', 'Price', 'Quantity']
ws.append(headers)
for cell in ws[1]:
cell.font = Font(bold=True)
rows = [
('Widget', 9.99, 100),
('Gadget', 14.49, 50),
]
for row in rows:
ws.append(row)
wb.save('products_openpyxl.xlsx')openpyxl uses an append-style API. The workbook is built in memory, and you save it at the end. This works well when you need to manipulate cells after writing them.
xlsxwriter
import xlsxwriter
workbook = xlsxwriter.Workbook('products_xlsxwriter.xlsx')
worksheet = workbook.add_worksheet('Products')
headers = ['Name', 'Price', 'Quantity']
bold = workbook.add_format({'bold': True})
for col, header in enumerate(headers):
worksheet.write(0, col, header, bold)
rows = [
('Widget', 9.99, 100),
('Gadget', 14.49, 50),
]
for row_idx, row in enumerate(rows, start=1):
for col_idx, value in enumerate(row):
worksheet.write(row_idx, col_idx, value)
workbook.close()xlsxwriter uses a cell-based write API. You must close the workbook to flush the file. The write-only API does not allow you to revisit or modify cells after they have been written.
When to Choose openpyxl
Choose openpyxl when you need to:
- Read data from an existing .xlsx file.
- Modify specific cells, styles, or formulas in an existing workbook.
- Work with the workbook as an in-memory data structure before saving.
- Copy sheets, merge data from existing workbooks, or use features that require reading.
openpyxl is also a good choice for small to medium files where memory is not a concern and you want the flexibility of the default workbook model.
When to Choose xlsxwriter
Choose xlsxwriter when you only need to write new files and one of the following applies:
- You are generating large datasets and want the
constant_memoryoption to keep memory low. - You prefer a write-only API that does not carry the overhead of a read/write workbook model.
- You are streaming rows from a generator or database cursor and do not need to hold all cells in memory.
- You do not need to read or modify existing Excel workbooks.
xlsxwriter is particularly well-suited for server-side report generation where the output file is written to disk or sent as a download.
Edge Cases and Limitations
A common mistake is trying to use xlsxwriter to append to an existing file. It cannot do that. If you need to append, load the file with openpyxl, add the data, and save it again.
If you hit memory limits while writing, use the memory-saving mode for the library you have chosen: Workbook(write_only=True) for openpyxl, or the constant_memory option for xlsxwriter. Both modes are only for creating new workbooks.
Both libraries write formulas as strings; they do not evaluate them. Excel calculates the results when the file is opened. If you need calculated values, compute them in Python and write those results as plain values.
Charts and images work in both libraries, but their APIs differ. If you are porting code from one library to the other, plan to rewrite chart and image code because the object models are not compatible.
Making the Decision in Practice
The practical rule is simple: if you need to read or modify an existing workbook, use openpyxl. If you are generating a new file from scratch, choose the library whose API fits your workflow. For small files, either works. For large exports, enable the appropriate memory-saving mode so memory stays manageable: Workbook(write_only=True) for openpyxl or constant_memory for xlsxwriter.
Using openpyxl's default mode for a very large write-only job is possible, but you are paying for in-memory flexibility you do not need. xlsxwriter avoids that default overhead by starting with a write-only design, but its default mode is not automatically streaming unless you set constant_memory. Choose the mode that matches the job.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.