How to Export HTML Table to Excel in C#

What Makes IronXL Suitable for Enterprise Environments?

IronXL excels at creating and manipulating Excel files without requiring Microsoft Office installation, making it ideal for server environments and cross-platform applications. The library supports deployment to Azure, AWS Lambda Functions, and Docker containers, ensuring compatibility with modern cloud architectures. When paired with HTML Agility Pack, a robust HTML file and content parser, IronXL becomes a versatile solution for converting any HTML table structure to Excel sheet data. This approach works seamlessly with .NET applications and can handle large datasets efficiently through optimized performance features.

For enterprise environments requiring strict compliance, IronXL provides comprehensive security documentation and supports password-protected workbooks and encrypted worksheets. The library also runs seamlessly on Linux servers and macOS systems, providing true cross-platform compatibility essential for diverse enterprise infrastructures.

How Does IronXL Compare to Other Excel Libraries?

Unlike libraries such as Syncfusion Excel library's XlsIO, which offers an ImportHtmlTable function limited to specific HTML formats and table structures, the IronXL approach gives developers complete control over the parsing and conversion process. This flexibility means developers can handle complex scenarios like nested tables, custom data formatting, and selective column extraction that rigid built-in methods cannot accommodate. The default settings work well for most use cases, but you can customize every detail including cell fonts and sizes, background patterns and colors, and border alignments.

IronXL's extensive API reference provides developers with granular control over every aspect of Excel manipulation, from conditional formatting to chart creation. This level of control is particularly valuable when dealing with enterprise data that requires specific formatting for regulatory compliance or corporate standards.

What Advanced Features Does IronXL Provide?

Additionally, IronXL provides comprehensive Excel features including formula support, cell styling, multiple worksheet management, and various export formats (XLSX, XLS, JSON, and CSV file). The library supports math functions like Sum, Average, Min, and Max, enabling complex calculations directly within the generated Excel files. You can even create charts, export to PDF, and manage hidden field data, making it a complete solution for Excel automation needs beyond simple HTML table conversion. Whether working with a DataTable object or a spreadsheet file, IronXL handles the conversion seamlessly.

For enterprise reporting needs, IronXL supports named ranges for improved formula readability, freeze panes for better data navigation, and group/ungroup functionality for organizing complex data structures. The library also provides autosize capabilities to ensure all content is properly displayed.

Which NuGet Packages Are Required?

First, install both IronXL and HTML Agility Pack through NuGet Package Manager. IronXL offers a free trial to test all features and provides detailed licensing documentation for enterprise deployments:

Install-Package IronXL.Excel
Install-Package HtmlAgilityPack

Install-Package IronXL.Excel
Install-Package HtmlAgilityPack

For enterprise environments, you can configure the license key in Web.config or apply it programmatically using the licensing API. The library supports various deployment scenarios including ASP.NET web applications and Blazor server-side applications.

What Namespaces Should I Import?

These NuGet packages allow you to create, load, and save Excel documents programmatically. Then import the necessary using statements to your C# code file:

using IronXL;
using HtmlAgilityPack;
using System;
using System.Linq;

using IronXL;
using HtmlAgilityPack;
using System;
using System.Linq;

These libraries work seamlessly together, with HTML Agility Pack handling the HTML parsing while IronXL manages the Excel file creation and manipulation. This example demonstrates a straightforward approach to converting HTML tables to XLSX format. For VB.NET developers, similar functionality is available with minor syntax adjustments.

What Is the Basic Approach to Extract HTML Table Content?

HTML Agility Pack provides a simple way to navigate HTML documents using XPath expressions. The following code shows how to extract data from an HTML table and prepare it for export using IronXL's data import capabilities:

// Sample HTML table with product data
string htmlContent = @"
<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Price</th>
            <th>Stock</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Laptop</td>
            <td>$999</td>
            <td>15</td>
        </tr>
        <tr>
            <td>Mouse</td>
            <td>$25</td>
            <td>50</td>
        </tr>
        <tr>
            <td>Keyboard</td>
            <td>$75</td>
            <td>30</td>
        </tr>
    </tbody>
</table>";
// Load HTML document for parsing
var doc = new HtmlDocument();
doc.LoadHtml(htmlContent);
// Select the HTML table element using XPath
var table = doc.DocumentNode.SelectSingleNode("//table");

// Sample HTML table with product data
string htmlContent = @"
<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Price</th>
            <th>Stock</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Laptop</td>
            <td>$999</td>
            <td>15</td>
        </tr>
        <tr>
            <td>Mouse</td>
            <td>$25</td>
            <td>50</td>
        </tr>
        <tr>
            <td>Keyboard</td>
            <td>$75</td>
            <td>30</td>
        </tr>
    </tbody>
</table>";
// Load HTML document for parsing
var doc = new HtmlDocument();
doc.LoadHtml(htmlContent);
// Select the HTML table element using XPath
var table = doc.DocumentNode.SelectSingleNode("//table");

This parsing approach works well with various HTML sources, whether from web scraping, database exports, or dynamically generated content. The extracted data can be further processed using IronXL's data manipulation features before export.

How Does XPath Selection Work for Table Elements?

This code loads the HTML content into an HtmlDocument object and uses XPath to query and select the table element. The SelectSingleNode method returns the first table found in the HTML, making it easy to target specific tables when multiple exist. Each table row is processed to extract the cell value for conversion, similar to how IronXL's range selection works for Excel data.

For more complex scenarios involving merged cells or repeating rows and columns, additional parsing logic may be required to maintain the proper structure during conversion.

What Code Converts HTML Table Data to Excel Format?

With IronXL, we can easily convert the parsed HTML table data into a professional Excel spreadsheet with proper formatting. The following code demonstrates how to export the data with custom font size and font family settings:

// Create a new Excel workbook
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Exported Data");
// Extract and write headers
var headers = table.SelectNodes(".//thead/tr/th");
if (headers != null)
{
    for (int col = 0; col < headers.Count; col++)
    {
        workSheet.SetCellValue(0, col, headers[col].InnerText.Trim());
        // Apply header formatting
        var headerCell = workSheet.GetCellAt(0, col);
        headerCell.Style.Font.Bold = true;
        headerCell.Style.BackgroundColor = "#4CAF50";
    }
}
// Extract and write data rows
var rows = table.SelectNodes(".//tbody/tr");
if (rows != null)
{
    for (int row = 0; row < rows.Count; row++)
    {
        var cells = rows[row].SelectNodes("td");
        if (cells != null)
        {
            for (int col = 0; col < cells.Count; col++)
            {
                string cellValue = cells[col].InnerText.Trim();
                workSheet.SetCellValue(row + 1, col, cellValue);
            }
        }
    }
}
// Auto-fit columns for better readability
for (int col = 0; col < headers?.Count; col++)
{
    workSheet.AutoSizeColumn(col);
}
// Save the Excel file
workBook.SaveAs("ExportedTable.xlsx");

// Create a new Excel workbook
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Exported Data");
// Extract and write headers
var headers = table.SelectNodes(".//thead/tr/th");
if (headers != null)
{
    for (int col = 0; col < headers.Count; col++)
    {
        workSheet.SetCellValue(0, col, headers[col].InnerText.Trim());
        // Apply header formatting
        var headerCell = workSheet.GetCellAt(0, col);
        headerCell.Style.Font.Bold = true;
        headerCell.Style.BackgroundColor = "#4CAF50";
    }
}
// Extract and write data rows
var rows = table.SelectNodes(".//tbody/tr");
if (rows != null)
{
    for (int row = 0; row < rows.Count; row++)
    {
        var cells = rows[row].SelectNodes("td");
        if (cells != null)
        {
            for (int col = 0; col < cells.Count; col++)
            {
                string cellValue = cells[col].InnerText.Trim();
                workSheet.SetCellValue(row + 1, col, cellValue);
            }
        }
    }
}
// Auto-fit columns for better readability
for (int col = 0; col < headers?.Count; col++)
{
    workSheet.AutoSizeColumn(col);
}
// Save the Excel file
workBook.SaveAs("ExportedTable.xlsx");

This code can be enhanced with additional formatting options such as number formats, cell comments, or hyperlinks to create more sophisticated Excel outputs. For large datasets, consider using IronXL's performance optimization features to handle file size limitations.

How Does the Excel API Structure Work?

This code demonstrates IronXL's intuitive API for C# Excel manipulation. First, it creates a new WorkBook and WorkSheet. Then it iterates through the parsed HTML table headers, placing them in the first row while applying bold formatting and a green background color. The data rows from the HTML table are processed similarly, with each cell's text content extracted and placed in the corresponding Excel cell. The AutoSizeColumn function ensures all content is visible, and finally, the workbook is saved as an XLSX file. You can easily download the generated file or store it in a database for later retrieval.

For enterprise scenarios requiring audit trails, you can add workbook metadata such as author information, creation date, and document properties. The library also supports print setup configuration for generating print-ready reports.

What Does the Final Output Look Like?

Here you can see the original HTML table compared to the output from above, demonstrating how IronXL maintains data integrity while providing professional formatting options:

How Can I Export Multiple HTML Tables?

When working with multiple tables, simply use SelectNodes("//table") to get all tables and iterate through them, creating separate worksheets for each. This example shows how to handle complex scenarios with large datasets using worksheet management techniques:

var tables = doc.DocumentNode.SelectNodes("//table");
foreach (var tbl in tables)
{
    // Create new worksheet for each table
    WorkSheet ws = workBook.CreateWorkSheet($"Table_{tables.IndexOf(tbl) + 1}");
    // Process table as shown above
}

var tables = doc.DocumentNode.SelectNodes("//table");
foreach (var tbl in tables)
{
    // Create new worksheet for each table
    WorkSheet ws = workBook.CreateWorkSheet($"Table_{tables.IndexOf(tbl) + 1}");
    // Process table as shown above
}

For more advanced scenarios, you can combine multiple Excel ranges, implement data validation, or add conditional formatting rules to highlight important data patterns.

What Error Handling Should I Implement?

For error handling, wrap the parsing logic in try-catch blocks to handle malformed HTML gracefully. IronXL automatically handles data type detection, converting numeric strings to numbers when appropriate using its built-in conversion capabilities. For more complex scenarios involving dynamic content, developers often combine this approach with tools like Selenium WebDriver for JavaScript-rendered tables.

When dealing with CSV files or TSV data, IronXL provides specialized methods to handle delimiter-based formats. The library also supports converting between different spreadsheet formats, making it easy to export to formats required by different systems.

How Do I Handle Special Data Requirements?

When processing content from a URL or database query for further analysis, you may need to handle additional details such as hidden field values or special formatting requirements. The default behavior works well for standard tables, but you can customize font size, font family, and other styling properties for each column or any specific table row as needed using IronXL's styling API.

For data that requires sorting or trimming, IronXL provides built-in methods to clean and organize data before final export. You can also add rows and columns dynamically based on your parsing requirements, or insert new rows and columns as needed during processing.

Enterprise applications often require exporting to different formats, such as converting to HTML for web display or integrating with SQL databases via DataTable conversions. IronXL supports all these scenarios with dedicated methods and comprehensive documentation.