Screenshot API with ASP.NET Core — HttpClient, Background Services & Blazor

Screenshot API in ASP.NET Core with HttpClient

ASP.NET Core applications call the SnapAPI screenshot endpoint using the IHttpClientFactory pattern, which manages HttpClient instance lifetimes correctly and avoids socket exhaustion from improper HttpClient disposal. Register a named HttpClient for SnapAPI in Program.cs using builder.Services.AddHttpClient("snapapi", client => { client.BaseAddress = new Uri("https://snapapi.pics"); }). Inject the IHttpClientFactory interface into your controller or service and call CreateClient("snapapi") to get a properly managed HttpClient instance. Construct the request URL with QueryString parameters for the access key and target URL, call GetAsync to send the request, and read the response content as a byte array with ReadAsByteArrayAsync for binary PNG responses or as a string with ReadAsStringAsync followed by JsonSerializer.Deserialize for JSON responses. The typed HttpClient variant provides a cleaner interface for services that exclusively call the SnapAPI endpoint.

ASP.NET Core minimal API endpoints that proxy screenshot requests to SnapAPI implement the route handler as an async lambda that reads the url query parameter, validates it, calls the SnapAPI HttpClient, and returns a Results.File response with the PNG bytes and the image/png content type. Minimal API route handlers are more concise than controller-based alternatives for simple proxy endpoints with no complex business logic. Add rate limiting middleware to the minimal API using the RateLimiter middleware with a fixed window or sliding window policy keyed to the client's IP address or user identity to prevent individual clients from exhausting the SnapAPI monthly quota through the proxy endpoint. ASP.NET Core's built-in rate limiting middleware, introduced in .NET 7, handles this without requiring a third-party middleware package.

Screenshot API ASP.NET Core Background Services

ASP.NET Core IHostedService background services process screenshot generation jobs from a queue without blocking the main request pipeline. Define a ScreenshotWorkerService class that implements BackgroundService and overrides the ExecuteAsync method with a loop that dequeues screenshot jobs from a Channel or a database-backed queue, calls the SnapAPI endpoint using a typed HttpClient, stores the result, and updates the job status. Register the background service in Program.cs with builder.Services.AddHostedService to start it automatically when the application starts. The background service runs concurrently with the HTTP request pipeline, processing screenshot jobs asynchronously while the web application continues handling user requests normally. For ASP.NET Core applications deployed on Azure App Service, configure Always On to prevent the application from being shut down when idle, which would terminate in-progress background screenshot processing.

ASP.NET Core applications can use Azure Queue Storage or Azure Service Bus as the backing queue for screenshot jobs in cloud deployments, providing durable job storage that persists screenshot requests across application restarts and scales horizontally across multiple application instances. When a web request triggers a screenshot, enqueue a message containing the target URL and job metadata to Azure Queue Storage using the Azure.Storage.Queues SDK. The background worker service dequeues messages, calls SnapAPI for each job, and stores results in Azure Blob Storage. Multiple application instances can process jobs concurrently by each running an instance of the background service, with Azure Queue Storage's message lease mechanism preventing duplicate processing of the same job by multiple workers.

Screenshot API with Blazor Server Components

Blazor Server components that display screenshot thumbnails call the SnapAPI endpoint from C# server-side code using the injected HttpClient, then update the component state to render the screenshot. Define a Blazor component with an ImageUrl parameter or a TargetUrl parameter, a private string screenshotSrc field for the image source, and a bool loading field for the loading state. In the OnParametersSetAsync lifecycle method, set loading to true, call the SnapAPI screenshot proxy endpoint using the injected HttpClient, encode the resulting byte array as a base64 data URL string, assign it to screenshotSrc, and set loading to false. The Blazor rendering engine updates the DOM automatically when the state changes, displaying the loading indicator while the screenshot generates and the image when it completes. For Blazor components displayed in lists, use a CancellationToken tied to the component lifecycle to cancel in-flight requests when components are removed from the DOM.

Screenshot API .NET SDK Integration

The SnapAPI .NET SDK wraps the HttpClient integration pattern in a clean, testable interface with async methods, strongly typed request and response objects, and built-in retry logic for transient errors. Add the NuGet package SnapAPI.Net to your project, configure the client with your API key from the IConfiguration system, and inject the SnapAPIClient into services and controllers through the standard dependency injection container. The SDK's ScreenshotAsync method accepts a ScreenshotOptions record with properties for all supported parameters and returns a ScreenshotResult record with the image bytes, HTTP status code of the captured page, and page metadata. The strongly typed interface eliminates the query string construction and response parsing boilerplate from every call site and provides IntelliSense documentation for all parameters and response fields in Visual Studio and Rider.