ScreenshotNeo
Sign in Get a free key

BlogHow-to

How to Set a Timeout for PDF Conversion in C#

Set a PDF conversion timeout through the API of the library doing the work. Here are scoped C# examples, cancellation patterns, and troubleshooting steps.

By the ScreenshotNeo team29 September 20269 min read

How to Set a Timeout for PDF Conversion in C#

To set a timeout for PDF conversion in C#, use the timeout or cancellation API provided by the library that performs the conversion. There is no universal .NET or PdfDocument conversion-timeout property. For Syncfusion’s documented Blink HTML-to-PDF flow, set BlinkConverterSettings.ConversionTimeout in milliseconds. For a supported GroupDocs.Conversion overload, pass a cancellation token. HttpClient.Timeout only limits HTTP requests; it does not impose a deadline on arbitrary local conversion work.

The right setting depends on what you are converting and how: HTML from a URL, an office document, or an existing PDF; a local library or a remote service; a synchronous or asynchronous method. Start by identifying the operation and its API, then verify the timeout’s unit, scope, and cancellation behavior in the documentation for your installed package version.

1. Identify which operation needs a deadline

“PDF conversion” can refer to several different jobs. A URL-to-PDF renderer may need to navigate to a page, run JavaScript, fetch resources, and then produce a document. An office converter may transform a local file. An HTTP client may send a document to a conversion service and wait for a response. Each stage can have a different limit.

HTTP, page loading, and conversion can each have separate timeout controls.
HTTP, page loading, and conversion can each have separate timeout controls.
Work being limited Typical control What to verify
Conversion engine work Vendor-specific timeout or cancellation token Does it stop conversion, and what is the unit?
URL navigation or page load Renderer-specific navigation or load timeout Does it cover resource fetching, scripts, or both?
HTTP request to a remote service HttpClient.Timeout or request cancellation token Does client cancellation stop server-side processing?
Worker process Library or process management API Does cancellation terminate the worker and clean up partial output?

These limits are not interchangeable. A short page-load timeout might fail before conversion begins; a client request timeout might stop waiting while a remote server continues working. Do not assume the name “timeout” alone defines the behavior.

In Syncfusion’s documented Blink HTML converter flow, create BlinkConverterSettings, set ConversionTimeout, assign the settings to the converter, and call Convert. The value is in milliseconds. The vendor example uses 5,000 milliseconds; treat that as an example value, not a generally suitable production limit.

using Syncfusion.HtmlConverter;
using Syncfusion.Pdf;

var htmlConverter = new HtmlToPdfConverter();
var settings = new BlinkConverterSettings();
settings.ConversionTimeout = 5000; // milliseconds; vendor example value
htmlConverter.ConverterSettings = settings;

PdfDocument document = htmlConverter.Convert("https://www.google.com");
document.Save("Output.pdf");
document.Close(true);

This code is specifically for Syncfusion’s Blink HTML-to-PDF conversion from a URL. Do not carry the property name, unit, or behavior over to another Syncfusion engine, another conversion method, or another vendor without checking that API’s documentation. The timeout shown also does not establish a recommended latency budget.

Choosing a value

No universal duration is established by the available documentation. Choose a limit based on the time your application can afford to wait and the real inputs it must support. Test representative pages or documents, including the slow and resource-heavy cases that matter to your application. If a URL renderer loads external resources, evaluate that workload separately from a local-file conversion.

3. GroupDocs.Conversion with cancellation

GroupDocs.Conversion documents a cancellation-token pattern for conversion calls that support a token. Create a CancellationTokenSource, schedule cancellation with CancelAfter, pass its token to the applicable overload, and handle OperationCanceledException.

using System;
using System.Threading;
using GroupDocs.Conversion;

using var converter = new Converter("input.docx");
using var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(30));

try
{
    // Use a Convert overload that accepts a CancellationToken
    // in your installed GroupDocs.Conversion version.
    converter.Convert("output.pdf", new PdfConvertOptions(), cts.Token);
}
catch (OperationCanceledException)
{
    Console.Error.WriteLine("PDF conversion was cancelled or exceeded its time limit.");
    throw;
}

Check the exact overload and package version before using this pattern: not every method signature necessarily accepts a token. Also confirm what cancellation means for that overload. A cancellation request and a converter’s own hard timeout can have different cleanup behavior. Decide how your application handles a partially written output file and whether it should be removed after cancellation.

4. HTTP request timeouts are a separate setting

If your C# application sends a conversion request to a remote service, HttpClient.Timeout can limit how long the client waits for an HTTP request. Microsoft documents a default of 100,000 milliseconds (100 seconds). A per-request cancellation token can also set a timeout; when both apply, the shorter timeout takes effect. This is an HTTP request limit, not a limit on arbitrary local PDF conversion.

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

using var client = new HttpClient
{
    Timeout = TimeSpan.FromSeconds(45)
};

using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(20));

try
{
    using var response = await client.GetAsync(
        "https://conversion-service.example/document/123",
        cts.Token);
    response.EnsureSuccessStatusCode();
    byte[] pdf = await response.Content.ReadAsByteArrayAsync(cts.Token);
    await File.WriteAllBytesAsync("output.pdf", pdf);
}
catch (OperationCanceledException)
{
    Console.Error.WriteLine("The HTTP request was cancelled or timed out.");
    throw;
}

The example illustrates the client-side distinction; replace the illustrative service address and request with the actual service API. If the client gives up, do not assume the remote server stops converting. That depends on the service’s own cancellation and job-cleanup contract. If the response is a long-running job, you may need to manage the job separately.

5. Account for different timeout categories

Conversion products may expose more than one timeout. PDFreactor, for example, documents a conversionTimeout in seconds that aborts conversion, while separately describing JavaScript-processing and resource-loading timeouts. Its manual says resource timeouts do not cause the overall conversion to abort. That difference illustrates why the setting name and documentation matter.

Before settling on a configuration, record answers to these questions:

  • Does the limit cover conversion, navigation, JavaScript, resource loading, or an HTTP request?
  • Is its unit milliseconds, seconds, or a TimeSpan?
  • Does expiry abort the work, cancel the caller, or only stop waiting?
  • Does the exact synchronous or asynchronous overload support cancellation?
  • What happens to temporary files, partial PDFs, and worker processes?
  • Can independent limits combine, with the shortest one taking effect?

6. Troubleshooting timeouts and failed conversions

Symptom Likely cause What to check or change
Code does not compile for ConversionTimeout The example uses a different converter engine or package API Confirm that you are using Syncfusion’s Blink settings and check the installed version’s API.
Conversion ends much sooner than expected Milliseconds were confused with seconds, or another limit is shorter Check units and all active request, navigation, conversion, and token limits.
Local conversion ignores HttpClient.Timeout That property limits HTTP requests only Use the converter’s own timeout or a supported cancellation mechanism.
OperationCanceledException is thrown A token was cancelled, possibly by its deadline or by application code Check the token’s lifetime and cancellation source; handle cancellation separately from conversion errors.
Caller times out but remote work continues Client cancellation may not cancel server-side processing Check the service’s cancellation contract and whether it exposes a job-cancel endpoint.
PDF is missing or incomplete after cancellation Cancellation may leave partial output or require worker cleanup Check the library’s cleanup semantics; write to a temporary path and publish only after successful completion.
Only pages with external assets fail Resource loading or scripts may have their own limits or dependencies Inspect renderer-specific resource and JavaScript settings separately from the overall conversion timeout.

For process-based converters, do not assume that cancelling a wait also terminates the worker. Confirm the library’s documented cancellation and cleanup behavior, and plan for temporary files and worker disposal. Avoid treating third-party generated API references as definitive when the package vendor’s own documentation is available.

7. Performance, reliability, and cost considerations

A timeout bounds how long the application waits or allows a particular operation to run; it does not make conversion faster. A limit that is too short can reject valid, complex inputs. A limit that is too long can tie up request handlers, workers, or other resources. Set the limit against the application’s latency budget and test with representative workloads rather than adopting a sample value as a benchmark.

For reliability, distinguish timeout from other failure results. Record which stage expired, whether cancellation was requested, whether the converter reported an error, and whether an output file was produced. Avoid presenting a partial file as a successful PDF. If conversion depends on remote resources, record or control those dependencies where possible so a slow resource is not mistaken for slow PDF generation.

Cost depends on the converter and service you use; the sources here establish no comparative pricing or performance figures. With a remote service, check whether billing is based on submitted requests, completed conversions, or another measure, and verify what happens when the client times out. A caller-side timeout alone does not prove that server-side work or charges stop.

8. Or skip the browser setup

If your task is rendering a website as a screenshot or PDF, ScreenshotNeo offers a website screenshot API and MCP server. A single GET request takes a URL and returns a screenshot or PDF. For the C# timeout question, keep the distinction clear: the call below is the supplied screenshot example, and it does not configure a C# converter timeout.

Website capture can remove common overlays before producing the result.
Website capture can remove common overlays before producing the result.

For C# PDF conversion, use the library-specific examples above. For a website capture workflow, you can make the API call from C# with HttpClient like this:

using System;
using System.Net.Http;
using System.Threading.Tasks;

using var client = new HttpClient();
using var response = await client.GetAsync(
    "https://api.screenshotneo.com/v1/shot?access_key=YOUR_API_KEY&url=https%3A%2F%2Fstripe.com");
response.EnsureSuccessStatusCode();
byte[] capture = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("shot.webp", capture);

See the ScreenshotNeo API documentation for its request details. Cookie banners, popups, and chat widgets are removed before capture; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots per month with no card, and paid plans start at $5 for 3,000.

For a website capture without browser setup, try ScreenshotNeo free: 1,000 screenshots a month, no card.

9. cURL, Python, and Node.js for the website capture option

These examples make the same ScreenshotNeo website capture request in common environments. They are relevant when the job is capturing a URL; they do not set the timeout of a separate C# PDF conversion engine. Set client-side request deadlines according to the HTTP library and workflow you use, and consult the API documentation for current request behavior.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode url=https://stripe.com \
  -o shot.webp

Python

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Capture request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

10. Frequently asked questions

Does .NET have a global PDF conversion timeout?

No universal conversion timeout is established here. The conversion library or service defines the relevant API.

Is 5 seconds a good timeout?

It is the value in Syncfusion’s documented Blink example, not a general recommendation. Choose a limit from your workload and latency needs.

Will cancelling an HTTP request stop the remote conversion?

Not necessarily. The client-side timeout limits the request from the client’s perspective; server-side cancellation depends on the remote service.

Should I use synchronous conversion?

Choose the method that fits your application and library. Whatever overload you use, verify whether it supports cancellation and how it reports an expired limit.

References

Keep reading

8 min read

How to Set Image Resolution in DPI

Change an image’s print resolution without changing its pixels, or resample it to meet a target size. Learn the Photoshop and GIMP steps and the math behind them.