PowerShell Command Instantly Reveals Your Motherboard Model on Windows 11 — No Screwdriver Required

A quick PowerShell cmdlet can pull your motherboard’s manufacturer, model, and revision directly from Windows 11’s firmware data — and it works just as well on Windows 10. No third-party tools, no BIOS navigation, and no case screws required.

It’s the kind of information that sits quietly in your system until the moment you need to download a BIOS update, check RAM compatibility, or file a support ticket. Instead of powering down, grabbing a screwdriver, and squinting at tiny PCB labels, you can retrieve everything from a single Terminal window.

A Single PowerShell Command Gets the Job Done

Right-click the Start button and choose Terminal (or Windows PowerShell on older builds). Paste this line and press Enter:

Get-CimInstance -ClassName Win32_BaseBoard | Select-Object Manufacturer, Product, Version, SerialNumber

The result drops in under a second. On a typical custom-built desktop, you might see something like:

Manufacturer              Product                   Version  SerialNumber
------------              -------                   -------  ------------
Gigabyte Technology Co.   B650 AORUS ELITE AX       x.x      ************

The Get-CimInstance cmdlet queries the standard Win32_BaseBoard class — Microsoft’s inventory abstraction for the physical motherboard, also called the baseboard. It only reads data already supplied by your firmware; it doesn’t install anything or require admin rights.

If you need to share the details with a forum or help desk, you can pipe the output straight to the clipboard:

Get-CimInstance -ClassName Win32_BaseBoard | Select-Object Manufacturer, Product, Version, SerialNumber | Format-List | Set-Clipboard

But be careful: that copies the serial number too. For public posts, slim the selection down to just the three identification fields:

Get-CimInstance -ClassName Win32_BaseBoard | Select-Object Manufacturer, Product, Version

System Information: The Graphical Alternative

PowerShell isn’t the only built‑in route. If you prefer clicking to typing, the old msinfo32 app still does the trick. Hit Windows + R, type msinfo32, and press Enter. Under System Summary, look for the entries named BaseBoard Manufacturer, BaseBoard Product, BaseBoard Version, and BaseBoard Serial Number.

The graphical tool is handy when you’re already poking around for a broader inventory, but it forces you to scroll through a long list. The PowerShell command gets you straight to the payload.

One quirk Microsoft acknowledges: System Information may show incomplete hardware data if you launch it in Safe Mode. Restart normally before relying on its output. Running it as administrator can sometimes improve driver reporting, though it’s not necessary for baseboard fields.

Why You Should Ditch the Old WMIC Command

If you’ve hunted for motherboard‑checking advice before, you’ve probably seen this Command Prompt relic:

wmic baseboard get manufacturer,product,version,serialnumber

It may still work on some Windows 10 and 11 installations, but Microsoft officially deprecated the WMIC utility starting with Windows 10 version 21H1. The WMIC command is a wrapper around the older Windows Management Instrumentation (WMI) infrastructure, and its future is uncertain. When it finally vanishes, scripts that depend on it will break without notice.

PowerShell’s Get-CimInstance is the supported replacement. It talks to the same underlying data through the Common Information Model (CIM) standard — a more modern, cross‑platform management layer. Moving your habits and scripts to it now ensures you won’t be caught off guard later.

Decoding the Output: What Each Field Actually Means

The labels Windows uses don’t always match the marketing name on the box. Here’s how to interpret them:

On a self-built PC, BaseBoard Product is usually the retail name you’d recognize. On a laptop or OEM desktop (Dell, HP, Lenovo, etc.), it might be an internal identifier like 0T7N1M or E93839. That’s entirely normal. In those cases, you should lean on the overall system model for driver downloads and support.

To get that system model, run:

Get-CimInstance -ClassName Win32_ComputerSystem | Select-Object Manufacturer, Model

That’s the information you’d enter on the manufacturer’s support site — not the baseboard product code.

When Windows Can’t Tell You the Full Story

Windows can only report what the firmware feeds it. If the manufacturer left fields empty or filled them with generic placeholders, you’ll see things like:

• To Be Filled By O.E.M.
• Default string
• System Product Name
• OEM

These are frustratingly common on budget prebuilts and some laptops. If both PowerShell and System Information show the same vague data, the firmware is almost certainly the source.

Your next line of attack is to check the device model in Settings > System > About, or use the Win32_ComputerSystem cmdlet above. For a laptop or branded desktop, that system model — combined with the manufacturer’s serial number or service tag — is far more useful than any motherboard detail. Most OEMs also offer a support‑detection utility; download it from their site if the sticker is hard to find.

As a last resort, you can restart the PC and enter the UEFI/BIOS setup screen (usually by pressing F2, Del, or Esc during startup). The main page often lists a board name or revision. Just make sure you exit without saving any changes. Physically opening the case should only be the final option — and only for a desktop where you need an absolute revision number for a critical BIOS flash or replacement part.

Before You Buy RAM or Flash the BIOS

Knowing the motherboard model is step one. Step two is using that information carefully. Flashing the wrong BIOS can leave your system unable to boot, and RAM that fits the slot isn’t always compatible.

For a BIOS update:
- Record BaseBoard Manufacturer, BaseBoard Product, and BaseBoard Version.
- Also record the current BIOS version from System Information.
- On a self-built PC, head to the board manufacturer’s support page and match the model and revision exactly. Even a one‑digit difference in revision (e.g., rev 1.0 vs 2.0) can mean incompatible firmware.
- On a Dell, HP, Lenovo, or similar prebuilt, always use the PC maker’s support page and your system model or service tag. Never cross‑flash a BIOS intended for a retail board that happens to share a chipset.

For hardware upgrades:
- The motherboard model gives you a starting point, but pull up the manual to confirm:
- CPU socket and supported processor generations
- Maximum memory capacity, supported speeds, and dual‑channel rules
- M.2 slot types (NVMe PCIe 3.0/4.0, SATA) and physical lengths
- SATA port availability and potential conflicts with M.2 slots
- PCIe slot wiring (a physical x16 slot might run at x4 electrically)
- Minimum BIOS version required for a newer CPU

Laptops are a special case. The baseboard product field is almost never enough to safely select RAM or a Wi‑Fi card upgrade. Always consult the laptop manufacturer’s service manual for the exact system model.

The Backstory: How Windows Reads Motherboard Details from Firmware

The ability to query motherboard information programmatically isn’t new — it’s been in Windows since the WMI era of the late 1990s. But the method has matured significantly over the last few years.

When you run Get-CimInstance -ClassName Win32_BaseBoard, Windows talks to the System Management BIOS (SMBIOS) data structures that firmware exposes to the operating system at startup. These structures contain inventory entries for the baseboard, system enclosure, processor, memory devices, and more. The values are provided by the manufacturer during production and stored in a special region of the firmware flash.

For years, the standard way to access this data from a script was wmic baseboard get. But WMIC (the WMI Command‑line) tied you to the original COM‑based WMI stack and a verbose, inconsistent syntax. As part of the broader move to PowerShell and modern management, Microsoft introduced CIM cmdlets in Windows PowerShell 3.0 (released alongside Windows 8 in 2012). These use the WS‑Management protocol and an object‑pipeline design that’s cleaner, more secure, and easier to automate.

The deprecation of WMIC in Windows 10 21H1 was the final signal: any guide or script still using wmic is on borrowed time. The underlying WMI repository with its Win32_BaseBoard class isn’t going away, but the command‑line entry point will eventually be removed. Transitioning to the PowerShell CIM cmdlets now future‑proofs your tooling.

What to Watch Next

Motherboard identification via firmware isn’t likely to change dramatically, but a couple of trends are worth noting. First, as Windows 10 reaches end of support and more users shift to Windows 11, the use of PowerShell over older command‑prompt tools will accelerate — especially as new admins learn the modern stack from the start.

Second, the ever‑growing complexity of UEFI firmware means that manufacturers are starting to populate the SMBIOS fields more consistently, even on consumer boards. The “To Be Filled By O.E.M.” placeholder may become rarer, making these simple built‑in commands even more reliable.

For now, the one‑liner is the fastest, cleanest way to pull your board identity without leaving the desktop. Bookmark it.