How to Migrate from GrabzIt to IronPDF in C#

The GrabzIt Architecture Problem

GrabzIt is a cloud-based screenshot and PDF capture service. While convenient for quick integrations, it has fundamental architectural limitations:

1. Image-Based PDFs: GrabzIt creates screenshot-based PDFs where text is not selectable—essentially images wrapped in PDF format. This is a fundamental limitation for any use case requiring text manipulation or accessibility.

2. External Processing: All content is sent to GrabzIt's servers for processing—creating privacy and compliance concerns for sensitive data. Your HTML content leaves your infrastructure.

3. Callback Complexity: GrabzIt uses an asynchronous callback model that requires webhook handling infrastructure. You must set up endpoints to receive results, adding architectural complexity.

4. Per-Capture Pricing: The pay-per-use model can become expensive at scale. Every PDF generation incurs a cost.

5. No Text Search: Since PDFs are image-based, text search and extraction don't work without OCR—an additional step and cost.

6. Larger File Sizes: Image-based PDFs are significantly larger than vector-based PDFs, often 5-10x the size.

7. Network Dependency: Cannot generate PDFs without an internet connection, making offline scenarios impossible.

8. Latency: Every PDF generation requires a network round-trip to external servers, adding 500ms-5s latency.

GrabzIt vs IronPDF Comparison

For teams planning .NET 10 and C# 14 adoption through 2025 and 2026, IronPDF provides a future-proof foundation with local processing that integrates natively with modern .NET patterns.

Estimated Effort by Feature

Paradigm Shift

The fundamental shift in this GrabzIt migration is from asynchronous callback-based cloud processing to synchronous in-process generation:

GrabzIt:   Send HTML → Wait for callback → Retrieve result from server
IronPDF:   Render HTML → Get PDF immediately

Prerequisites

1. .NET Version: IronPDF supports .NET Framework 4.6.2+ and .NET Core 3.1+ / .NET 5/6/7/8/9+
2. License Key: Obtain your IronPDF license key from ironpdf.com
3. Plan Infrastructure Removal: Document callback handlers and webhook endpoints for decommissioning

Identify All GrabzIt Usage

# Find GrabzIt client usage
grep -r "GrabzItClient\|GrabzIt\." --include="*.cs" .

# Find callback handlers
grep -r "GrabzIt\|grabzit" --include="*.ashx" --include="*.aspx" --include="*.cs" .

# Find configuration
grep -r "APPLICATION_KEY\|APPLICATION_SECRET\|grabzit" --include="*.config" --include="*.json" .

# Find GrabzIt client usage
grep -r "GrabzItClient\|GrabzIt\." --include="*.cs" .

# Find callback handlers
grep -r "GrabzIt\|grabzit" --include="*.ashx" --include="*.aspx" --include="*.cs" .

# Find configuration
grep -r "APPLICATION_KEY\|APPLICATION_SECRET\|grabzit" --include="*.config" --include="*.json" .

NuGet Package Changes

# Remove GrabzIt
dotnet remove package GrabzIt

# Install IronPDF
dotnet add package IronPdf

# Remove GrabzIt
dotnet remove package GrabzIt

# Install IronPDF
dotnet add package IronPdf

Step 1: Update License Configuration

Before (GrabzIt):

GrabzIt requires application key and secret for every client instantiation:

var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");

var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");

After (IronPDF):

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// Then create renderer without credentials
var renderer = new ChromePdfRenderer();

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// Then create renderer without credentials
var renderer = new ChromePdfRenderer();

Step 2: Update Namespace Imports

// Before (GrabzIt)
using GrabzIt;
using GrabzIt.Parameters;

// After (IronPDF)
using IronPdf;

// Before (GrabzIt)
using GrabzIt;
using GrabzIt.Parameters;

// After (IronPDF)
using IronPdf;

GrabzItClient to IronPDF Mapping

PDFOptions to RenderingOptions Mapping

ImageOptions to IronPDF Mapping

Example 1: HTML to PDF Conversion

Before (GrabzIt):

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.CustomId = "my-pdf";

        grabzIt.HTMLToPDF("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.pdf");
    }
}

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.CustomId = "my-pdf";

        grabzIt.HTMLToPDF("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.pdf");
    }
}

After (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

The difference is substantial: GrabzIt requires API credentials (YOUR_APPLICATION_KEY, YOUR_APPLICATION_SECRET), creates a PDFOptions object with a custom ID, and the result is an image-based PDF sent through external servers. IronPDF's ChromePdfRenderer generates a true vector PDF locally with selectable text—no credentials, no network calls, no callbacks. See the HTML to PDF documentation for additional rendering options.

Example 2: URL to PDF Conversion

Before (GrabzIt):

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.PageSize = PageSize.A4;

        grabzIt.URLToPDF("https://www.example.com", options);
        grabzIt.SaveTo("webpage.pdf");
    }
}

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new PDFOptions();
        options.PageSize = PageSize.A4;

        grabzIt.URLToPDF("https://www.example.com", options);
        grabzIt.SaveTo("webpage.pdf");
    }
}

After (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

GrabzIt requires configuring PageSize.A4 through the options object and authenticating with external servers. IronPDF's RenderUrlAsPdf() method accepts the URL directly and renders it locally using a full Chromium engine with complete CSS and JavaScript support. Learn more about URL to PDF conversion.

Example 3: HTML to Image Conversion

Before (GrabzIt):

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new ImageOptions();
        options.Format = ImageFormat.png;
        options.Width = 800;
        options.Height = 600;

        grabzIt.HTMLToImage("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.png");
    }
}

// NuGet: Install-Package GrabzIt
using GrabzIt;
using GrabzIt.Parameters;
using System;

class Program
{
    static void Main()
    {
        var grabzIt = new GrabzItClient("YOUR_APPLICATION_KEY", "YOUR_APPLICATION_SECRET");
        var options = new ImageOptions();
        options.Format = ImageFormat.png;
        options.Width = 800;
        options.Height = 600;

        grabzIt.HTMLToImage("<html><body><h1>Hello World</h1></body></html>", options);
        grabzIt.SaveTo("output.png");
    }
}

After (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Drawing;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        var images = pdf.ToBitmap();
        images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Drawing;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        var images = pdf.ToBitmap();
        images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);
    }
}

GrabzIt provides a dedicated HTMLToImage() method with ImageOptions for format, width, and height configuration. IronPDF achieves the same result by first rendering HTML to PDF using RenderHtmlAsPdf(), then converting to bitmap with ToBitmap(). This approach gives you both the PDF and image output from a single render operation.

No Callbacks Required

The most significant architectural change is eliminating callback handlers entirely:

// GrabzIt: Async callback pattern
grabzIt.HTMLToPDF(html, options);
grabzIt.Save("https://myserver.com/grabzit-callback");  // Wait for callback...

// Callback handler (separate endpoint)
public class GrabzItHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        string id = context.Request.QueryString["id"];
        GrabzItClient grabzIt = new GrabzItClient("APP_KEY", "APP_SECRET");
        GrabzItFile file = grabzIt.GetResult(id);
        file.Save("output.pdf");
    }
}

// IronPDF: Synchronous - result immediately available
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");  // Done! No callback needed.

// GrabzIt: Async callback pattern
grabzIt.HTMLToPDF(html, options);
grabzIt.Save("https://myserver.com/grabzit-callback");  // Wait for callback...

// Callback handler (separate endpoint)
public class GrabzItHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        string id = context.Request.QueryString["id"];
        GrabzItClient grabzIt = new GrabzItClient("APP_KEY", "APP_SECRET");
        GrabzItFile file = grabzIt.GetResult(id);
        file.Save("output.pdf");
    }
}

// IronPDF: Synchronous - result immediately available
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");  // Done! No callback needed.

Delete all GrabzIt callback handlers (.ashx files, handler endpoints, webhook configuration) after migration.

True Vector PDFs

GrabzIt creates image-based PDFs where text is not selectable. IronPDF generates true vector PDFs:

// With IronPDF, text extraction works natively
var pdf = PdfDocument.FromFile("document.pdf");
string text = pdf.ExtractAllText();  // Works without OCR!

// With IronPDF, text extraction works natively
var pdf = PdfDocument.FromFile("document.pdf");
string text = pdf.ExtractAllText();  // Works without OCR!

See the text extraction documentation for more details.

Smaller File Sizes

Vector-based PDFs are typically 5-10x smaller than GrabzIt's image-based PDFs. This improves storage costs, download times, and email attachment feasibility.

Remove API Credentials

GrabzIt requires API credentials for every operation:

// Remove these from configuration
// YOUR_APPLICATION_KEY
// YOUR_APPLICATION_SECRET

// Remove these from configuration
// YOUR_APPLICATION_KEY
// YOUR_APPLICATION_SECRET

IronPDF uses a single license key set once at application startup—no per-request authentication.

Issue 1: GrabzItClient Not Found

Problem: After removing GrabzIt, GrabzItClient references cause compile errors.

Solution: Replace with ChromePdfRenderer:

// Remove:
// var grabzIt = new GrabzItClient("KEY", "SECRET");

// Replace with:
var renderer = new ChromePdfRenderer();

// Remove:
// var grabzIt = new GrabzItClient("KEY", "SECRET");

// Replace with:
var renderer = new ChromePdfRenderer();

Issue 2: PDFOptions Not Found

Problem: PDFOptions class doesn't exist in IronPDF.

Solution: Use RenderingOptions property:

// GrabzIt
var options = new PDFOptions();
options.PageSize = PageSize.A4;

// IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// GrabzIt
var options = new PDFOptions();
options.PageSize = PageSize.A4;

// IronPDF
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

Issue 3: Callback Handlers Still Referenced

Problem: Application expects callback endpoints.

Solution: Delete callback infrastructure entirely. IronPDF returns results synchronously—no webhooks needed.

Issue 4: ImageOptions Not Found

Problem: ImageOptions class doesn't exist in IronPDF.

Solution: Render to PDF first, then convert:

// GrabzIt
var options = new ImageOptions();
options.Format = ImageFormat.png;
grabzIt.HTMLToImage(html, options);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);
var images = pdf.ToBitmap();
images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);

// GrabzIt
var options = new ImageOptions();
options.Format = ImageFormat.png;
grabzIt.HTMLToImage(html, options);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);
var images = pdf.ToBitmap();
images[0].Save("output.png", System.Drawing.Imaging.ImageFormat.Png);

Pre-Migration

• Inventory all GrabzIt API calls in codebase
• Identify callback handlers and webhook endpoints
• Document current GrabzIt options and templates
• Obtain IronPDF license key
• Plan callback handler decommissioning

Code Migration

• Install IronPdf NuGet package: dotnet add package IronPdf
• Remove GrabzIt NuGet package: dotnet remove package GrabzIt
• Replace GrabzItClient with ChromePdfRenderer
• Convert HTMLToPDF() to RenderHtmlAsPdf()
• Convert URLToPDF() to RenderUrlAsPdf()
• Replace Save(callback) with SaveAs(path)
• Update options from PDFOptions to RenderingOptions

Infrastructure Migration

• Delete callback handler files (.ashx, etc.)
• Remove GrabzIt API keys from configuration
• Remove webhook URL configuration
• Add IronPDF license key to configuration
• Remove polling/status checking code

Testing

• Test HTML to PDF conversion
• Test URL to PDF conversion
• Verify text is selectable in output PDFs
• Test text extraction works (without OCR)
• Verify file sizes are smaller
• Performance test without network latency

Post-Migration

• Cancel GrabzIt subscription
• Archive callback handler code
• Update documentation
• Monitor for any GrabzIt-related errors