WebGPU Report
Read the adapter identity, feature set and limits WebGPU exposes to any page, and check whether it names the same GPU that WebGL does. Free, no signup, nothing uploaded.
- Runs in your browser
- Opens WebGL first to cross-check
- No signup
See what WebGPU says about this GPU
The report opens a WebGL context, then requests a WebGPU adapter and reads its identity, features and limits — and checks that the two APIs name the same hardware, because a machine has one GPU and two stories about it is the finding.
Runs entirely in this browser. Nothing is uploaded, nothing is stored, no signup.
Now give every account its own device.
A clean browser is still one browser. Sendwin runs each profile in isolation with its own fingerprint, cookies and proxy, so the accounts you work on never look like they came from the same machine.
- Isolated profiles, each with its own fingerprint and cookies
- A proxy per profile, with the timezone bound to the proxy country
- Windows, macOS and Linux — plus cloud sessions when you need them
The free plan includes 10 minutes of cloud browsing a day.
A second description of the same GPU
WebGPU is the successor to WebGL: a lower-level graphics and compute API that Chromium, Firefox and Safari now ship. Before a page can draw anything it asks for an adapter, and the adapter answers with a vendor, an architecture, a list of optional features it supports and a table of numeric limits — maximum texture size, buffer size, workgroup size and about thirty more. None of that needs a permission prompt, and none of it is secret by design; it is there so a page can decide what it is able to run.
The same answers make a durable identifier. Vendor and architecture narrow you to a GPU family; the feature list and the limit values narrow you to a generation and a driver. This page requests an adapter the way any site would, reads everything it publishes, hashes the feature-and-limit table so you can compare it across reloads, and — because it also opens a WebGL context first — checks that the two APIs describe the same piece of hardware. A machine has one GPU. Two APIs that name different vendors were not both telling the truth.
What the adapter gives away
Adapter info is deliberately coarse: a vendor such as nvidia, amd, intel or apple, an architecture family, and on some platforms a device and description string. The features and limits are where the detail is. Each optional feature (texture compression formats, timestamp queries, shader float16 and so on) is present or absent per hardware and driver, and the limit values are the actual numbers the driver reports rather than a rounded tier. Together they form a table with far more distinct outcomes than the vendor alone, and it stays identical for the lifetime of a driver install.
Why the WebGL comparison is the interesting part
WebGL names the GPU through its renderer string; WebGPU names it through the adapter. Both read the same physical device, so on a real machine they agree at the family level: an AMD renderer in WebGL and an amd architecture in WebGPU. Spoofing tools that rewrite the WebGL renderer string frequently forget the newer API, and the result is a browser that claims NVIDIA in one place and Intel in another. That single disagreement is worth more to a detection system than either value alone, because a real device cannot produce it.
No adapter, software adapter, and what each means
Three outcomes are ordinary and none of them is an automation tell. Safari and older Chromium builds expose no navigator.gpu at all. A browser with the API present but no adapter granted usually has the GPU blocklisted or hardware acceleration switched off. A fallback adapter means rendering is happening in software — normal on a VPS, inside a virtual machine or over remote desktop, and exactly how our own cloud sessions render. Each is a property of the environment. What none of them explains is a hardware WebGPU adapter sitting next to a software WebGL renderer, which is the one combination this page flags.
How the report is produced
- 1
Open WebGL first
The page reads the WebGL renderer and vendor so there is something to compare the newer API against. The rows appear in their own group above the WebGPU ones.
- 2
Request a WebGPU adapter
navigator.gpu.requestAdapter() is called with a high-performance preference, then the adapter's info, features and limits are read and hashed.
- 3
Compare the two stories
The GPU family named by each API is matched, and a hardware adapter beside a software renderer is flagged. Agreement is the normal result; disagreement is the finding.
Other free checks
WebGPU is one read of the hardware. These are the others a site compares it with.
WebGPU FAQ
What the adapter exposes, why the WebGL comparison matters, and what a missing adapter means.
Reading the adapter description, feature list and limit table that WebGPU hands to any page, and using that combination as an identifier. It works for the same reason WebGL fingerprinting works: the values are determined by hardware and driver rather than by anything the user chooses, so they stay put across sessions and differ between machines.
No. Chromium has shipped it on desktop since version 113 and on Android since 121; Firefox and Safari added it more recently, and some platforms still ship it behind a flag. A browser that does not expose navigator.gpu is not suspicious — it simply has one fewer set of GPU signals to read.
navigator.gpu exists but requestAdapter() returned nothing. The usual causes are a GPU on the browser's blocklist, hardware acceleration switched off in settings, a headless build, or a virtual machine with no usable graphics stack. The API is present because the browser supports it; the adapter is absent because the machine cannot back it.
It is differently identifying. WebGL's renderer string is often the single most specific value a page can read, while WebGPU's adapter info is deliberately coarse. But the WebGPU limit table is precise and long, and the two APIs together give a site two independent reads of the same hardware. The pairing is what matters: a site that has both can check them against each other.
Chromium and Firefox both have a flag for it, and some privacy-focused browsers disable it by default. Doing so removes this set of signals, at the cost of any site that uses the API for rendering or compute — and a browser that claims a recent Chrome version while exposing no navigator.gpu is itself a mismatch a careful site can notice.
No. The adapter is requested and read in your browser, the hash is computed here, and nothing is sent to Sendwin or anyone else. Reloading clears the result; the raw JSON below the table is there so you can copy it yourself.
Each profile's GPU identity is set at the engine level, so WebGL and WebGPU describe the same adapter, the feature and limit tables belong to that adapter, and the values hold still across sessions. You can confirm it the same way you just checked this browser: open this page inside a profile and read the comparison row.
Still have questions? Talk to us →
How to read the report
The comparison here is between two APIs in one browser. Agreement means they describe the same hardware; it does not mean the hardware is real, and it does not rank this machine against any other. There is no database behind this page and no rarity figure, because we do not hold other visitors' adapters and would not print a number we cannot measure.
One GPU story, told by every API.
Sendwin sets each profile's GPU identity at the engine level, so WebGL and WebGPU name the same adapter and its limits hold still across sessions. Free for 30 days on Windows, macOS and Linux.
30-day free trial · $0 today · cancel anytime — your profiles stay on your machine