Bhowra.Ink 1.0.7

Bhowra.Ink — HTML to PDF for .NET, C# & Azure Functions

Serverless HTML-to-PDF for .NET — without a browser. Bhowra.Ink is a zero-dependency, pure-C# engine that converts modern HTML5 + CSS (Grid, flexbox, var()/calc(), gradients, border-radius, box-shadow, transforms, SVG) straight to PDF, in-process — with no Chromium, no headless browser, and no native binaries.

A fully managed alternative to headless-browser (Chromium-based) converters and AGPL-licensed PDF libraries. No AGPL. No cold start. Zero third-party dependencies.

Use it for HTML-to-PDF in C#, ASP.NET Core, Blazor, Azure Functions, and AWS Lambda — invoices, hybrid e-invoices (Factur-X / ZUGFeRD, ZATCA), payslips, statements, reports, and contracts — where launching a headless browser per request is too slow, too heavy, or simply not allowed.

Install

dotnet add package Bhowra.Ink

Targets .NET 8. One managed DLL (under 1 MB — 880 KB, fonts embedded). Works on Windows and Linux, including Azure Functions / AWS Lambda / containers.

Quickstart

using Bhowra.Ink;

string html = "<h1 style='color:teal'>Hello, PDF</h1><p>Rendered in pure .NET.</p>";

// Simplest: straight to a file
HtmlConverter.ConvertToFile(html, "out.pdf");

// Or get bytes + a result you can inspect
ConversionResult result = HtmlConverter.Convert(html, new ConverterProperties { Title = "Demo" });
Console.WriteLine($"{result.PageCount} page(s), {result.SizeBytes} bytes, {result.ConversionTimeMs} ms");
result.SaveToFile("out.pdf");

Output options: ConvertToFile, ConvertToBytes, ConvertToStream, ConvertFileToFile, and Convert (returns a ConversionResult with bytes, page count, timing, and diagnostics).

Convert HTML to PDF in Azure Functions (serverless)

Because Bhowra.Ink runs in-process with no Chromium and no native binaries, it works on Azure Functions, AWS Lambda, and Linux containers with no cold-start browser launch and nothing to install on the host — just add the package and call HtmlConverter:

[Function("InvoicePdf")]
public async Task<HttpResponseData> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
{
    string html = await new StreamReader(req.Body).ReadToEndAsync();
    byte[] pdf   = HtmlConverter.ConvertToBytes(html);

    var res = req.CreateResponse(System.Net.HttpStatusCode.OK);
    res.Headers.Add("Content-Type", "application/pdf");
    await res.Body.WriteAsync(pdf);
    return res;
}

The same code runs unchanged on Windows Consumption plans, Linux, AWS Lambda, and Docker — there are no per-platform native builds to manage.

Why Bhowra.Ink? (vs headless-browser converters & AGPL/commercial PDF libraries)

What it renders

CSS & layout

• Full CSS cascade — specificity, inheritance, shorthand expansion, !important, inline styles
• External stylesheets — <link rel="stylesheet"> and @import resolved into the cascade in document order (secure-by-default; see External stylesheets)
• Selectors: type, class, id, attribute, descendant/child/adjacent/sibling, :nth-child, :not, ::before/::after (incl. counters)
• Flexbox and CSS Grid (incl. repeat(), minmax(), auto-fit/auto-fill)
• var(), calc(), position (relative/absolute/fixed + z-index), float, multi-column
• Gradients (linear / radial / conic), border-radius, box-shadow, filter: blur, transforms (rotate/scale/translate), opacity & alpha compositing
• Tables (colspan, rowspan, border-collapse, repeating headers), lists, nested markers

Documents & paging

• Automatic pagination, page-break-*, @page size/margins
• Running headers/footers (HeaderHtml/FooterHtml with {{page}} / {{pages}})
• Bookmarks/outlines from headings, internal links, link annotations
• Interactive AcroForm fields and embedded file attachments

Graphics & fonts

• SVG: paths, shapes, gradients, clipPath, <use>/<symbol>, transforms
• Images: PNG (incl. alpha/soft-mask + 16-bit), JPEG (incl. CMYK + Exif orientation), GIF, BMP, WebP (lossless), data: URIs
• Base-14 fonts (no files needed) + TrueType/OpenType embedding (Identity-H), WOFF/WOFF2, subsetting, @font-face
• Right-to-left & complex scripts — Arabic (OpenType cursive joining + GPOS harakat) and Hebrew with bidirectional (mixed LTR/RTL) text, plus Devanagari and Thai — bundled Noto fonts, no setup

Output targets

• Encryption: passwords with RC4-128 or AES-256
• PDF/A-2b and PDF/A-3b (archival — all fonts embedded automatically), PDF/UA-1 + Tagged PDF (accessibility), XMP metadata
• Hybrid e-invoices — PDF/A-3 with embedded associated files (/AFRelationship), EU Factur-X / ZUGFeRD, and a built-in QR-code generator (see E-invoicing)
• Configurable diagonal watermark

E-invoicing — Factur-X / ZUGFeRD, ZATCA hybrid, and QR

Produce the hybrid invoice PDF that modern e-invoicing flows expect: a human-readable PDF/A-3 with the structured XML embedded inside it, plus a scannable QR — all in pure .NET, no extra packages.

PDF/A-3 with an embedded associated file

using Bhowra.Ink;

byte[] xml = File.ReadAllBytes("invoice.xml");

var props = new ConverterProperties { PdfA = PdfAConformance.PdfA3B }
    .AttachFile("invoice.xml", xml, "application/xml", afRelationship: "Alternative");

byte[] pdf = HtmlConverter.ConvertToBytes(invoiceHtml, props);

EU Factur-X / ZUGFeRD — SetFacturX embeds the Cross-Industry Invoice XML under the mandated filename (factur-x.xml, or xrechnung.xml for XRECHNUNG), writes the fx: XMP schema with its required PDF/A extension declaration, and applies a profile-correct /AFRelationship:

byte[] cii = File.ReadAllBytes("factur-x.xml");

var props = new ConverterProperties { PdfA = PdfAConformance.PdfA3B }
    .SetFacturX(cii, FacturXProfile.En16931);

byte[] pdf = HtmlConverter.ConvertToBytes(invoiceHtml, props);

Profiles: Minimum, BasicWL, Basic, En16931, Extended, XRechnung.

This fits enterprise EDI, ERP, and SAP S/4HANA flows that need a PDF/A-3 hybrid invoice carrier: Bhowra.Ink builds the document layer (rendered invoice PDF + embedded CII XML + Factur-X/XRechnung metadata). It is not an EDI network, validation service, or SAP connector; generate and validate the business XML in your platform, then pass it to SetFacturX.

Built-in QR — a zero-dependency ISO/IEC 18004 generator (byte mode, versions 1–40, error-correction L/M/Q/H), drawn as a crisp vector with the mandatory quiet zone — sized for payloads up to the ~700-character range (e.g. a Saudi TLV string).

For Saudi invoice QR data, ZatcaTlv builds the TLV payload: typed helpers for tags 1-5, and raw caller-supplied bytes for Phase 2 tags 6-9 (invoice hash, signature, public key, stamp signature). It does not generate, sign, stamp, validate, or submit the invoice XML.

using Bhowra.Ink;
using Bhowra.Ink.QrCode;

byte[] tlvBytes = ZatcaTlv.BuildPhase1Bytes(
    seller: "Najd Trading Company",
    vatNo: "311111111100003",
    ts: DateTimeOffset.Parse("2026-06-28T10:15:00Z"),
    total: "2472.50",
    vat: "322.50");

var props = new ConverterProperties
{
    QrCode =
    {
        Data             = tlvBytes,       // any bytes; null/empty = no QR (output unchanged)
        X                = 60f,            // points from the page's left edge
        Y                = 70f,            // points from the page's bottom edge
        Size             = 120f,           // points (includes the quiet zone)
        Page             = 1,              // 1-based; 0 = every page
        EcLevel          = QrEcLevel.M,    // L / M / Q / H
        QuietZoneModules = 4,              // ISO minimum
    },
};

Configuration

ConverterProperties is the single config object (every member is documented for IntelliSense):

var props = new ConverterProperties
{
    Title  = "Invoice 2026-001",
    Author = "Acme Corp",

    WatermarkText    = "CONFIDENTIAL",   // diagonal; always honoured, licensed or not
    WatermarkOpacity = 0.15f,
    WatermarkColor   = "#BFBFBF",

    UserPassword = "secret",             // encrypts the PDF
    Aes256       = true,                 // AES-256 instead of the default RC4-128

    PdfA   = PdfAConformance.PdfA2B,     // archival conformance (fonts auto-embedded)
    Tagged = true,                       // accessible structure (PDF/UA)

    MissingGlyphBehavior = MissingGlyphBehavior.Diagnostic, // never silently drop glyphs
}
.SetPageA4()        // or SetPageLetter() / SetPageLegal() / SetLandscape()
.SetMargins(36f);   // points (1 pt = 1/72")

byte[] pdf = HtmlConverter.ConvertToBytes(html, props);

Page size/margins can also be set explicitly via PageWidth/PageHeight and MarginTop/Right/Bottom/Left (all in points). Defaults: A4 portrait, 36 pt margins.

External stylesheets (<link rel="stylesheet"> and @import)

The engine resolves external CSS — <link rel="stylesheet"> and the @imports those sheets (and inline <style> blocks) contain — and cascades it with embedded styles in correct document order. It is secure-by-default: local stylesheets under BaseUri resolve out of the box; remote (http/https) fetching is opt-in.

// Local stylesheets (the common case) — resolved relative to BaseUri, no extra setup:
var props = new ConverterProperties { BaseUri = templateDir };   // <link href="css/site.css"> just works

// Opt in to remote stylesheets (CDN), keeping every guard on:
props.ExternalCss.EnableRemote();          // or .Mode = ExternalCssMode.LocalAndRemote

props.ExternalCss (an ExternalCssOptions) carries the policy and limits:

Behaviour matches how a strict print renderer treats CSS: the print media is the target, so media="screen" links are ignored and media="print"/all apply; @import cycles are detected (ancestor-chain) and depth-bounded; charset follows BOM → HTTP charset → @charset → UTF-8. Skipped or blocked stylesheets are reported in ConversionResult.ImageDiagnostics.

Images: remote & local sources (secure-by-default)

Out of the box an <img> is embedded only from a data: URI. Both remote and local file sources are opt-in, so converting HTML you don't fully trust makes no outbound network calls and reads no local files — no SSRF and no local-file disclosure by default.

// Trusted template with local logo assets + CDN images:
var props = new ConverterProperties { AllowLocalFiles = true, AllowRemoteImages = true };

Skipped or blocked images are reported in ConversionResult.ImageDiagnostics.

Image → PDF

Turn one or more images into a PDF — one image per page — with ImageToPdf. It routes through the same renderer, so it inherits the full image stack: JPEG embedded losslessly (DCTDecode passthrough), PNG/WebP/BMP/GIF decoding, RGB/Gray/CMYK color spaces, EXIF auto-orientation, alpha (/SMask), and image de-duplication.

// One image, fit to A4 (default), preserving aspect ratio:
byte[] pdf = ImageToPdf.ToBytes("scan.jpg");

// Several images → multi-page, page sized to each image (no margins):
ImageToPdf.ToFile(
    new[] { ImageInput.FromFile("p1.png"), ImageInput.FromBytes(jpegBytes) },
    "album.pdf",
    new ImageToPdfOptions { PageSize = ImagePageSize.FitToImage });

// A4 with margins, centered, cropped to fill, at print resolution:
var opts = new ImageToPdfOptions
{
    PageSize  = ImagePageSize.A4,     // or Letter / Legal / Custom / FitToImage
    Fit       = ImageFit.Cover,       // Contain (default) / Cover / Stretch / None
    MarginPt  = 36,
    Dpi       = 300,                  // px→pt for FitToImage (300 = print scans)
    Background = "#ffffff",
};
byte[] album = ImageToPdf.ToBytes(new[] { ImageInput.FromFile("photo.jpg") }, opts);

Inputs are files, byte[], or Stream (ImageInput.FromFile/FromBytes/FromStream). ImagePageSize.FitToImage sizes the page to the image; with multiple differently-sized images the page is sized to the largest and the rest are centered (one PDF uses a single page size).

Fonts & non-Latin text

props.RegisterFont("Inter", File.ReadAllBytes("Inter.ttf"));   // embed a custom family

Bundled Noto fonts (Arabic, Hebrew, Thai, Devanagari) ship inside the DLL, so common non-Latin scripts render with no extra setup. Anything a registered or bundled font can't draw is reported — never silently dropped:

var result = HtmlConverter.Convert(html, props);
foreach (var d in result.FontDiagnostics)
    Console.WriteLine(d);   // e.g. characters with no available glyph + how to fix

Licensing & trial

Bhowra.Ink is commercial software that runs fully without a key — it never expires, never imposes a page limit, and never throws based on license state. Unlicensed output simply carries a horizontal "TRIAL VERSION" mark (plus a clickable licensing banner). Activating a valid license removes that trial mark; any caller-configured watermark is independent and unaffected. A free, time-limited evaluation key for clean output is available on request.

See LICENSE.txt for the full agreement. Licensing & sales: sales@bhowra.com.

Architecture (in brief)

HtmlConverter → HtmlParser (DOM) + CssParser/CssCascade (computed styles) → LayoutTreeBuilder (typed layout tree) → PdfWriter (paginate, render, emit PDF bytes). Everything — the HTML parser, CSS engine, font/image decoders, and the PDF writer — is implemented from scratch on the .NET 8 base class library, with no third-party packages.

Known limitations

License

Commercial license — see LICENSE.txt. Bundled Noto fonts are licensed under the SIL Open Font License 1.1 (see OFL.txt) and remain governed by the OFL.

Links

• Product & docs: https://bhowra.com/bhowra-ink.html
• Licensing & sales: sales@bhowra.com