How to Export an HTML Table to Excel in C# Using IronXL

Why Should You Use IronXL to Export HTML Table Data?

IronXL excels at creating and manipulating Excel files without requiring Microsoft Office installation, making it ideal for server environments and cross-platform applications. When paired with HTML Agility Pack, a capable HTML file and content parser, IronXL becomes a versatile solution for converting any HTML table structure to Excel sheet data. This approach works well with .NET 10 applications and can handle large datasets efficiently.

Unlike libraries such as the 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.

IronXL also provides a full suite of Excel features including formula support, cell styling, multiple worksheet management, and various export formats (XLSX, XLS, JSON, and CSV). You can create charts, export to PDF, and manage hidden field data, making it a complete solution for Excel automation beyond simple HTML table conversion.

How Do You Install the Required Libraries?

Install both IronXL and HTML Agility Pack through NuGet Package Manager. IronXL offers a free trial to test all features before committing to a license.

Install-Package IronXL.Excel
Install-Package HtmlAgilityPack

Install-Package IronXL.Excel
Install-Package HtmlAgilityPack

dotnet add package IronXL.Excel
dotnet add package HtmlAgilityPack

dotnet add package IronXL.Excel
dotnet add package HtmlAgilityPack

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

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

Imports IronXL
Imports HtmlAgilityPack
Imports System
Imports System.Linq

How Do You Parse HTML Table Data with HTML Agility Pack?

HTML Agility Pack provides a straightforward 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:

// 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");

' Sample HTML table with product data
Dim htmlContent As String = "
<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
Dim doc As New HtmlDocument()
doc.LoadHtml(htmlContent)

' Select the HTML table element using XPath
Dim table = doc.DocumentNode.SelectSingleNode("//table")

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 then processed to extract the cell value for conversion.

var web = new HtmlWeb();
var remoteDoc = web.Load("https://example.com/data-page");
var remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']");

var web = new HtmlWeb();
var remoteDoc = web.Load("https://example.com/data-page");
var remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']");

Dim web As New HtmlWeb()
Dim remoteDoc = web.Load("https://example.com/data-page")
Dim remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']")

How Do You Export Parsed Data to Excel Using IronXL?

With IronXL, you can 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 styling:

// 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");

Imports System
Imports System.Xml

' Create a new Excel workbook
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Exported Data")

' Extract and write headers
Dim headers As XmlNodeList = table.SelectNodes(".//thead/tr/th")
If headers IsNot Nothing Then
    For col As Integer = 0 To headers.Count - 1
        workSheet.SetCellValue(0, col, headers(col).InnerText.Trim())

        ' Apply header formatting
        Dim headerCell = workSheet.GetCellAt(0, col)
        headerCell.Style.Font.Bold = True
        headerCell.Style.BackgroundColor = "#4CAF50"
    Next
End If

' Extract and write data rows
Dim rows As XmlNodeList = table.SelectNodes(".//tbody/tr")
If rows IsNot Nothing Then
    For row As Integer = 0 To rows.Count - 1
        Dim cells As XmlNodeList = rows(row).SelectNodes("td")
        If cells IsNot Nothing Then
            For col As Integer = 0 To cells.Count - 1
                Dim cellValue As String = cells(col).InnerText.Trim()
                workSheet.SetCellValue(row + 1, col, cellValue)
            Next
        End If
    Next
End If

' Auto-fit columns for better readability
For col As Integer = 0 To If(headers?.Count, 0) - 1
    workSheet.AutoSizeColumn(col)
Next

' Save the Excel file
workBook.SaveAs("ExportedTable.xlsx")

This code demonstrates IronXL's intuitive API for C# Excel manipulation. It creates a new WorkBook and WorkSheet, then 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 row by row, with each cell's text content extracted and placed in the corresponding Excel cell. The AutoSizeColumn function ensures all content is visible, and the workbook is saved as an XLSX file.

Here you can see the original HTML table compared to the output from the code above:

// Apply number formatting to a price column (column index 1)
var priceRange = workSheet[$"B2:B{rows.Count + 1}"];
priceRange.FormatString = "$#,##0.00";

// Set font size on all header cells
var headerRange = workSheet[$"A1:{(char)('A' + headers.Count - 1)}1"];
headerRange.Style.Font.Height = 13; // in half-points, so 13 = 6.5pt

// Apply number formatting to a price column (column index 1)
var priceRange = workSheet[$"B2:B{rows.Count + 1}"];
priceRange.FormatString = "$#,##0.00";

// Set font size on all header cells
var headerRange = workSheet[$"A1:{(char)('A' + headers.Count - 1)}1"];
headerRange.Style.Font.Height = 13; // in half-points, so 13 = 6.5pt

' Apply number formatting to a price column (column index 1)
Dim priceRange = workSheet($"B2:B{rows.Count + 1}")
priceRange.FormatString = "$#,##0.00"

' Set font size on all header cells
Dim headerRange = workSheet($"A1:{Chr(Asc("A"c) + headers.Count - 1)}1")
headerRange.Style.Font.Height = 13 ' in half-points, so 13 = 6.5pt

How Do You Handle Multiple Tables and Error Scenarios?

When working with multiple tables on a single page, use SelectNodes("//table") to retrieve all tables and iterate through them, creating a separate worksheet for each:

var tables = doc.DocumentNode.SelectNodes("//table");
if (tables != null)
{
    for (int t = 0; t < tables.Count; t++)
    {
        WorkSheet ws = workBook.CreateWorkSheet($"Table_{t + 1}");
        var tblHeaders = tables[t].SelectNodes(".//thead/tr/th");
        var tblRows = tables[t].SelectNodes(".//tbody/tr");

        if (tblHeaders != null)
        {
            for (int col = 0; col < tblHeaders.Count; col++)
            {
                ws.SetCellValue(0, col, tblHeaders[col].InnerText.Trim());
                ws.GetCellAt(0, col).Style.Font.Bold = true;
            }
        }

        if (tblRows != null)
        {
            for (int row = 0; row < tblRows.Count; row++)
            {
                var cells = tblRows[row].SelectNodes("td");
                if (cells != null)
                {
                    for (int col = 0; col < cells.Count; col++)
                    {
                        ws.SetCellValue(row + 1, col, cells[col].InnerText.Trim());
                    }
                }
            }
        }
    }
}

workBook.SaveAs("MultiTableExport.xlsx");

var tables = doc.DocumentNode.SelectNodes("//table");
if (tables != null)
{
    for (int t = 0; t < tables.Count; t++)
    {
        WorkSheet ws = workBook.CreateWorkSheet($"Table_{t + 1}");
        var tblHeaders = tables[t].SelectNodes(".//thead/tr/th");
        var tblRows = tables[t].SelectNodes(".//tbody/tr");

        if (tblHeaders != null)
        {
            for (int col = 0; col < tblHeaders.Count; col++)
            {
                ws.SetCellValue(0, col, tblHeaders[col].InnerText.Trim());
                ws.GetCellAt(0, col).Style.Font.Bold = true;
            }
        }

        if (tblRows != null)
        {
            for (int row = 0; row < tblRows.Count; row++)
            {
                var cells = tblRows[row].SelectNodes("td");
                if (cells != null)
                {
                    for (int col = 0; col < cells.Count; col++)
                    {
                        ws.SetCellValue(row + 1, col, cells[col].InnerText.Trim());
                    }
                }
            }
        }
    }
}

workBook.SaveAs("MultiTableExport.xlsx");

Imports System

Dim tables = doc.DocumentNode.SelectNodes("//table")
If tables IsNot Nothing Then
    For t As Integer = 0 To tables.Count - 1
        Dim ws As WorkSheet = workBook.CreateWorkSheet($"Table_{t + 1}")
        Dim tblHeaders = tables(t).SelectNodes(".//thead/tr/th")
        Dim tblRows = tables(t).SelectNodes(".//tbody/tr")

        If tblHeaders IsNot Nothing Then
            For col As Integer = 0 To tblHeaders.Count - 1
                ws.SetCellValue(0, col, tblHeaders(col).InnerText.Trim())
                ws.GetCellAt(0, col).Style.Font.Bold = True
            Next
        End If

        If tblRows IsNot Nothing Then
            For row As Integer = 0 To tblRows.Count - 1
                Dim cells = tblRows(row).SelectNodes("td")
                If cells IsNot Nothing Then
                    For col As Integer = 0 To cells.Count - 1
                        ws.SetCellValue(row + 1, col, cells(col).InnerText.Trim())
                    Next
                End If
            Next
        End If
    Next
End If

workBook.SaveAs("MultiTableExport.xlsx")

try
{
    var headerNodes = table.SelectNodes(".//thead/tr/th")
                     ?? table.SelectNodes(".//tr[1]/th")
                     ?? table.SelectNodes(".//tr[1]/td");

    var dataRows = table.SelectNodes(".//tbody/tr")
                  ?? table.SelectNodes(".//tr[position()>1]");

    // ... process as normal
}
catch (Exception ex)
{
    Console.WriteLine($"Table parsing failed: {ex.Message}");
}

try
{
    var headerNodes = table.SelectNodes(".//thead/tr/th")
                     ?? table.SelectNodes(".//tr[1]/th")
                     ?? table.SelectNodes(".//tr[1]/td");

    var dataRows = table.SelectNodes(".//tbody/tr")
                  ?? table.SelectNodes(".//tr[position()>1]");

    // ... process as normal
}
catch (Exception ex)
{
    Console.WriteLine($"Table parsing failed: {ex.Message}");
}

Imports System

Try
    Dim headerNodes = table.SelectNodes(".//thead/tr/th") _
                     OrElse table.SelectNodes(".//tr[1]/th") _
                     OrElse table.SelectNodes(".//tr[1]/td")

    Dim dataRows = table.SelectNodes(".//tbody/tr") _
                  OrElse table.SelectNodes(".//tr[position()>1]")

    ' ... process as normal
Catch ex As Exception
    Console.WriteLine($"Table parsing failed: {ex.Message}")
End Try

How Do You Save and Export the Excel File?

IronXL supports multiple output formats beyond XLSX. You can save as XLS, CSV, TSV, or JSON depending on the downstream requirements. You can also stream the output directly to an HTTP response in ASP.NET Core, which avoids writing a file to disk:

// Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx");

// Save as CSV
workBook.SaveAsCsv("ExportedTable.csv");

// Stream to HTTP response (ASP.NET Core)
// Response.Headers["Content-Disposition"] = "attachment; filename=ExportedTable.xlsx";
// workBook.SaveAs(Response.BodyWriter.AsStream());

// Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx");

// Save as CSV
workBook.SaveAsCsv("ExportedTable.csv");

// Stream to HTTP response (ASP.NET Core)
// Response.Headers["Content-Disposition"] = "attachment; filename=ExportedTable.xlsx";
// workBook.SaveAs(Response.BodyWriter.AsStream());

' Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx")

' Save as CSV
workBook.SaveAsCsv("ExportedTable.csv")

' Stream to HTTP response (ASP.NET Core)
' Response.Headers("Content-Disposition") = "attachment; filename=ExportedTable.xlsx"
' workBook.SaveAs(Response.BodyWriter.AsStream())

When streaming to an HTTP response, make sure the Content-Disposition header is set to attachment so the browser treats the response as a file download. This pattern works well in both MVC controllers and Razor Pages.

For scenarios where you need to export data to an existing Excel template, IronXL can load an existing workbook and populate named ranges or specific cell addresses with the parsed HTML data, preserving all the formatting in the template.

What Are the Best Practices for Production Use?

When processing content from a URL or database query for further analysis, 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.

For reading data back from Excel files after export, IronXL uses the same WorkBook.Load API, making round-trip workflows straightforward. You can also convert the resulting Excel file to other formats such as JSON or XML for further processing.

How Do You Manage Licensing and Deployment?

IronXL requires a license key for production use. The free trial includes all features and is ideal for evaluating the library before purchasing. Explore the pricing and licensing options to find the right tier for your team.

For deployment in Docker, Azure Functions, or Linux environments, IronXL does not depend on Microsoft Office or COM Interop, making it a straightforward dependency to manage. It supports .NET 10, .NET 9, .NET 8, .NET Framework 4.6.2+, and is fully compatible with the current ASP.NET Core export patterns.

The combination of IronXL and HTML Agility Pack provides a flexible solution for exporting HTML tables to Excel in C#. The approach demonstrated here offers more control than rigid built-in methods, letting you handle complex HTML structures while taking advantage of IronXL's full Excel feature set.

Whether you are building web scrapers, migrating legacy data from a database, automating report generation, or performing data analysis on large datasets, this solution scales to meet enterprise needs. The code examples show how to handle various input sources, from static HTML strings to dynamic content retrieved via URL. Results can be exported for download or further processing in your .NET application.

Ready to transform your HTML data into professional Excel files? Start your free trial of IronXL today and experience the flexibility of programmatic Excel manipulation without Office dependencies.