Convert HTML to PDF Behind Login Authentication in C#
To convert HTML to PDF behind login authentication in C#, use IronPDF's ChromeHttpLoginCredentials for network authentication or download HTML using System.Net.WebClient/HttpClient before conversion. This approach handles both network authentication and HTML form logins effectively.
Convert HTML pages to PDFs behind login forms using IronPDF's API. This guide demonstrates ChromeHttpLoginCredentials for authentication and protected content retrieval. Handle both network authentication and HTML form logins with straightforward code examples.
-
1Install IronPDF with NuGet Package Manager
-
2Copy and run this code snippet.
new ChromePdfRenderer { LoginCredentials = new ChromeHttpLoginCredentials { NetworkUsername = "username", NetworkPassword = "password" } } .RenderUrlAsPdf("https://example.com/protected") .SaveAs("secure.pdf");C# -
3Deploy to test on your live environment
Start using IronPDF in your project today with a free trial
Minimal Workflow (5 steps)
- Download the C# IronPDF Library
- Download the HTML to Avoid Logins
- Login using Network Authentication with LoginCredentials property
- Use HTML Form for Authentication
- Workaround for MVC Login Authentication
What Are the Best Practices for Handling Login Authentication?
IronPDF supports TLS network authentication (username and password) through the ChromeHttpLoginCredentials API. For comprehensive guidance on various login scenarios, see the TLS Website & System Logins tutorial.
The recommended approach is using System.Net.WebClient or HttpClient to download HTML and assets. This method supports headers, logins, and other requirements. After downloading to memory or disk, IronPDF converts the HTML to PDF. Extract assets like stylesheets and images using HtmlAgilityPack, then download with System.Net.WebClient.
// Your authentication token
string accessToken = "your-access-token";
// Download HTML content from a URL with authentication
using (WebClient client = new WebClient())
{
// Add authentication headers if needed
client.Headers.Add("Authorization", "Bearer " + accessToken);
// Download the HTML string
string html = client.DownloadString("http://www.example.com/protected-content");
// Load the HTML into an HtmlDocument for parsing
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(html);
// Extract all image sources for downloading
foreach(HtmlNode img in doc.DocumentNode.SelectNodes("//img"))
{
string imgSrc = img.GetAttributeValue("src", null);
Console.WriteLine($"Found image: {imgSrc}");
// Download each image asset
if (!string.IsNullOrEmpty(imgSrc))
{
string fileName = Path.GetFileName(imgSrc);
client.DownloadFile(imgSrc, fileName);
}
}
// Convert the downloaded HTML to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("authenticated-content.pdf");
}System.Uri constructor. To rebase all relative paths in an HTML document, add a <base> tag to the header using HtmlAgilityPack. Example. For more information on handling URLs and assets, see the Base URLs & Asset Encoding guide.Why Should I Download HTML Content First?
Downloading HTML content before conversion provides several advantages:
- Complete Control: Modify HTML, fix broken links, or inject authentication tokens before conversion
- Asset Management: Download and cache external resources like images, CSS, and JavaScript files
- Authentication Flexibility: Use any .NET authentication mechanism including OAuth, JWT tokens, or custom headers
- Performance: Cache frequently accessed content to reduce server load
- Debugging: Inspect the exact HTML being converted to troubleshoot issues
For complex authentication scenarios involving cookies and sessions, see the Cookies guide which explains authentication state management during PDF conversion.
How Do I Handle Assets Like Images and Stylesheets?
When converting authenticated pages, external assets often require the same authentication. Here's a comprehensive approach using HttpClient:
public async Task<string> DownloadAuthenticatedHtmlWithAssets(string url, string authToken)
{
using (var client = new HttpClient())
{
// Set authentication header
client.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authToken);
// Download the main HTML
string html = await client.GetStringAsync(url);
// Parse HTML to find assets
var doc = new HtmlDocument();
doc.LoadHtml(html);
// Create a base URI for resolving relative paths
var baseUri = new Uri(url);
// Download CSS files
var cssLinks = doc.DocumentNode.SelectNodes("//link[@rel='stylesheet']");
if (cssLinks != null)
{
foreach (var link in cssLinks)
{
string href = link.GetAttributeValue("href", "");
if (!string.IsNullOrEmpty(href))
{
var cssUri = new Uri(baseUri, href);
string cssContent = await client.GetStringAsync(cssUri);
// Embed CSS directly in the HTML
var styleNode = doc.CreateElement("style");
styleNode.InnerHtml = cssContent;
doc.DocumentNode.SelectSingleNode("//head").AppendChild(styleNode);
// Remove the external link
link.Remove();
}
}
}
// Return the modified HTML with embedded assets
return doc.DocumentNode.OuterHtml;
}
}Public Async Function DownloadAuthenticatedHtmlWithAssets(url As String, authToken As String) As Task(Of String)
Using client As New HttpClient()
' Set authentication header
client.DefaultRequestHeaders.Authorization = New System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authToken)
' Download the main HTML
Dim html As String = Await client.GetStringAsync(url)
' Parse HTML to find assets
Dim doc As New HtmlDocument()
doc.LoadHtml(html)
' Create a base URI for resolving relative paths
Dim baseUri As New Uri(url)
' Download CSS files
Dim cssLinks = doc.DocumentNode.SelectNodes("//link[@rel='stylesheet']")
If cssLinks IsNot Nothing Then
For Each link In cssLinks
Dim href As String = link.GetAttributeValue("href", "")
If Not String.IsNullOrEmpty(href) Then
Dim cssUri As New Uri(baseUri, href)
Dim cssContent As String = Await client.GetStringAsync(cssUri)
' Embed CSS directly in the HTML
Dim styleNode = doc.CreateElement("style")
styleNode.InnerHtml = cssContent
doc.DocumentNode.SelectSingleNode("//head").AppendChild(styleNode)
' Remove the external link
link.Remove()
End If
Next
End If
' Return the modified HTML with embedded assets
Return doc.DocumentNode.OuterHtml
End Using
End FunctionWhat Tools Help with HTML Parsing?
The HtmlAgilityPack is the most popular HTML parsing library for .NET, but alternatives exist:
- HtmlAgilityPack: Best for general HTML parsing and manipulation
- AngleSharp: Modern, standards-compliant HTML parser with CSS selector support
- CsQuery: jQuery-like syntax for C# developers familiar with jQuery
- Regular Expressions: For simple extraction tasks (not recommended for complex HTML)
ChromeHttpLoginCredentials
How Do I Login Using Network Authentication?
Most ASP.NET applications support network authentication, which is more reliable than HTML form posting. IronPDF provides built-in support for basic, digest, and NTLM authentication through the ChromeHttpLoginCredentials class. For additional header customization, see the HTTP Request Header guide.
using IronPdf;
using System;
ChromePdfRenderer renderer = new ChromePdfRenderer
{
// setting login credentials to bypass basic authentication
LoginCredentials = new ChromeHttpLoginCredentials()
{
NetworkUsername = "testUser",
NetworkPassword = "testPassword"
}
};
var uri = new Uri("http://localhost:51169/Invoice");
// Render web URL to PDF
PdfDocument pdf = renderer.RenderUrlAsPdf(uri);
// Export PDF
pdf.SaveAs("UrlToPdfExample.Pdf");Imports IronPdf
Imports System
Private renderer As New ChromePdfRenderer With {
.LoginCredentials = New ChromeHttpLoginCredentials() With {
.NetworkUsername = "testUser",
.NetworkPassword = "testPassword"
}
}
Private uri = New Uri("http://localhost:51169/Invoice")
' Render web URL to PDF
Private pdf As PdfDocument = renderer.RenderUrlAsPdf(uri)
' Export PDF
pdf.SaveAs("UrlToPdfExample.Pdf")Why Is Network Authentication More Reliable Than Form Posting?
Network authentication offers several advantages over HTML form posting:
- Standardized Protocol: Uses HTTP authentication headers following RFC standards
- Browser Integration: Chrome rendering engine handles authentication
- Session Management: Automatic handling of authentication challenges and session persistence
- Security: Credentials transmitted securely via headers rather than form data
- Compatibility: Works with most enterprise authentication systems (
Active Directory,LDAP)
What Credentials Do I Need for Network Authentication?
Different authentication types require different credentials:
// Basic Authentication (most common)
var basicAuth = new ChromeHttpLoginCredentials
{
NetworkUsername = "user@domain.com",
NetworkPassword = "password123"
};
// NTLM/Windows Authentication
var ntlmAuth = new ChromeHttpLoginCredentials
{
NetworkUsername = "DOMAIN\\username", // Include domain
NetworkPassword = "password123"
};
// Custom authentication headers
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HttpRequestHeaders = new Dictionary<string, string>
{
{ "X-API-Key", "your-api-key" },
{ "Authorization", "Bearer " + jwtToken }
};How Do I Troubleshoot Authentication Failures?
Common authentication issues and solutions:
- 401 Unauthorized: Check credentials and authentication type
- 403 Forbidden: User authenticated but lacks permissions
- Timeout Errors: Increase
Timeoutfor slow authentication systems - Certificate Errors: Configure TLS/SSL settings appropriately
Enable debugging to diagnose issues:
// Enable detailed logging
IronPdf.Logging.Logger.EnableDebugging = true;
IronPdf.Logging.Logger.LogFilePath = "IronPdf.log";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
// Test authentication
try
{
var pdf = renderer.RenderUrlAsPdf("https://secure.example.com");
pdf.SaveAs("authenticated.pdf");
}
catch (Exception ex)
{
Console.WriteLine($"Authentication failed: {ex.Message}");
// Check IronPdf.log for detailed error information
}Imports IronPdf
Imports System
' Enable detailed logging
Logging.Logger.EnableDebugging = True
Logging.Logger.LogFilePath = "IronPdf.log"
Logging.Logger.LoggingMode = Logging.Logger.LoggingModes.All
' Test authentication
Try
Dim pdf = renderer.RenderUrlAsPdf("https://secure.example.com")
pdf.SaveAs("authenticated.pdf")
Catch ex As Exception
Console.WriteLine($"Authentication failed: {ex.Message}")
' Check IronPdf.log for detailed error information
End Try
My favorite library of this kind is IronPDF. It allows for fast and efficient manipulation of PDF files. It also has many valuable features, like exporting to PDF/A format and digitally signing PDF documents.
IronOCR means we can save $40,000 annually from manual processing, while enhancing productivity and freeing up resources for high-impact tasks. I would highly recommend it.
The IronSuite play a crucial role in our operations. These are tools that increase efficiencies across the business including creating floor plans and improving inventory management.
How Do I Login Using an HTML Form?
To log in by sending data to an HTML form, use the ChromeHttpLoginCredentials class. See IronPDF's ChromeHttpLoginCredentials API.
Consider these points:
- Post login data to the URL specified in the HTML form's ACTION attribute. Set this as the
LoginFormUrlattribute ofHttpLoginCredentials. This may differ from the URL you want to render as a PDF. - Send data representing every input and textarea in the HTML form. The name attributes define each variable name (not the id).
- Some websites actively protect against machine login.
// Configure form-based login
var formLogin = new ChromeHttpLoginCredentials
{
LoginFormUrl = "https://example.com/login",
LoginFormData = new Dictionary<string, string>
{
{"username", "user@example.com"},
{"password", "securePassword123"},
{"rememberMe", "true"},
{"csrf_token", "abc123"} // Include any hidden fields
}
};
var renderer = new ChromePdfRenderer
{
LoginCredentials = formLogin,
RenderingOptions = new ChromePdfRenderOptions
{
RenderDelay = 3000, // Allow time for login redirect
EnableJavaScript = true
}
};
// The actual page you want to convert (after login)
var pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard");
pdf.SaveAs("dashboard.pdf");Imports System.Collections.Generic
' Configure form-based login
Dim formLogin As New ChromeHttpLoginCredentials With {
.LoginFormUrl = "https://example.com/login",
.LoginFormData = New Dictionary(Of String, String) From {
{"username", "user@example.com"},
{"password", "securePassword123"},
{"rememberMe", "true"},
{"csrf_token", "abc123"} ' Include any hidden fields
}
}
Dim renderer As New ChromePdfRenderer With {
.LoginCredentials = formLogin,
.RenderingOptions = New ChromePdfRenderOptions With {
.RenderDelay = 3000, ' Allow time for login redirect
.EnableJavaScript = True
}
}
' The actual page you want to convert (after login)
Dim pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard")
pdf.SaveAs("dashboard.pdf")What Form Data Do I Need to Capture?
To authenticate successfully via HTML forms, capture all form inputs:
// Use this helper method to extract form fields
public Dictionary<string, string> ExtractFormFields(string loginPageHtml)
{
var formData = new Dictionary<string, string>();
var doc = new HtmlDocument();
doc.LoadHtml(loginPageHtml);
// Find all input fields
var inputs = doc.DocumentNode.SelectNodes("//input");
if (inputs != null)
{
foreach (var input in inputs)
{
string name = input.GetAttributeValue("name", "");
string value = input.GetAttributeValue("value", "");
string type = input.GetAttributeValue("type", "text");
if (!string.IsNullOrEmpty(name))
{
// Handle different input types
switch (type.ToLower())
{
case "checkbox":
if (input.Attributes["checked"] != null)
formData[name] = "on";
break;
case "radio":
if (input.Attributes["checked"] != null)
formData[name] = value;
break;
default:
formData[name] = value;
break;
}
}
}
}
// Don't forget select elements
var selects = doc.DocumentNode.SelectNodes("//select");
if (selects != null)
{
foreach (var select in selects)
{
string name = select.GetAttributeValue("name", "");
var selected = select.SelectSingleNode(".//option[@selected]");
if (selected != null && !string.IsNullOrEmpty(name))
{
formData[name] = selected.GetAttributeValue("value", "");
}
}
}
return formData;
}' Use this helper method to extract form fields
Public Function ExtractFormFields(loginPageHtml As String) As Dictionary(Of String, String)
Dim formData As New Dictionary(Of String, String)()
Dim doc As New HtmlDocument()
doc.LoadHtml(loginPageHtml)
' Find all input fields
Dim inputs = doc.DocumentNode.SelectNodes("//input")
If inputs IsNot Nothing Then
For Each input In inputs
Dim name As String = input.GetAttributeValue("name", "")
Dim value As String = input.GetAttributeValue("value", "")
Dim type As String = input.GetAttributeValue("type", "text")
If Not String.IsNullOrEmpty(name) Then
' Handle different input types
Select Case type.ToLower()
Case "checkbox"
If input.Attributes("checked") IsNot Nothing Then
formData(name) = "on"
End If
Case "radio"
If input.Attributes("checked") IsNot Nothing Then
formData(name) = value
End If
Case Else
formData(name) = value
End Select
End If
Next
End If
' Don't forget select elements
Dim selects = doc.DocumentNode.SelectNodes("//select")
If selects IsNot Nothing Then
For Each selectNode In selects
Dim name As String = selectNode.GetAttributeValue("name", "")
Dim selected = selectNode.SelectSingleNode(".//option[@selected]")
If selected IsNot Nothing AndAlso Not String.IsNullOrEmpty(name) Then
formData(name) = selected.GetAttributeValue("value", "")
End If
Next
End If
Return formData
End FunctionHow Do I Find the Correct Form Action URL?
The form action URL is critical for successful authentication:
public string ExtractFormAction(string loginPageUrl, string loginPageHtml)
{
var doc = new HtmlDocument();
doc.LoadHtml(loginPageHtml);
// Find the login form
var form = doc.DocumentNode.SelectSingleNode("//form[contains(@action, 'login') or contains(@id, 'login') or contains(@class, 'login')]");
if (form == null)
{
// Try finding any form with password field
form = doc.DocumentNode.SelectSingleNode("//form[.//input[@type='password']]");
}
if (form != null)
{
string action = form.GetAttributeValue("action", "");
// Resolve relative URLs
if (!string.IsNullOrEmpty(action))
{
var baseUri = new Uri(loginPageUrl);
var actionUri = new Uri(baseUri, action);
return actionUri.ToString();
}
}
// Default to the login page URL if no action found
return loginPageUrl;
}Public Function ExtractFormAction(loginPageUrl As String, loginPageHtml As String) As String
Dim doc As New HtmlDocument()
doc.LoadHtml(loginPageHtml)
' Find the login form
Dim form As HtmlNode = doc.DocumentNode.SelectSingleNode("//form[contains(@action, 'login') or contains(@id, 'login') or contains(@class, 'login')]")
If form Is Nothing Then
' Try finding any form with password field
form = doc.DocumentNode.SelectSingleNode("//form[.//input[@type='password']]")
End If
If form IsNot Nothing Then
Dim action As String = form.GetAttributeValue("action", "")
' Resolve relative URLs
If Not String.IsNullOrEmpty(action) Then
Dim baseUri As New Uri(loginPageUrl)
Dim actionUri As New Uri(baseUri, action)
Return actionUri.ToString()
End If
End If
' Default to the login page URL if no action found
Return loginPageUrl
End FunctionWhat Are Common Issues with Form-Based Authentication?
- CSRF Tokens: Many forms include anti-forgery tokens that expire
- JavaScript Validation: Some forms require JavaScript execution
- Multi-Step Authentication: Forms that require multiple pages
- CAPTCHA Protection: Human verification challenges
- Session Timeouts: Login sessions that expire quickly
ViewBag
TempData
Html
For comprehensive HTML to PDF conversion guidance, including complex authentication scenarios, visit the HTML to PDF tutorial.
How Do I Handle MVC Authentication?
The following workaround renders a .NET MVC view to a string programmatically, avoiding MVC logins while rendering views faithfully. This approach works well when converting CSHTML to PDF in MVC Core or MVC Framework.
// Converts an MVC partial view to a string
public static string RenderPartialViewToString(this Controller controller, string viewPath, object model = null)
{
try
{
// Set the model
var context = controller.ControllerContext;
controller.ViewData.Model = model;
using (var sw = new StringWriter())
{
// Find the partial view
var viewResult = ViewEngines.Engines.FindPartialView(context, viewPath);
if (viewResult.View == null)
{
throw new Exception($"Partial view {viewPath} could not be found.");
}
// Create a view context
var viewContext = new ViewContext(context, viewResult.View, context.Controller.ViewData, context.Controller.TempData, sw);
// Render the view
viewResult.View.Render(viewContext, sw);
viewResult.ViewEngine.ReleaseView(context, viewResult.View);
return sw.GetStringBuilder().ToString();
}
}
catch (Exception ex)
{
// Return error message if there is an exception
return ex.Message;
}
}
// Usage in an MVC Controller
public ActionResult GeneratePdf()
{
// Render authenticated view to string
var model = new InvoiceViewModel { /* populate model */ };
string html = this.RenderPartialViewToString("~/Views/Invoice/Details.cshtml", model);
// Convert to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Return PDF file
return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}' Converts an MVC partial view to a string
<Extension()>
Public Shared Function RenderPartialViewToString(ByVal controller As Controller, ByVal viewPath As String, Optional ByVal model As Object = Nothing) As String
Try
' Set the model
Dim context = controller.ControllerContext
controller.ViewData.Model = model
Using sw As New StringWriter()
' Find the partial view
Dim viewResult = ViewEngines.Engines.FindPartialView(context, viewPath)
If viewResult.View Is Nothing Then
Throw New Exception($"Partial view {viewPath} could not be found.")
End If
' Create a view context
Dim viewContext As New ViewContext(context, viewResult.View, context.Controller.ViewData, context.Controller.TempData, sw)
' Render the view
viewResult.View.Render(viewContext, sw)
viewResult.ViewEngine.ReleaseView(context, viewResult.View)
Return sw.GetStringBuilder().ToString()
End Using
Catch ex As Exception
' Return error message if there is an exception
Return ex.Message
End Try
End Function
' Usage in an MVC Controller
Public Function GeneratePdf() As ActionResult
' Render authenticated view to string
Dim model As New InvoiceViewModel() ' populate model
Dim html As String = Me.RenderPartialViewToString("~/Views/Invoice/Details.cshtml", model)
' Convert to PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Return PDF file
Return File(pdf.BinaryData, "application/pdf", "invoice.pdf")
End FunctionWhy Render Views to String Instead of Direct Conversion?
Rendering MVC views to string provides several key advantages:
- Authentication Context: Views render within the authenticated user's context
- Full MVC Pipeline: All MVC features work including
HtmlHelper,UrlHelper, andViewBaghelpers - Layout Support: Master pages and layouts render correctly
- Model Binding: Complex view models work
- Action Filters: Security and logging filters execute normally
What Are the Benefits of This MVC Workaround?
The MVC string rendering approach offers:
- Security: No need to expose internal URLs or bypass authentication
- Performance: Avoid additional HTTP requests
- Consistency: Identical output to what users see in browsers
- Flexibility: Modify HTML before PDF conversion
- Testing: Unit test HTML generation easily
How Do I Pass Models to the Rendered View?
Here's a comprehensive example with a complex model:
public class InvoiceController : Controller
{
private readonly IInvoiceService _invoiceService;
public async Task<ActionResult> DownloadInvoicePdf(int invoiceId)
{
// Load data within authenticated context
var invoice = await _invoiceService.GetInvoiceAsync(invoiceId);
if (invoice == null || invoice.UserId != User.Identity.GetUserId())
{
return HttpNotFound();
}
// Create view model
var viewModel = new InvoiceDetailsViewModel
{
Invoice = invoice,
Company = await _invoiceService.GetCompanyDetailsAsync(),
LineItems = await _invoiceService.GetLineItemsAsync(invoiceId),
TaxDetails = await _invoiceService.GetTaxDetailsAsync(invoiceId)
};
// Render to HTML string
string html = this.RenderPartialViewToString("~/Views/Invoice/DetailsPdf.cshtml", viewModel);
// Add custom styling for PDF
html = $@"
<html>
<head>
<style>
body {{ font-family: Arial, sans-serif; }}
.invoice-header {{ background-color: #f0f0f0; padding: 20px; }}
.line-items {{ width: 100%; border-collapse: collapse; }}
.line-items th, .line-items td {{ border: 1px solid #ddd; padding: 8px; }}
</style>
</head>
<body>
{html}
</body>
</html>";
// Convert to PDF with options
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
MarginTop = 20,
MarginBottom = 20,
MarginLeft = 10,
MarginRight = 10,
PrintHtmlBackgrounds = true
}
};
var pdf = renderer.RenderHtmlAsPdf(html);
// Add metadata
pdf.MetaData.Author = "Invoice System";
pdf.MetaData.Title = $"Invoice #{invoice.Number}";
pdf.MetaData.CreationDate = DateTime.Now;
return File(pdf.BinaryData, "application/pdf", $"Invoice-{invoice.Number}.pdf");
}
}Public Class InvoiceController
Inherits Controller
Private ReadOnly _invoiceService As IInvoiceService
Public Async Function DownloadInvoicePdf(invoiceId As Integer) As Task(Of ActionResult)
' Load data within authenticated context
Dim invoice = Await _invoiceService.GetInvoiceAsync(invoiceId)
If invoice Is Nothing OrElse invoice.UserId <> User.Identity.GetUserId() Then
Return HttpNotFound()
End If
' Create view model
Dim viewModel = New InvoiceDetailsViewModel With {
.Invoice = invoice,
.Company = Await _invoiceService.GetCompanyDetailsAsync(),
.LineItems = Await _invoiceService.GetLineItemsAsync(invoiceId),
.TaxDetails = Await _invoiceService.GetTaxDetailsAsync(invoiceId)
}
' Render to HTML string
Dim html As String = Me.RenderPartialViewToString("~/Views/Invoice/DetailsPdf.vbhtml", viewModel)
' Add custom styling for PDF
html = $"
<html>
<head>
<style>
body {{ font-family: Arial, sans-serif; }}
.invoice-header {{ background-color: #f0f0f0; padding: 20px; }}
.line-items {{ width: 100%; border-collapse: collapse; }}
.line-items th, .line-items td {{ border: 1px solid #ddd; padding: 8px; }}
</style>
</head>
<body>
{html}
</body>
</html>"
' Convert to PDF with options
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.MarginTop = 20,
.MarginBottom = 20,
.MarginLeft = 10,
.MarginRight = 10,
.PrintHtmlBackgrounds = True
}
}
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Add metadata
pdf.MetaData.Author = "Invoice System"
pdf.MetaData.Title = $"Invoice #{invoice.Number}"
pdf.MetaData.CreationDate = DateTime.Now
Return File(pdf.BinaryData, "application/pdf", $"Invoice-{invoice.Number}.pdf")
End Function
End ClassBefore implementing any authentication solution, ensure you have installed IronPDF properly and configured your license keys.
Ready to see what else you can do? Visit our tutorial page: Convert PDFs.
RenderDelay
Frequently Asked Questions
How can I convert HTML to PDF behind login authentication using C#?
You can use IronPDF's 'ChromeHttpLoginCredentials' class for network authentication or download the HTML using System.Net.WebClient or HttpClient before conversion. This handles both network and HTML form logins effectively.
What is the purpose of the 'ChromeHttpLoginCredentials' class in IronPDF?
The 'ChromeHttpLoginCredentials' class in IronPDF is used for network authentication, supporting various authentication types such as basic, digest, and NTLM. It helps bypass authentication for accessing protected HTML content.
Why should I download HTML content before converting it to PDF?
Downloading HTML content beforehand provides control over the HTML, allows asset management, enhances authentication flexibility, improves performance through caching, and aids in debugging by letting you inspect the HTML.
How does IronPDF handle assets like images and stylesheets during PDF conversion?
IronPDF can handle assets by leveraging HttpClient to download them. You can parse HTML with HtmlAgilityPack, resolve relative paths to absolute URLs, and embed CSS directly to ensure all resources are included in the PDF.
What are the benefits of using network authentication over form posting?
Network authentication uses standardized HTTP headers, is generally more secure, integrates well with browsers, manages sessions automatically, and is compatible with enterprise systems such as Active Directory.
What tools are recommended for parsing HTML in C#?
HtmlAgilityPack is popular for HTML parsing and manipulation in .NET. Alternatives include AngleSharp for modern HTML parsing, CsQuery for jQuery-like syntax, and regular expressions for simple extractions, though not recommended for complex tasks.
How do I log in using HTML form authentication with IronPDF?
Using IronPDF, you can configure form-based login by providing URL and form data to 'ChromeHttpLoginCredentials'. Ensure all input data from the HTML form, including hidden fields like CSRF tokens, are captured accurately.
What common issues might arise with form-based authentication?
Common issues include handling CSRF tokens, JavaScript validations, multi-step processes, CAPTCHA requirements, and session timeouts. Properly addressing these can ensure smoother login processes for automated tasks.
How can I troubleshoot authentication failures with IronPDF?
Authentication issues can be addressed by verifying credentials, checking for 401 or 403 errors, adjusting timeout settings, ensuring proper TLS/SSL configuration, and enabling detailed logging to diagnose problems.
What are the advantages of rendering MVC views to strings before converting to PDF?
Rendering views to strings maintains the authentication context, supports MVC features, and allows modification of HTML before conversion. This approach ensures security, performance, and consistency, reflecting what users see in browsers.
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
