API reference

public static HtmlPdfResult Render(string html, HtmlPdfOptions? options = null)

The PDF of html. Relative addresses resolve against HtmlPdfOptions.BaseUrl: a folder's (file:) files are read from that folder only, a web address's through the network the options allow; without one, nothing is fetched.

Parameters

• html: The document's HTML.
• options: How to print it; null: HtmlPdfOptions.Default.

Throws

• System.ArgumentNullException: html is null.
• System.ArgumentOutOfRangeException: The options' HtmlPdfOptions.Scale is outside 0.1 to 2, or HtmlPdfOptions.ScrollStepWait outside 0 to 60 seconds.
• System.ArgumentException: The options contradict themselves: HtmlPdfOptions.PdfA with passwords, an empty HtmlPdfOptions.Format without HtmlPdfOptions.Width and HtmlPdfOptions.Height, an empty HtmlPdfOptions.ScrollTo, a HtmlPdfOptions.Region whose From is empty or whose Height is no length, a network header the fetcher writes itself (Host, Cookie...) or holding a line break, a cookie or credentials that cannot be sent (HtmlNetwork.Headers, HtmlNetwork.Cookies, HtmlNetwork.Credentials).
• HtmlRenderException: No PDF could be made at all (a stage of the engine failed); a page's own errors are notes, never exceptions.

Puppeteer

page.setContent(html) then page.pdf()

Rendered

Your first PDF: HTML text, Into a stream

public static HtmlPdfResult RenderFile(string path, HtmlPdfOptions? options = null)

The PDF of the HTML file at path: its CSS, pictures, fonts and scripts read from its folder (never outside it), web addresses through the network the options allow.

Throws

• System.ArgumentNullException: path is null.
• System.IO.IOException: The file cannot be read (System.IO.FileNotFoundException when it is not there).
• System.ArgumentOutOfRangeException: The options' HtmlPdfOptions.Scale is outside 0.1 to 2, or HtmlPdfOptions.ScrollStepWait outside 0 to 60 seconds.
• System.ArgumentException: The options contradict themselves: HtmlPdfOptions.PdfA with passwords, an empty HtmlPdfOptions.Format without HtmlPdfOptions.Width and HtmlPdfOptions.Height, an empty HtmlPdfOptions.ScrollTo, a HtmlPdfOptions.Region whose From is empty or whose Height is no length, a network header the fetcher writes itself (Host, Cookie...) or holding a line break, a cookie or credentials that cannot be sent (HtmlNetwork.Headers, HtmlNetwork.Cookies, HtmlNetwork.Credentials).
• HtmlRenderException: No PDF could be made at all (a stage of the engine failed); a page's own errors are notes, never exceptions.

Puppeteer

page.goto('file://...') then page.pdf()

Rendered

A file and its folder

public static HtmlPdfResult RenderUrl(Uri url, HtmlPdfOptions? options = null)

The PDF of the page at url, fetched with its resources. The network is the options' (HtmlPdfOptions.Network); when they leave it off, the page's own host is allowed. A page the server answers with an error status (401, 403, 404...) and a page of its own is printed, as Chrome prints it: HtmlPdfResult.HttpStatus and a note with the code documentHttpError tell it apart.

Throws

• System.ArgumentNullException: url is null.
• System.ArgumentException: url is not an absolute http or https address (a file goes to HtmlToPdf.RenderFile), or the options contradict themselves (as for HtmlToPdf.Render).
• System.ArgumentOutOfRangeException: The options' Scale or ScrollStepWait is out of its range.
• HtmlRenderException: The page could not be loaded (no answer, refused, or an error status with no page), or no PDF could be made at all.

Puppeteer

page.goto(url) then page.pdf()

Rendered

A web address

public static HtmlPdfResult Render(string html, Stream output, HtmlPdfOptions? options = null)

The PDF of html written to output (the result's HtmlPdfResult.Pdf is then null).

Throws

• System.ArgumentNullException: html or output is null.
• System.ArgumentOutOfRangeException: The options' HtmlPdfOptions.Scale is outside 0.1 to 2, or HtmlPdfOptions.ScrollStepWait outside 0 to 60 seconds.
• System.ArgumentException: The options contradict themselves: HtmlPdfOptions.PdfA with passwords, an empty HtmlPdfOptions.Format without HtmlPdfOptions.Width and HtmlPdfOptions.Height, an empty HtmlPdfOptions.ScrollTo, a HtmlPdfOptions.Region whose From is empty or whose Height is no length, a network header the fetcher writes itself (Host, Cookie...) or holding a line break, a cookie or credentials that cannot be sent (HtmlNetwork.Headers, HtmlNetwork.Cookies, HtmlNetwork.Credentials).
• HtmlRenderException: No PDF could be made at all (a stage of the engine failed); a page's own errors are notes, never exceptions.

Puppeteer

page.setContent(html) then page.pdf()

Rendered

Your first PDF: HTML text, Into a stream

public static Task<HtmlPdfResult> RenderAsync(string html, HtmlPdfOptions? options = null, CancellationToken cancellationToken = default)

HtmlToPdf.Render on the thread pool. A cancellation stops a render that has not started; one under way runs to its end or to its limits (HtmlScripts.Timeout). The task faults with the exceptions HtmlToPdf.Render throws.

public static Task<HtmlPdfResult> RenderFileAsync(string path, HtmlPdfOptions? options = null, CancellationToken cancellationToken = default)

HtmlToPdf.RenderFile on the thread pool (cancellation as HtmlToPdf.RenderAsync).

public static Task<HtmlPdfResult> RenderUrlAsync(Uri url, HtmlPdfOptions? options = null, CancellationToken cancellationToken = default)

HtmlToPdf.RenderUrl on the thread pool (cancellation as HtmlToPdf.RenderAsync).

public static HtmlPdfOptions Default { get; }

The defaults.

public string Format { get; init; }

The paper: Letter, Legal, Tabloid, Ledger, A0 to A6 (A4 by default).

Default

"A4"

Throws

• System.ArgumentException: At render: empty while HtmlPdfOptions.Width or HtmlPdfOptions.Height is null.

Puppeteer

page.pdf({ format })

Rendered

Paper size and orientation

public string? Width { get; init; }

The paper's width as a CSS length ("210mm", "8.5in"); with HtmlPdfOptions.Height, wins over HtmlPdfOptions.Format.

Default

null

Puppeteer

page.pdf({ width })

Rendered

Paper size and orientation

public string? Height { get; init; }

The paper's height as a CSS length.

Default

null

Puppeteer

page.pdf({ height })

Rendered

Paper size and orientation

public bool Landscape { get; init; }

The paper turned on its side (its width and height swapped). False by default; the page's @page size wins when HtmlPdfOptions.PreferCssPageSize and it gives an orientation.

Default

false

Puppeteer

page.pdf({ landscape })

Rendered

Paper size and orientation

public HtmlMargins? Margin { get; init; }

The page's margins; null: the page's @page margins, else Chrome's.

Default

null

Puppeteer

page.pdf({ margin })

Rendered

Margins

public bool PreferCssPageSize { get; init; }

The page's @page size wins over HtmlPdfOptions.Format (Chrome's preferCSSPageSize).

Default

true

Puppeteer

page.pdf({ preferCSSPageSize })

Rendered

The page's own @page size

public bool PrintBackground { get; init; }

Background colours and pictures printed.

Default

true

Puppeteer

page.pdf({ printBackground })

Rendered

Backgrounds

public double Scale { get; init; }

The page's content scaled when printed (Chrome's scale): 0.1 to 2, 1 by default; the paper keeps its size.

Default

1

Throws

• System.ArgumentOutOfRangeException: At render: outside 0.1 to 2.

Puppeteer

page.pdf({ scale })

Rendered

Scale

public string? PageRanges { get; init; }

The pages printed: "1-5, 8, 11-13"; null: every page.

Default

null

Puppeteer

page.pdf({ pageRanges })

Rendered

Choosing pages

public bool DisplayHeaderFooter { get; init; }

Chrome's header and footer templates printed in the margins.

Default

false

Puppeteer

page.pdf({ displayHeaderFooter })

Rendered

Header and footer templates

public string? HeaderTemplate { get; init; }

The header printed in each page's top margin when HtmlPdfOptions.DisplayHeaderFooter: HTML whose elements of the classes pageNumber, totalPages, title, url and date get those values. It is a document of its own, as in Chrome: its styles are the template's (a template without a font-size prints at 1px, as in Chrome), no scripts run, nothing is fetched, backgrounds need print-color-adjust: exact. Null or empty: Chrome's default header (the date and the title).

Default

null

Puppeteer

page.pdf({ headerTemplate })

Rendered

Header and footer templates

public string? FooterTemplate { get; init; }

The footer printed in each page's bottom margin when HtmlPdfOptions.DisplayHeaderFooter, as HtmlPdfOptions.HeaderTemplate. Null or empty: Chrome's default footer (the address and "page/pages").

Default

null

Puppeteer

page.pdf({ footerTemplate })

Rendered

Header and footer templates

public Uri? BaseUrl { get; init; }

What relative addresses resolve against for HtmlToPdf.Render.

Default

null

Rendered

The network

public HtmlScripts Scripts { get; init; }

The page's scripts and its frames': on, as in Chrome.

Default

HtmlScripts.Default

Rendered

Scripts and the virtual clock

public HtmlNetwork Network { get; init; }

The network: off by default (nothing is fetched but a file's own folder).

Default

HtmlNetwork.Off

Rendered

A web address, The network

public string? ScrollTo { get; init; }

Scroll the window before printing, as a user would before pressing Print (with Puppeteer, a window.scrollTo in page.evaluate before page.pdf): "top", "bottom", a CSS selector (its first match scrolled into view, its top at the window's top) or a length from the document's top in px ("1200px", "1200"). Null (the default): not scrolled. It happens once the page's scripts have settled, in screen media, before beforeprint: the page's scroll events, scroll positions and IntersectionObserver callbacks see it, and what scripts change is printed. Animations on the root scroll timeline print at their start, scrolled or not, as Chrome prints them. The PDF still holds the whole document from its top, as Chrome's print of a scrolled page does; HtmlPdfOptions.Region prints a part of it. Without scripts, nothing changes.

Default

null

Throws

• System.ArgumentException: At render: empty or white space (null not to scroll).

Puppeteer

page.evaluate(() => window.scrollTo(...)) before page.pdf()

Rendered

Scrolling to a section first

public bool ScrollThrough { get; init; }

Scroll the window from the top to the document's end, one window height at a time, before printing: what a page loads as one scrolls (infinite lists, images and charts made when they come into view) is loaded and printed. Each step waits HtmlPdfOptions.ScrollStepWait of the page's virtual time; at most 200 steps. The window then goes to HtmlPdfOptions.ScrollTo, else back to the top.

IntersectionObserver without a scroll option (neither this nor HtmlPdfOptions.ScrollTo): every observed element is reported visible once, wherever it is, so content a page loads as it comes into view (lazy images, charts, list items made by scripts) is loaded and printed, the whole page in the PDF, which is what a PDF is for. Chrome reports only what is in the window, so with Puppeteer such a page prints its first screen unless it is scrolled first. With a scroll option, Weblitz reports real intersections with the window, as Chrome does.

Default

false

Rendered

Lists that load as you scroll

public TimeSpan ScrollStepWait { get; init; }

The virtual time each scroll (HtmlPdfOptions.ScrollTo, each step of HtmlPdfOptions.ScrollThrough) gives the page to react: its timers, animation frames, observers and image loads. 0 to 60 seconds; 0.5 s by default.

Default

00:00:00.5000000

Throws

• System.ArgumentOutOfRangeException: At render: outside 0 to 60 seconds.

Rendered

Lists that load as you scroll

public HtmlPrintRegion? Region { get; init; }

Print only a part of the document (null, the default: all of it): from a start (the window's scroll position, a length or an element) to an optional height; what lies above and below is left out. The part is laid out on pages as a whole document is: @page sizes and margins, page breaks, headers and footers.

Default

null

Rendered

Printing a part of the page

public string? UserAgent { get; init; }

The browser the page sees and the network is told of (Puppeteer's page.setUserAgent(userAgent, userAgentMetadata)): navigator.userAgent, appVersion and the User-Agent header. Null: desktop Chrome 156's on the machine's OS (macOS, Windows or Linux).

Default

null

Puppeteer

page.setUserAgent(userAgent)

Rendered

The browser the page sees

public HtmlUserAgentMetadata? UserAgentMetadata { get; init; }

What navigator.userAgentData says and the Sec-CH-UA headers send. Null: the machine's Chrome's when HtmlPdfOptions.UserAgent is null, else none (as Chrome, given a User-Agent without metadata).

Default

null

Puppeteer

page.setUserAgent(userAgent, userAgentMetadata)

Rendered

The browser the page sees

public string? Title { get; init; }

The PDF's title (the page's <title> when null) and author.

Default

null

Rendered

Title, author and PDF/A

public string? Author { get; init; }

The PDF's author (the page's <meta name="author"> when null).

Default

null

Rendered

Title, author and PDF/A

public bool PdfA { get; init; }

A PDF/A-2b document (archival: fonts embedded, an output intent, XMP metadata). False by default.

Default

false

Throws

• System.ArgumentException: At render: with passwords in HtmlPdfOptions.Security (PDF/A forbids encryption).

Puppeteer

page.pdf({ tagged }) has no PDF/A

Rendered

Title, author and PDF/A

public HtmlPdfSecurity? Security { get; init; }

Passwords and permissions (AES-256); not with HtmlPdfOptions.PdfA.

Default

null

Rendered

Passwords and permissions

public HtmlPdfCompression Compression { get; init; }

How hard the PDF's streams are deflated: HtmlPdfCompression.Fastest by default, smaller files at the cost of time with HtmlPdfCompression.Default or HtmlPdfCompression.Smallest.

Default

HtmlPdfCompression.Fastest

Values

None Fastest Default Smallest

Rendered

PDF compression

public string Locale { get; init; }

What the page's scripts and Intl see: its language, time zone and clock (fixed: the same PDF every time).

Default

"en-US"

Rendered

Locale, time zone and clock

public string TimeZone { get; init; }

The time zone the page's scripts see (an IANA name: "Europe/Paris", "America/New_York"; "UTC" by default): Date's local time and offset and Intl's formatting, as Chrome with an emulated time zone.

Default

"UTC"

Puppeteer

page.emulateTimezone(timezoneId)

Rendered

Locale, time zone and clock

public DateTimeOffset? Now { get; init; }

The clock the page's scripts start at (Date.now(), new Date()), and the PDF's creation date; then virtual time runs from it. Null: a fixed date (2026-01-01 00:00 UTC), so the same input makes the same PDF.

Default

null

Rendered

Locale, time zone and clock

public bool UseInstalledFonts { get; init; }

The machine's fonts after the page's own @font-face fonts; false: the bundled faces only.

Default

true

Rendered

Installed fonts

public HtmlPdfLimits Limits { get; init; }

What a page may ask for: input size, pages, resources.

Default

HtmlPdfLimits.Default

Rendered

Limits

public bool ExperimentalWebFeatures { get; init; }

Chrome's experimental web platform features that Weblitz has built, on, as Chrome 156 lays them out with its "Experimental Web Platform features" flag (default false: Weblitz prints as stable Chrome does, which ignores them). Among them: grid lanes (display: grid-lanes and inline-grid-lanes, the masonry layout, with grid-lanes-direction, grid-lanes-pack and flow-tolerance), their gap decorations and page and column breaks, text-decoration-inset, text-decoration-skip-spaces, text-transform's full-width and full-size-kana beside a case keyword, the flow-start and flow-end alignment keywords, image symbols in @counter-style. Scripts see them too (CSS.supports, the parsed styles).

Default

false

Rendered

Chrome's experimental features

public HtmlMargins(string? Top = null, string? Right = null, string? Bottom = null, string? Left = null)

Page margins as CSS lengths ("18mm", "0.5in", "40px"; a bare number is px, as Puppeteer reads it).

Parameters

• Top: The top margin; null: the page's @page margin, else Chrome's (about 1 cm).
• Right: The right margin; null as Top.
• Bottom: The bottom margin; null as Top.
• Left: The left margin; null as Top.

public string? Top { get; init; }

The top margin; null: the page's @page margin, else Chrome's (about 1 cm).

public string? Right { get; init; }

The right margin; null as Top.

public string? Bottom { get; init; }

The bottom margin; null as Top.

public string? Left { get; init; }

The left margin; null as Top.

public static HtmlMargins All(string length)

The same margin on the four sides.

public static HtmlPrintRegion FromScroll { get; }

From the window's scroll position (HtmlPdfOptions.ScrollTo, or where the page's scripts scrolled it) to the end.

public string From { get; init; }

Where the part starts: "scroll" (the default: the window's scroll position when printing starts), "top", a length from the document's top in px ("1200px", "1200"), or a CSS selector (its first match's top). The print's layout is measured, the page's print styles applied: a selector's top is where the element is on paper.

Default

"scroll"

public string? Height { get; init; }

How much of the document is printed from HtmlPrintRegion.From, as a CSS length ("1200px", "20cm", "8in", "600pt"; a bare number is px). Null (the default): to the document's end.

Default

null

Throws

• System.ArgumentException: At render: not a length greater than 0.

public static HtmlPrintRegion Of(string from, string? height = null)

From from (see HtmlPrintRegion.From), height tall (see HtmlPrintRegion.Height; null: to the end).

public static HtmlScripts Default { get; }

Scripts on, with the default timeout (30 s of CPU time) and wait (5 s of virtual time).

public static HtmlScripts Off { get; }

No script runs, a frame's neither: the HTML and CSS as they are written.

public bool Enabled { get; init; }

Whether the page's scripts run (true by default).

Default

true

Puppeteer

page.setJavaScriptEnabled(enabled)

public TimeSpan Timeout { get; init; }

The CPU time the scripts may take before they are stopped (the pages printed as they are then).

Default

TimeSpan.FromSeconds(30)

public TimeSpan WaitFor { get; init; }

The virtual time timers and animations run for before printing.

Default

TimeSpan.FromSeconds(5)

public static HtmlNetwork Off { get; }

Nothing is fetched from the network (the default): a file's own folder is still read.

public static HtmlNetwork Any { get; }

Any public host (never the machine's own or private addresses unless named in HtmlNetwork.AllowedHosts).

public IReadOnlyList<string> AllowedHosts { get; init; }

The hosts the render may fetch from: names ("example.com"), wildcards ("*.example.com"), "*" for any public host. Empty: the network is off.

Default

[]

public TimeSpan ResourceTimeout { get; init; }

The time one resource may take (15 s by default); what has not arrived is left out, noted.

Default

TimeSpan.FromSeconds(15)

public TimeSpan TotalTimeout { get; init; }

The time the whole document's resources may take together (60 s by default).

Default

TimeSpan.FromSeconds(60)

public string? CacheDirectory { get; init; }

A folder where fetched resources are kept between renders (HTTP's caching rules), or none. A render with HtmlNetwork.Headers, HtmlNetwork.Cookies, HtmlNetwork.AcceptCookies or HtmlNetwork.Credentials neither reads nor writes it: what a signed-in render receives is never handed to another render.

Default

null

public IReadOnlyList<HtmlRequestHeader> Headers { get; init; }

Request headers added to the render's fetches (an Authorization: Bearer token, an API key), each sent only to the hosts it names, by default the document's own host: never to a CDN or another site's script unless named. A header is not sent on a redirect to a host it does not name. Host, Content-Length, Cookie (use HtmlNetwork.Cookies) and the other headers the fetcher writes itself are refused.

Default

[]

Puppeteer

page.setExtraHTTPHeaders(headers)

Rendered

Pages behind a login

public IReadOnlyList<HtmlCookie> Cookies { get; init; }

Cookies the render starts with, as a browser signed in would have them (a session cookie): sent by the cookie rules (domain, path, Secure, SameSite, expiry) with the document, its frames, style sheets, pictures, fonts, scripts and the page's own fetch() and XMLHttpRequest calls to its origin; the page's scripts read them in document.cookie unless HttpOnly. Setting any keeps the cookies servers set during the render too (HtmlNetwork.AcceptCookies).

Default

[]

Puppeteer

page.setCookie(...cookies)

Rendered

Pages behind a login

public bool AcceptCookies { get; init; }

Whether the cookies servers set (Set-Cookie, redirects included) and the page's scripts set are kept for the rest of the render and sent back, as a browser does: a login redirect that sets a session cookie then works. Nothing is kept between renders. True whenever HtmlNetwork.Cookies holds any; false by default.

Default

false

Rendered

Pages behind a login

public HtmlCredentials? Credentials { get; init; }

A user name and password answering a host's HTTP authentication challenge (Basic or Digest, after its 401), for the hosts they name, by default the document's own host; never sent unasked, nor to another host.

Default

null

Puppeteer

page.authenticate(credentials)

Rendered

Pages behind a login

public static HtmlNetwork Allow(string[] hosts)

These hosts only ("example.com", "*.example.com").

public HtmlNetwork WithHeader(string name, string value, string[] hosts)

This network with a header added (HtmlNetwork.Headers): for hosts, else the document's own host.

public HtmlNetwork WithBearerToken(string token, string[] hosts)

This network with Authorization: Bearer added: for hosts, else the document's own host.

public HtmlNetwork WithCookie(HtmlCookie cookie)

This network with a cookie added (HtmlNetwork.Cookies).

public HtmlRequestHeader(string Name, string Value)

A request header a render adds to its fetches (HtmlNetwork.Headers).

Parameters

• Name: The header's name ("Authorization", "X-Api-Key").
• Value: Its value ("Bearer eyJ...").

public string Name { get; init; }

The header's name ("Authorization", "X-Api-Key").

public string Value { get; init; }

Its value ("Bearer eyJ...").

public IReadOnlyList<string> Hosts { get; init; }

The hosts it is sent to ("api.example.com", "*.example.com"); empty: the document's own host only (a document read from a file has none: name the hosts).

public HtmlCookie(string Name, string Value)

A cookie a render starts with (HtmlNetwork.Cookies), as a browser keeps it.

Parameters

• Name: Its name.
• Value: Its value.

public string Name { get; init; }

Its name.

public string Value { get; init; }

Its value.

public string? Domain { get; init; }

The domain it goes to with its subdomains ("example.com"); null: the document's own host alone.

public string Path { get; init; }

The path it goes to with the paths under it ("/" by default).

public bool Secure { get; init; }

Sent over https: only (and to the machine's own addresses, as Chrome sends it there).

public bool HttpOnly { get; init; }

Hidden from the page's scripts (document.cookie, cookieStore).

public HtmlCookieSameSite SameSite { get; init; }

How it goes with requests from other sites (Lax by default).

Values

Lax Strict None

public DateTimeOffset? Expires { get; init; }

When it expires; null: it lasts the render.

Lax = 0

With the site's own requests and the top-level document (browsers' default).

Strict = 1

With the site's own requests only.

None = 2

With every request, other sites' too; the cookie must be HtmlCookie.Secure.

public HtmlCredentials(string UserName, string Password)

A user name and password answering HTTP authentication (HtmlNetwork.Credentials).

Parameters

• UserName: The user name.
• Password: The password.

public string UserName { get; init; }

The user name.

public string Password { get; init; }

The password.

public IReadOnlyList<string> Hosts { get; init; }

The hosts that may be answered ("intranet.example.com", "*.example.com"); empty: the document's own host.

public string? UserPassword { get; init; }

The password a reader needs to open the PDF; null: it opens without one.

Default

null

public string? OwnerPassword { get; init; }

The password that lifts the permissions below; null: none set.

Default

null

public bool PermitPrinting { get; init; }

Whether a reader may print without the owner's password (true by default).

Default

true

public bool PermitCopying { get; init; }

Whether a reader may copy text and pictures without the owner's password (true by default).

Default

true

public bool PermitModifying { get; init; }

Whether a reader may change the document without the owner's password (true by default).

Default

true

None = 0

Streams stored without deflating: the largest files, the fastest writing.

Fastest = 1

zlib's fastest level (1): the default, the fastest writing of a deflated PDF.

Default = 6

zlib's default level (6): smaller files, slower writing.

Smallest = 9

zlib's best level (9): the smallest files, the slowest writing.

public static HtmlPdfLimits Default { get; }

The default limits (each below).

public long MaxInputBytes { get; init; }

The largest document read (50 MB by default): past it the rest is not parsed and the result is not HtmlPdfResult.Completed.

Default

52,428,800 (50 MB)

public int MaxPages { get; init; }

The most pages printed (10,000 by default): the document is cut there, not completed.

Default

10,000

public int MaxNodes { get; init; }

The most DOM nodes, the parser's and the scripts' (1,000,000 by default): past it the parse or the scripts stop, not completed.

Default

1,000,000

public long MaxResourceBytes { get; init; }

The largest resource fetched or read (20 MB by default): a larger one is left out, noted.

Default

20,971,520 (20 MB)

public long MaxTotalResourceBytes { get; init; }

The most bytes of resources a document fetches and reads in all (200 MB by default).

Default

209,715,200 (200 MB)

public IReadOnlyList<HtmlUserAgentBrand> Brands { get; init; }

The brands with their major versions.

Default

[]

public IReadOnlyList<HtmlUserAgentBrand> FullVersionList { get; init; }

The brands with their full versions.

Default

[]

public string? FullVersion { get; init; }

uaFullVersion (deprecated in Chrome; Chrome's own when null).

Default

null

public string Platform { get; init; }

"macOS", "Windows", "Linux", "Android"...

Default

""

public string PlatformVersion { get; init; }

The platform's version ("15.0.0", "10.0.0"); empty: none said.

Default

""

public string Architecture { get; init; }

"arm", "x86".

Default

""

public string Model { get; init; }

The device model, for a mobile device ("Pixel 9"); empty on desktops.

Default

""

public bool Mobile { get; init; }

Whether the browser says it is a mobile one (navigator.userAgentData.mobile, Sec-CH-UA-Mobile).

Default

false

public string Bitness { get; init; }

"64", "32".

Default

""

public bool Wow64 { get; init; }

Whether a 32-bit browser runs on 64-bit Windows (Sec-CH-UA-WoW64); false elsewhere.

Default

false

public IReadOnlyList<string>? FormFactors { get; init; }

"Desktop", "Mobile", "Tablet"...; Chrome's ["Desktop"] when null.

Default

null

public static HtmlUserAgentMetadata ChromeOnThisMachine { get; }

Desktop Chrome 156's on the machine's OS, as the engine says by default.

public HtmlUserAgentBrand(string Brand, string Version)

A brand of HtmlUserAgentMetadata: navigator.userAgentData's brands and Sec-CH-UA's.

Parameters

• Brand: The brand's name ("Google Chrome", "Chromium", "Not:A-Brand").
• Version: Its version: the major one in HtmlUserAgentMetadata.Brands ("156"), the full one in HtmlUserAgentMetadata.FullVersionList ("156.0.8078.47").

public string Brand { get; init; }

The brand's name ("Google Chrome", "Chromium", "Not:A-Brand").

public string Version { get; init; }

Its version: the major one in HtmlUserAgentMetadata.Brands ("156"), the full one in HtmlUserAgentMetadata.FullVersionList ("156.0.8078.47").

public byte[]? Pdf { get; }

The document; null when it was written to a stream.

public int PageCount { get; }

The pages printed (after page ranges chose some).

public IReadOnlyList<HtmlPdfNote> Notes { get; }

What was left out or could not be drawn: a font missing, a resource refused, a script that threw, content shrunk to fit. A page's own errors are notes, never exceptions, as a browser goes on.

Rendered

Notes: what could not be done

public bool Completed { get; }

False when a limit or the script timeout stopped the render (the pages printed so far are the PDF).

Rendered

Limits

public TimeSpan Elapsed { get; }

How long the render took, from the call to the PDF written.

public int? HttpStatus { get; }

The HTTP status the server answered for the document, when it was fetched by its URL (HtmlToPdf.RenderUrl): a success (200), or an error (401, 403, 404...) whose page the server sent and which was printed, as Chrome prints it (a note with the code documentHttpError says so). Null for HTML given as text or read from a file.

public HtmlPdfNote(string Code, HtmlPdfNoteSeverity Severity, string Message, string? Element)

One thing the engine noted about the document.

Parameters

• Code: What kind of note: a stable word ("missingGlyph", "resourceFailed", "limitReached", "scriptError", "notImplemented"...) to sort or filter by.
• Severity: How much it matters to the PDF.
• Message: What happened, in plain words.
• Element: Where, when the note is about one element: its path from the root element, CSS-like (the tag, "#id", the first ".class", ":nth-of-type(n)" among siblings of its name, joined by ">": "html>body>div.card:nth-of-type(2)"); null for the document as a whole.

public string Code { get; init; }

What kind of note: a stable word ("missingGlyph", "resourceFailed", "limitReached", "scriptError", "notImplemented"...) to sort or filter by.

public HtmlPdfNoteSeverity Severity { get; init; }

How much it matters to the PDF.

Values

Info Warning Error

public string Message { get; init; }

What happened, in plain words.

public string? Element { get; init; }

Where, when the note is about one element: its path from the root element, CSS-like (the tag, "#id", the first ".class", ":nth-of-type(n)" among siblings of its name, joined by ">": "html>body>div.card:nth-of-type(2)"); null for the document as a whole.

Info = 0

For information: the PDF is as Chrome's would be (a setting ignored as Chrome ignores it, content shrunk to fit).

Warning = 1

Something is missing or differs (a resource not loaded, a glyph a font lacks, a limit reached).

Error = 2

A part could not be made (a script that threw, a stage that failed).

public HtmlRenderException(string message)

The exception with what went wrong.

Parameters

• message: Why no PDF could be made, with the engine's error notes.

public static bool IsActive { get; }

Whether a valid licence is active.

public static string? LicensedTo { get; }

The licensed company, or null when not licensed.

public static DateTime? ExpiryDate { get; }

The licence's expiry date, or null when not licensed.

public static DateTime? UpdatesUntil { get; }

The last release date a licence covers for good, or null (not licensed, or a key that simply expires).

public static string? Tier { get; }

The licence's tier, or null when not licensed.

public static IReadOnlyList<string> Features { get; }

The features the active licence names.

public static void Activate(string licenseKey)

Activates the licence key (an SSRS2-... key). Call it once at application startup.

Throws

• SSRS2.Licensing.LicenseException: The key is invalid or has expired.

public static bool TryActivate(string licenseKey, out string error)

Activates the licence key without throwing: false and the reason when it is refused.

public static bool TryRead(string licenseKey, out LicenseInfo? info, out string error)

Reads a licence key without activating it: whether it is genuine and has not expired, and what it says.

public static bool HasFeature(string feature)

Whether the active licence names feature.