Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsTo capture a website from C# or .NET, call a hosted screenshot API: use that provider’s .NET SDK when its framework and behavior fit your application, or send the request with HttpClient when you want to avoid a vendor client or none is available. Screenshot Scout documents an official package for .NET 8+, while ScreenshotAPI.to’s guide demonstrates direct HTTP calls for .NET 6+. These are vendor-specific baselines, not a universal minimum for screenshot APIs.
This is different from taking a screenshot of the current screen in a .NET MAUI app. A hosted screenshot API renders a supplied website URL in a remote browser; MAUI’s Screenshot API captures the app’s displayed screen on a supported device.
Choose an integration route
Start with the API provider’s current documentation and package metadata. An SDK may supply request models, signing, typed errors, and response handling; direct REST keeps dependencies light but makes your application responsible for those details. The code examples below are provider-specific and should not be mixed across services: authentication headers, query parameters, response formats, and capture options differ.
| Route | What the reviewed documentation establishes | Good fit when |
|---|---|---|
| ScreenshotNeo API and MCP server | One GET request to its API can return a PNG, JPEG, WebP, or PDF; its parameters support common screenshot API names. ScreenshotNeo also documents an MCP server for AI agents. | You want a direct HTTP integration, clean captures, and explicit verdict/billing headers. |
| Screenshot Scout .NET SDK | Official package ScreenshotScout, documented for .NET 8 or later; asynchronous capture and binary or JSON response modes. |
You meet the framework requirement and want the vendor’s client behavior, signing, and typed errors. |
| ScreenshotOne .NET package | Installable package named ScreenshotOne.dotnetsdk; its documentation shows signed URL generation and fetching image bytes. |
You have checked the package’s current release, target frameworks, maintainers, and support channel. |
| Direct REST with ScreenshotAPI.to | The C# guide demonstrates HttpClient for .NET 6+ and says the service has no official .NET SDK yet. |
You prefer a small dependency surface and are prepared to implement request and error handling. |
| AllScreenshots SDK | Its documentation describes AllScreenshots.Sdk for .NET 8+, including capture options, async jobs, bulk capture, and composition. |
You need the documented capabilities and have verified current package recency and service terms. |
For any provider, compare target framework, official package status, authentication and signing, image-versus-JSON responses, capture controls, cancellation and timeouts, diagnostics, package maintenance, and service terms. Package registries and vendor features change; verify current metadata before adoption.
Free tools Windows power users keep installed
One-click scans. No signup required.
#1 Best Overall
Use a .NET SDK when its contract fits
Screenshot Scout
Screenshot Scout’s documented flow installs ScreenshotScout, constructs a ScreenshotScoutClient with an access key, then calls CaptureAsync(url, options). By default, the call uses POST and returns binary image data. The sample pattern is to check for BinaryCaptureResponse and save its Bytes. The client can also return JSON with CaptureResponseType.Json, or use GET when selected explicitly. See the vendor’s repository and README for current installation and API details.
The SDK documents options for output format and response type; country, proxy, and geolocation; cookies and headers; navigation timing; device emulation; media and color preferences; full-page capture; overlay blocking; DOM interaction and injection; element or clip framing; image sizing; PDF; caching; and storage. These are Screenshot Scout options, not a promise that another vendor exposes the same controls.
For production, reuse an injected HttpClient where appropriate and observe the SDK’s documented ownership rules. Its documentation distinguishes the service-side capture timeout from a caller’s CancellationToken, exposes raw response details, and separates API, transport, configuration, serialization, and decoding exceptions. Map these to your own application’s logging and retry policy rather than treating every failure as an identical screenshot error.
ScreenshotOne and AllScreenshots
ScreenshotOne’s C#/.NET documentation shows installing ScreenshotOne.dotnetsdk using NuGet or the .NET CLI, generating a signed capture URL, and fetching image bytes. NuGet displayed version 1.0.5 and framework metadata, including .NET Standard 2.1 and computed targets through .NET 10 when reviewed in 2026; those registry facts can change. NuGet says it does not support the package itself, so check the maintainers’ current support and release history before building on it. The repository metadata for Screenshot Scout identifies an MIT license; confirm the current license for any dependency you adopt.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →AllScreenshots documents a .NET 8+ package, AllScreenshots.Sdk, with API-key configuration, capture options, async jobs, bulk capture, and composition. Treat these as vendor-documented capabilities and verify present availability, package status, and service terms directly with the provider.
Call a screenshot API directly with HttpClient
When a provider documents REST but not an official .NET client, HttpClient is sufficient. The following ScreenshotAPI.to-shaped example follows that guide’s pattern: API key in an x-api-key header, URL-encoded parameters, success-status validation, and binary response bytes. The endpoint and parameters are specific to that service; use the current endpoint and exact parameter names in the provider’s documentation.
Example targeting .NET 6+:
using System.Net.Http.Headers;
using System.Text;
var apiKey = Environment.GetEnvironmentVariable("SCREENSHOT_API_KEY")
?? throw new InvalidOperationException("Set SCREENSHOT_API_KEY first.");
using var client = new HttpClient
{
Timeout = TimeSpan.FromSeconds(90)
};
var parameters = new Dictionary<string, string>
{
["url"] = "https://example.com",
["width"] = "1440",
["height"] = "900",
["full_page"] = "true",
["format"] = "png"
};
var query = string.Join("&", parameters.Select(p =>
$"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(p.Value)}"));
using var request = new HttpRequestMessage(
HttpMethod.Get,
$"https://api.screenshotapi.to/v1/screenshot?{query}");
request.Headers.Add("x-api-key", apiKey);
using var response = await client.SendAsync(
request,
HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();
var image = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("capture.png", image);
Console.WriteLine($"Saved {image.Length} bytes to capture.png");The endpoint and parameter spelling above reflect the guide’s example pattern; consult the provider’s live documentation for the precise URL and supported values before running it. The guide’s reusable-client model includes width, height, full-page capture, format, quality, color scheme, wait condition, selector, and delay. Do not assume every service accepts every setting.
Make the HTTP integration production-ready
- Reuse the client. A real application should normally use an injected
HttpClientorIHttpClientFactory, rather than constructing one per capture. Set a timeout appropriate to the remote render and your request budget. - Propagate cancellation. Pass the caller’s
CancellationTokenthrough the send and body-read operations. A cancelled caller request does not necessarily cancel work already running at the remote service. - Validate the response. Check status before saving bytes, and check content type or file signature if the API may return JSON errors, PDFs, or multiple image formats. Do not silently save an error body with a .png extension.
- Protect secrets and URLs. Keep API keys in environment-backed configuration or a secret store; never commit them or log full authenticated request URLs. If an API embeds a key in a generated URL, treat that URL as a credential.
- Retry selectively. Retry only transient transport failures or documented retryable server responses, with bounded attempts and backoff. A timeout can mean the remote browser did not finish; repeated immediate retries may add load or create duplicate work.
- Limit concurrency and payloads. Large full-page images and PDFs consume more network and memory than viewport captures. Stream or persist responses where suitable, and bound parallel jobs to avoid exhausting sockets, memory, or provider quotas.
Or skip the browser setup
ScreenshotNeo provides a one-call screenshot API and an MCP server for Claude, Cursor, and other MCP clients. Cookie banners and consent overlays, newsletter popups, and chat widgets are removed before capture; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed as clean shots, and responses identify the page verdict and billing status in X-Page-Verdict and X-Billed headers. Plans include 1,000 shots a month free with no card; paid plans start at $5 for 3,000. See the ScreenshotNeo API documentation for request options.
using System.Net.Http;
using var client = new HttpClient();
var url = "https://api.screenshotneo.com/v1/shot";
var query = new Dictionary<string, string>
{
["access_key"] = Environment.GetEnvironmentVariable("SCREENSHOTNEO_API_KEY")
?? throw new InvalidOperationException("Set SCREENSHOTNEO_API_KEY first."),
["url"] = "https://example.com"
};
var queryString = string.Join("&", query.Select(p =>
$"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(p.Value)}"));
using var response = await client.GetAsync($"{url}?{queryString}");
response.EnsureSuccessStatusCode();
var bytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("shot.webp", bytes);The API can return PNG, JPEG, WebP, or PDF; select the output and other capture parameters documented for your use case. An MCP server lets AI agents take screenshots, and the broader feature set includes full-page and element capture, custom CSS or JavaScript, waits, device presets, PDF settings, caching, signed image links, async jobs, and bulk capture. Every feature is on every plan; yearly billing gives two months free.
Sign up for ScreenshotNeo: 1,000 screenshots a month free, with no card required.
Rank #4
Use the right API settings for the page
Rendering succeeds only when the request gives the page enough time and tells the API what to capture. Determine whether you need a viewport or a full page, a desktop or mobile viewport, a particular color scheme, or a specific element. Dynamic pages may need a selector wait, a delay, or network-idle condition; excessive waits increase latency. If the site needs authentication, check whether the API supports cookies or custom headers and send only credentials you are authorized to use.
For an image pipeline, agree on output format, dimensions, and quality with downstream consumers. For documents, check PDF page size, margins, orientation, and page ranges. Transparent backgrounds, resizing, CSS/JavaScript injection, selector hiding, and resource blocking can alter the result; keep such transformations explicit and test them against the pages that matter.
Authentication, reliability, and cost
Credentials and signed capture URLs
Screenshot Scout’s client supports signed requests when configured with its secret key. Its generated capture URLs contain the access key, so treat them as sensitive and follow the documentation’s advice to sign before exposing URLs to browsers or users. Do not put real keys in source code, public repositories, client-side JavaScript, or diagnostic logs. ScreenshotAPI.to’s C# guide uses the x-api-key header; that is a service-specific scheme, not a general standard.
Failures and billing semantics
Distinguish a local HTTP timeout from a provider’s render timeout, a non-success HTTP status from an API-level capture error, and a valid image from an error payload. Preserve response status and provider diagnostics in logs while redacting credentials. For ScreenshotNeo, the response’s verdict and billed headers make it possible to tell a clean capture from bot checks, blank pages, failed loads, timeouts, or cache hits; those non-clean outcomes are not billed.
Cost controls
Before selecting a plan, measure your expected monthly clean captures, retries, and bulk needs against the provider’s current quota and billing rules. Cache stable pages when permitted, avoid unnecessary full-page/PDF renders, and inspect billing metadata when the API supplies it. ScreenshotNeo’s listed tiers are Free: 1,000 per month; Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; Business: $249 for 1,000,000. Yearly billing gives two months free. These are ScreenshotNeo plan prices and allowances; confirm current terms on its site.
Troubleshoot common integration problems
| Symptom | Likely cause | What to check |
|---|---|---|
| Build fails or package APIs are missing | The project target is below the SDK’s stated framework requirement, or package metadata changed. | Check the provider’s current target frameworks; Screenshot Scout documents .NET 8+, AllScreenshots documents .NET 8+, and ScreenshotAPI.to’s guide uses .NET 6+ direct HTTP. |
| 401 or 403 response | Missing, invalid, or misplaced credentials; the service may require a different auth method. | Confirm the key is present and use the provider’s required header, parameter, or signature. Never paste secrets into logs while diagnosing. |
| Saved file is JSON or unreadable | The API returned an error or a different response mode/format than expected. | Inspect status, content type, response body safely, and the selected output mode. Screenshot Scout can return binary by default or JSON when requested. |
| Capture is blank or misses content | Client-side rendering has not completed, a selector is wrong, or the target blocks automation. | Use the provider’s documented wait condition or selector wait; verify the selector against the rendered page and check its page verdict if supplied. |
| Timeout or cancellation | The page is slow, the render timeout is too short, or the caller cancelled independently. | Separate caller cancellation from service-side timeout, tune waits, and retry only under a bounded policy. |
| Excessive memory or latency | Many large full-page captures are running concurrently, or response bytes are buffered unnecessarily. | Limit parallelism, choose only the required dimensions and page scope, and use streaming or durable storage where appropriate. |
| Package has no clear support path | Registry metadata may not identify who maintains or supports it. | Check repository activity, release history, license, and vendor support channels before adoption; NuGet says it does not support ScreenshotOne.dotnetsdk itself. |
Frequently asked questions
Can I use any screenshot API from C#?
Usually, if the provider exposes HTTP endpoints, but its authentication, parameter names, accepted methods, and response shape are provider-specific. Follow that API’s documentation rather than assuming SDKs are interchangeable.
Is .NET MAUI Screenshot the same thing?
No. Microsoft’s Microsoft.Maui.Media.Screenshot API captures the currently displayed screen of a running app and exposes IsCaptureSupported to check device support. It does not render an arbitrary website URL in a hosted browser. See Microsoft Learn’s MAUI screenshot API reference.
Should I choose an SDK or raw HttpClient?
Choose based on framework compatibility, authentication and signing, output modes, capture controls, cancellation and error diagnostics, and how actively the package is maintained—not simply on which example has fewer lines.
