Migrating from jsreport to IronPDF transforms your .NET PDF workflow from a Node.js-dependent system with external binary management and separate server processes to a pure .NET library that runs entirely in-process. This guide provides a comprehensive, step-by-step migration path that eliminates infrastructure complexity and JavaScript templating requirements for professional .NET developers.
jsreport introduces complexity that doesn't belong in a pure .NET environment:
jsreport.Binary, jsreport.Binary.Linux, jsreport.Binary.OSX).StartAsync() and KillAsync() lifecycle methods.RenderRequest objects with nested Template configurations for even simple PDF generation.| Feature | jsreport | IronPDF |
|---|---|---|
| Runtime | Node.js + .NET | Pure .NET |
| Binary Management | Manual (jsreport.Binary packages) | Automatic |
| Server Process | Required (utility or web server) | In-process |
| Templating | JavaScript (Handlebars, etc.) | C# (Razor, string interpolation) |
| API Style | Verbose request objects | Clean fluent methods |
| Output | Stream | PdfDocument object |
| PDF Manipulation | Limited | Extensive (merge, split, edit) |
| Async Support | Async-only | Both sync and async |
For teams planning .NET 10 and C# 14 adoption, IronPDF provides a native .NET foundation without external runtime dependencies.
| Feature | Migration Complexity |
|---|---|
| HTML to PDF | Very Low |
| URL to PDF | Very Low |
| Headers/Footers | Low |
| Page Settings | Low |
| Server Lifecycle | Low |
| Binary Management | Low |
The fundamental shift in this jsreport migration is from verbose request objects with server management to simple in-process method calls:
jsreport: LocalReporting().UseBinary().AsUtility().Create() → RenderAsync(RenderRequest) → Stream → File
IronPDF: ChromePdfRenderer → RenderHtmlAsPdf(html) → SaveAs()# Remove jsreport packages
dotnet remove package jsreport.Binary
dotnet remove package jsreport.Binary.Linux
dotnet remove package jsreport.Binary.OSX
dotnet remove package jsreport.Local
dotnet remove package jsreport.Types
dotnet remove package jsreport.Client
# Install IronPDF
dotnet add package IronPdf// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"# Find all jsreport references
grep -r "using jsreport\|LocalReporting\|RenderRequest\|RenderAsync" --include="*.cs" .
grep -r "JsReportBinary\|Template\|Recipe\|Engine\." --include="*.cs" .| jsreport Class | IronPDF Equivalent |
|---|---|
LocalReporting | ChromePdfRenderer |
ReportingService | ChromePdfRenderer |
RenderRequest | Method parameters |
Template | Method parameters |
Chrome | RenderingOptions |
Report | PdfDocument |
Engine | (not needed) |
| jsreport Method | IronPDF Equivalent |
|---|---|
LocalReporting().UseBinary().AsUtility().Create() | new ChromePdfRenderer() |
rs.RenderAsync(request) | renderer.RenderHtmlAsPdf(html) |
rs.StartAsync() | (not needed) |
rs.KillAsync() | (not needed) |
report.Content.CopyTo(stream) | pdf.SaveAs(path) or pdf.BinaryData |
| jsreport Template Property | IronPDF Equivalent |
|---|---|
Template.Content | First parameter to RenderHtmlAsPdf() |
Template.Recipe = Recipe.ChromePdf | (not needed) |
Template.Engine = Engine.None | (not needed) |
Chrome.HeaderTemplate | RenderingOptions.TextHeader or HtmlHeader |
Chrome.FooterTemplate | RenderingOptions.TextFooter or HtmlFooter |
Chrome.DisplayHeaderFooter | (automatic) |
Chrome.MarginTop | RenderingOptions.MarginTop |
| jsreport Placeholder | IronPDF Placeholder |
|---|---|
<span class='pageNumber'></span> | {page} |
<span class='totalPages'></span> | {total-pages} |
{#pageNum} | {page} |
{#numPages} | {total-pages} |
{#timestamp} | {date} |
Before (jsreport):
// NuGet: Install-Package jsreport.Binary
// NuGet: Install-Package jsreport.Local
// NuGet: Install-Package jsreport.Types
using jsreport.Binary;
using jsreport.Local;
using jsreport.Types;
using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var rs = new LocalReporting()
.UseBinary(JsReportBinary.GetBinary())
.AsUtility()
.Create();
var report = await rs.RenderAsync(new RenderRequest()
{
Template = new Template()
{
Recipe = Recipe.ChromePdf,
Engine = Engine.None,
Content = "<h1>Hello from jsreport</h1><p>This is a PDF document.</p>"
}
});
using (var fileStream = File.Create("output.pdf"))
{
report.Content.CopyTo(fileStream);
}
Console.WriteLine("PDF created successfully!");
}
}Imports jsreport.Binary
Imports jsreport.Local
Imports jsreport.Types
Imports System
Imports System.IO
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim rs = (New LocalReporting()) _
.UseBinary(JsReportBinary.GetBinary()) _
.AsUtility() _
.Create()
Dim report = Await rs.RenderAsync(New RenderRequest() With {
.Template = New Template() With {
.Recipe = Recipe.ChromePdf,
.Engine = Engine.None,
.Content = "<h1>Hello from jsreport</h1><p>This is a PDF document.</p>"
}
})
Using fileStream = File.Create("output.pdf")
report.Content.CopyTo(fileStream)
End Using
Console.WriteLine("PDF created successfully!")
End Function
End ModuleAfter (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF</h1><p>This is a PDF document.</p>");
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF created successfully!");
}
}Imports IronPdf
Imports System
Class Program
Shared Sub Main(args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF</h1><p>This is a PDF document.</p>")
pdf.SaveAs("output.pdf")
Console.WriteLine("PDF created successfully!")
End Sub
End ClassThe jsreport approach requires three NuGet packages (jsreport.Binary, jsreport.Local, jsreport.Types), three namespace imports, async-only execution, a fluent builder chain (LocalReporting().UseBinary().AsUtility().Create()), a verbose RenderRequest with nested Template object specifying Recipe and Engine, and manual stream-to-file copying with a using block.
IronPDF reduces this to one NuGet package, one namespace, three lines of code, and synchronous execution. The ChromePdfRenderer.RenderHtmlAsPdf() method accepts HTML directly and returns a PdfDocument with a simple SaveAs() method. See the HTML to PDF documentation for additional rendering options.
Before (jsreport):
// NuGet: Install-Package jsreport.Binary
// NuGet: Install-Package jsreport.Local
// NuGet: Install-Package jsreport.Types
using jsreport.Binary;
using jsreport.Local;
using jsreport.Types;
using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var rs = new LocalReporting()
.UseBinary(JsReportBinary.GetBinary())
.AsUtility()
.Create();
var report = await rs.RenderAsync(new RenderRequest()
{
Template = new Template()
{
Recipe = Recipe.ChromePdf,
Engine = Engine.None,
Content = "<html><body><script>window.location='https://example.com';</script></body></html>"
}
});
using (var fileStream = File.Create("webpage.pdf"))
{
report.Content.CopyTo(fileStream);
}
Console.WriteLine("Webpage PDF created successfully!");
}
}Imports jsreport.Binary
Imports jsreport.Local
Imports jsreport.Types
Imports System
Imports System.IO
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim rs = (New LocalReporting()) _
.UseBinary(JsReportBinary.GetBinary()) _
.AsUtility() _
.Create()
Dim report = Await rs.RenderAsync(New RenderRequest() With {
.Template = New Template() With {
.Recipe = Recipe.ChromePdf,
.Engine = Engine.None,
.Content = "<html><body><script>window.location='https://example.com';</script></body></html>"
}
})
Using fileStream = File.Create("webpage.pdf")
report.Content.CopyTo(fileStream)
End Using
Console.WriteLine("Webpage PDF created successfully!")
End Function
End ModuleAfter (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("webpage.pdf");
Console.WriteLine("Webpage PDF created successfully!");
}
}Imports IronPdf
Imports System
Class Program
Shared Sub Main(ByVal args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
pdf.SaveAs("webpage.pdf")
Console.WriteLine("Webpage PDF created successfully!")
End Sub
End Classjsreport can render a URL by setting Chrome.Url on the request, but there is no top-level convenience method - and a common pattern in existing code is the JavaScript redirect workaround (window.location='https://example.com') shown above, which can fail on sites that block scripted navigation.
IronPDF provides a dedicated RenderUrlAsPdf() method that takes the URL as a direct argument, with full JavaScript execution and modern CSS support. Learn more about URL to PDF conversion.
Before (jsreport):
// NuGet: Install-Package jsreport.Binary
// NuGet: Install-Package jsreport.Local
// NuGet: Install-Package jsreport.Types
using jsreport.Binary;
using jsreport.Local;
using jsreport.Types;
using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var rs = new LocalReporting()
.UseBinary(JsReportBinary.GetBinary())
.AsUtility()
.Create();
var report = await rs.RenderAsync(new RenderRequest()
{
Template = new Template()
{
Recipe = Recipe.ChromePdf,
Engine = Engine.None,
Content = "<h1>Document with Header and Footer</h1><p>Main content goes here.</p>",
Chrome = new Chrome()
{
DisplayHeaderFooter = true,
HeaderTemplate = "<div style='font-size:10px; text-align:center; width:100%;'>Custom Header</div>",
FooterTemplate = "<div style='font-size:10px; text-align:center; width:100%;'>Page <span class='pageNumber'></span> of <span class='totalPages'></span></div>"
}
}
});
using (var fileStream = File.Create("document_with_headers.pdf"))
{
report.Content.CopyTo(fileStream);
}
Console.WriteLine("PDF with headers and footers created successfully!");
}
}Imports jsreport.Binary
Imports jsreport.Local
Imports jsreport.Types
Imports System
Imports System.IO
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim rs = New LocalReporting() _
.UseBinary(JsReportBinary.GetBinary()) _
.AsUtility() _
.Create()
Dim report = Await rs.RenderAsync(New RenderRequest() With {
.Template = New Template() With {
.Recipe = Recipe.ChromePdf,
.Engine = Engine.None,
.Content = "<h1>Document with Header and Footer</h1><p>Main content goes here.</p>",
.Chrome = New Chrome() With {
.DisplayHeaderFooter = True,
.HeaderTemplate = "<div style='font-size:10px; text-align:center; width:100%;'>Custom Header</div>",
.FooterTemplate = "<div style='font-size:10px; text-align:center; width:100%;'>Page <span class='pageNumber'></span> of <span class='totalPages'></span></div>"
}
}
})
Using fileStream = File.Create("document_with_headers.pdf")
report.Content.CopyTo(fileStream)
End Using
Console.WriteLine("PDF with headers and footers created successfully!")
End Function
End ModuleAfter (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
CenterText = "Custom Header",
FontSize = 10
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10
};
var pdf = renderer.RenderHtmlAsPdf("<h1>Document with Header and Footer</h1><p>Main content goes here.</p>");
pdf.SaveAs("document_with_headers.pdf");
Console.WriteLine("PDF with headers and footers created successfully!");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering
Imports System
Module Program
Sub Main(args As String())
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.TextHeader = New TextHeaderFooter() With {
.CenterText = "Custom Header",
.FontSize = 10
}
renderer.RenderingOptions.TextFooter = New TextHeaderFooter() With {
.CenterText = "Page {page} of {total-pages}",
.FontSize = 10
}
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Document with Header and Footer</h1><p>Main content goes here.</p>")
pdf.SaveAs("document_with_headers.pdf")
Console.WriteLine("PDF with headers and footers created successfully!")
End Sub
End ModuleThe jsreport approach requires adding a Chrome object to the Template, setting DisplayHeaderFooter = true, and using HTML templates with special CSS class placeholders (<span class='pageNumber'></span>, <span class='totalPages'></span>). The header and footer templates must include full inline styling.
IronPDF provides a cleaner TextHeaderFooter configuration with dedicated properties for CenterText, LeftText, RightText, and FontSize. Page number placeholders use the simpler {page} and {total-pages} syntax. See the headers and footers documentation for HTML header options.
jsreport requires explicit server lifecycle management:
// jsreport (DELETE THIS):
var rs = new LocalReporting()
.UseBinary(JsReportBinary.GetBinary())
.AsUtility()
.Create();
// Or for web server mode:
var rs = new LocalReporting()
.UseBinary(JsReportBinary.GetBinary())
.AsWebServer()
.Create();
await rs.StartAsync();
// ... use rs ...
await rs.KillAsync();' jsreport (DELETE THIS):
Dim rs = (New LocalReporting()) _
.UseBinary(JsReportBinary.GetBinary()) _
.AsUtility() _
.Create()
' Or for web server mode:
rs = (New LocalReporting()) _
.UseBinary(JsReportBinary.GetBinary()) _
.AsWebServer() _
.Create()
Await rs.StartAsync()
' ... use rs ...
Await rs.KillAsync()IronPDF runs entirely in-process - no server startup, no process management, no cleanup:
// IronPDF:
var renderer = new ChromePdfRenderer();
// Just use it—no lifecycle management needednetjsreport requires separate NuGet packages for each target platform:
# DELETE these platform-specific packages:
dotnet remove package jsreport.Binary
dotnet remove package jsreport.Binary.Linux
dotnet remove package jsreport.Binary.OSXIronPDF handles all platform requirements automatically through a single NuGet package.
jsreport uses CSS class-based or curly brace placeholders. IronPDF uses a different syntax:
// jsreport placeholders:
"<span class='pageNumber'></span>" // or {#pageNum}
"<span class='totalPages'></span>" // or {#numPages}
// IronPDF placeholders:
"{page}"
"{total-pages}"
"{date}"
"{html-title}"' jsreport placeholders:
"<span class='pageNumber'></span>" ' or {#pageNum}
"<span class='totalPages'></span>" ' or {#numPages}
' IronPDF placeholders:
"{page}"
"{total-pages}"
"{date}"
"{html-title}"jsreport often uses Handlebars templating with Engine.Handlebars:
// jsreport Handlebars (DELETE THIS):
Template = new Template
{
Content = "<h1>Hello, {{name}}</h1>",
Engine = Engine.Handlebars
},
Data = new { name = "World" }
// IronPDF with C# string interpolation:
string name = "World";
string html = $"<h1>Hello, {name}</h1>";
var pdf = renderer.RenderHtmlAsPdf(html);Imports jsreport
Imports IronPdf
' jsreport Handlebars (DELETE THIS):
Dim Template As New Template With {
.Content = "<h1>Hello, {{name}}</h1>",
.Engine = Engine.Handlebars
}
Dim Data = New With {.name = "World"}
' IronPDF with VB.NET string interpolation:
Dim name As String = "World"
Dim html As String = $"<h1>Hello, {name}</h1>"
Dim pdf = renderer.RenderHtmlAsPdf(html)jsreport returns a stream that requires manual copying:
// jsreport stream handling (DELETE THIS):
using (var fileStream = File.Create("output.pdf"))
{
report.Content.CopyTo(fileStream);
}
// Or for byte array:
using (var memoryStream = new MemoryStream())
{
await report.Content.CopyToAsync(memoryStream);
return memoryStream.ToArray();
}
// IronPDF direct access:
pdf.SaveAs("output.pdf");
// Or:
byte[] bytes = pdf.BinaryData;Imports System.IO
' jsreport stream handling (DELETE THIS):
Using fileStream As FileStream = File.Create("output.pdf")
report.Content.CopyTo(fileStream)
End Using
' Or for byte array:
Using memoryStream As New MemoryStream()
Await report.Content.CopyToAsync(memoryStream)
Return memoryStream.ToArray()
End Using
' IronPDF direct access:
pdf.SaveAs("output.pdf")
' Or:
Dim bytes As Byte() = pdf.BinaryDataProblem: Code references LocalReporting class which doesn't exist in IronPDF.
Solution: Replace with ChromePdfRenderer:
// jsreport
var rs = new LocalReporting().UseBinary().AsUtility().Create();
// IronPDF
var renderer = new ChromePdfRenderer();' jsreport
Dim rs = New LocalReporting().UseBinary().AsUtility().Create()
' IronPDF
Dim renderer = New ChromePdfRenderer()Problem: Code uses RenderRequest and Template wrapper objects.
Solution: Pass HTML directly to render methods:
// jsreport
await rs.RenderAsync(new RenderRequest { Template = new Template { Content = html } });
// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);Imports System.Threading.Tasks
' jsreport
Await rs.RenderAsync(New RenderRequest With {.Template = New Template With {.Content = html}})
' IronPDF
Dim pdf = renderer.RenderHtmlAsPdf(html)Problem: Using jsreport placeholder syntax <span class='pageNumber'></span>.
Solution: Update to IronPDF placeholder syntax:
// jsreport syntax (won't work)
"Page <span class='pageNumber'></span> of <span class='totalPages'></span>"
// IronPDF syntax
"Page {page} of {total-pages}"netProblem: Code references JsReportBinary.GetBinary().
Solution: Delete entirely - IronPDF doesn't require external binaries:
// DELETE this jsreport pattern:
.UseBinary(JsReportBinary.GetBinary())
// IronPDF needs nothing—just create the renderer:
var renderer = new ChromePdfRenderer();netusing statementsjsreport.Binary packagejsreport.Binary.Linux packagejsreport.Binary.OSX packagejsreport.Local packagejsreport.Types packagejsreport.Client packageIronPdf packageLocalReporting with ChromePdfRendererRenderRequest wrapperTemplate wrapper<span class='pageNumber'> → {page})StartAsync() / KillAsync() callsBinaryData or SaveAs()
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.
IronPDF is a part of IRONSUITE
10 .NET API products for your office documents
When you need your PDF to look like HTML, fast.
