Somewhere on your PC's case or laptop chassis there is a sticker with a serial number. You could also open the Settings app, dig through System, find the About page, and scroll until it appears. That works for one computer. It is a nightmare for twenty, and it fails entirely when the sticker has worn off or the machine is in another building. The reliable way to find serial numbers on Windows is the command line: Command Prompt and PowerShell can pull the numbers straight from the hardware, fast, and in a format you can copy into a spreadsheet.
This guide covers the essential commands, explains what each number actually means, and shows you how to build a script that inventories a whole fleet in minutes.
Why Serial Numbers Matter
A serial number is the hardware's identity document. Manufacturers use it to track production, and you use it for three practical jobs. Warranty claims: most manufacturers want the serial before they will talk to you, and finding it on demand speeds up every support case. Asset tracking: if your organization owns a hundred laptops, the serial is the key that ties a physical device to a purchase order, a user, and a software license. Security: in an audit or an incident response, serial numbers help you confirm which physical machines are on your network and spot unauthorized devices.
None of this works if the numbers live on a sticker that has faded. The hardware itself stores its own identifiers in firmware, and Windows can read them directly.
Consider a typical helpdesk morning: a user reports a broken laptop, the vendor asks for the serial, the ticket needs the asset tag, and the license team wants to confirm which machine is running the expensive software. Doing that by reading stickers and opening system dialogs takes minutes per device; a single command returns all of it in seconds. That speed is why serial number lookup is a core skill for anyone who manages more than a handful of computers.
Before You Start: Permissions and Caveats
Most serial number commands work from a normal user account, but a few require administrator rights, and some numbers are simply not populated by certain manufacturers. Open Command Prompt by typing cmd in the Start menu; if a command returns Access denied, close it and reopen as administrator by right-clicking and choosing Run as administrator.
Two things to know before you trust a result. First, some manufacturers, especially on consumer laptops, leave certain fields blank to keep the sticker relevant — a blank answer does not mean your command failed. Second, the numbers are only as trustworthy as the firmware that stores them; a BIOS that has been reflashed or a motherboard that has been replaced can return values that do not match the original unit. When in doubt, record what the system reports and note the method you used; a timestamped inventory entry is worth more than a guess about which number is authoritative.
Finding the BIOS and Motherboard Serial Number
The most fundamental identifier on a PC is stored in the firmware. The classic command uses WMIC, the Windows Management Instrumentation command-line tool:
wmic bios get serialnumber
This returns the serial number recorded in the BIOS, which is usually the number the manufacturer uses for the whole system. For many business machines, this is also the number printed on the chassis, which makes it the best starting point for warranty calls.
If the BIOS field is blank, the motherboard itself often carries its own serial:
wmic baseboard get serialnumber
Motherboard numbers are useful when you are tracking individual components, but be aware that a motherboard swap changes what this command returns while the BIOS number may stay the same.
WMIC still works on most systems, but Microsoft has deprecated it, and it has been removed from the newest Windows releases. If wmic is not recognized on your machine, use the PowerShell alternatives in the next section — they are the modern, supported way.
Finding the System Serial Number
The system serial is the number that represents the complete unit — the number on the sticker. The WMIC command for it is:
wmic csproduct get identifyingnumber
The csproduct class describes the computer system product, and its identifyingnumber property is the system serial. This is the most relevant number for warranty tracking and asset management, because it is the one the manufacturer associates with the machine as sold.
To see the full picture in one command, combine the queries:
wmic bios get serialnumber
wmic csproduct get identifyingnumber
wmic baseboard get serialnumber
Each command returns its value on its own line, which makes them easy to copy into a text file for a quick inventory. For a clean record, redirect the output to a file in a single step and keep the result alongside your purchase order or asset register.
Getting Network Adapter and MAC Information
Serial numbers identify the machine, but network identifiers identify it on the network. The MAC address is the permanent identifier burned into each network adapter, and it is essential for DHCP reservations, network audits, and identifying a device when the OS label is misleading.
From Command Prompt, the simplest command is:
getmac /v /fo list
This lists every network adapter with its physical address, connection name, and transport name. The /v flag adds verbose detail and /fo list formats the output as readable key-value pairs.
For a cleaner hardware-level view, WMIC offers:
wmic nic where "netenabled=true" get macaddress
This filters to active adapters only, which is useful on machines with virtual adapters installed by VPN or virtualization software.
PowerShell: The Modern Comprehensive Approach
PowerShell replaces WMIC with the Get-CimInstance cmdlet, which is fully supported in current Windows versions and works identically in scripts. Open PowerShell from the Start menu and run:
Get-CimInstance Win32_BIOS | Select-Object SerialNumber
Get-CimInstance Win32_ComputerSystemProduct | Select-Object IdentifyingNumber
Get-CimInstance Win32_BaseBoard | Select-Object SerialNumber
Get-CimInstance Win32_Processor | Select-Object ProcessorId
The Win32_ classes map almost one-to-one to the WMIC classes, so anything you learned with wmic transfers directly. The advantages of PowerShell: the output is a proper object, not text, which makes formatting, filtering, and exporting dramatically easier.
To see everything in one screen, combine them:
Get-CimInstance Win32_ComputerSystemProduct | Select-Object Name, IdentifyingNumber
Get-CimInstance Win32_BIOS | Select-Object Manufacturer, SerialNumber
Get-CimInstance Win32_BaseBoard | Select-Object Manufacturer, Product, SerialNumber
Building a Batch Inventory Script
The real payoff of the command line is automation. A short PowerShell script can inventory every machine it runs on and write the results to a single file, ready for a spreadsheet.
Save the following as inventory.ps1:
$computer = $env:COMPUTERNAME
$bios = Get-CimInstance Win32_BIOS
$product = Get-CimInstance Win32_ComputerSystemProduct
$board = Get-CimInstance Win32_BaseBoard
$cpu = Get-CimInstance Win32_Processor
[PSCustomObject]@{
ComputerName = $computer
SystemSerial = $product.IdentifyingNumber
BiosSerial = $bios.SerialNumber
BoardSerial = $board.SerialNumber
ProcessorId = $cpu.ProcessorId
} | Export-Csv -Path "inventory-$computer.csv" -NoTypeInformation
Run it with:
powershell -ExecutionPolicy Bypass -File inventory.ps1
Each machine produces a CSV with its serials. Combine the files, and you have a fleet inventory without touching a single machine physically. The same script can be pushed with group policy, run from a login script, or executed remotely against a list of machines.
Inventorying Remote Machines
For machines you can reach over the network, PowerShell remoting takes the script further. From an elevated prompt on a management machine, you can run the same CimInstance queries against a list of remote computers:
$computers = Get-Content -Path "computers.txt"
foreach ($computer in $computers) {
$product = Invoke-Command -ComputerName $computer -ScriptBlock {
Get-CimInstance Win32_ComputerSystemProduct
}
[PSCustomObject]@{
ComputerName = $computer
SystemSerial = $product.IdentifyingNumber
} | Export-Csv -Path "remote-inventory.csv" -NoTypeInformation -Append
}
Remote inventorying requires the machines to allow PowerShell remoting and the account to have permission on each target. It is the fastest way to build a fleet list, but test it on one machine first, because permission errors are the most common failure and they only become obvious at scale.
Verifying Your Data
Inventory data is only useful if it is accurate. Before you treat a serial list as fact, verify a sample against the physical machines. Pick five devices, compare the reported numbers with the labels, and confirm they match. If they do, the firmware and the labels agree, and you can trust the rest of the list. If even one device disagrees, check whether that machine had a motherboard replacement or a firmware reflash before you trust the whole dataset.
Event Logs and the Difference Between CMD and PowerShell
A common confusion is whether the serial number appears in the event logs. Windows does log hardware changes in the System event log, and a device install event may reference hardware IDs, but serial numbers are generally not written to event logs. If you need an audit trail of hardware changes, the event log tells you when something changed, while the commands above tell you what the hardware reports now. For forensic work, record both the timestamp and the serial so you can correlate.
As for CMD versus PowerShell: both can read hardware information, and the wmic commands run in either. The difference is scale. For one-off checks, use whatever you are comfortable with. For scripts, reporting, or anything involving more than a handful of machines, use PowerShell. It returns objects you can filter, sort, and export without parsing text.
Common Problems and Fixes
Access denied when running wmic. The command requires elevation. Close the prompt and run as administrator.
Blank output for the BIOS serial. The manufacturer did not populate the field, or the board was replaced. Check the system serial and the baseboard serial as alternatives, then fall back to the physical label.
wmic is not recognized. Your Windows build removed WMIC. Use the Get-CimInstance commands instead; they return the same data.
The serial differs from the sticker. The motherboard was replaced at some point, or the firmware was reflashed. Record both values and note the discrepancy in your inventory.
Get-CimInstance fails with a CIM error. The WMI service may be stopped. Restart it from an elevated prompt with net start winmgmt, then retry.
When the Physical Label Is Still Better
The command line is fast, but the firmware is not infallible. For warranty claims and legal purposes, the physical label remains the authoritative source when it exists. The best practice is to use the commands to build your inventory and to verify a sample against the stickers. If they agree, your data is trustworthy; if they disagree, investigate before you trust either one.
FAQ
Do I need administrator rights for all serial commands? Most return data from a normal account. Access denied means you need to run as administrator for that particular query.
What if my laptop's BIOS serial is blank? Try the system serial and the baseboard serial. Some consumer brands only populate one of the three.
Is WMIC going away? Microsoft deprecated it and removed it from recent Windows versions. New scripts should use PowerShell Get-CimInstance.
Can I find a serial number remotely? Yes, from an elevated prompt you can query remote machines with PowerShell remoting, provided the target is reachable and configured for it.
Why do I see different numbers from different commands? They read different components: the BIOS, the system product, the motherboard, and the processor each carry their own identifier.
What is the fastest way to inventory a whole office? Run the PowerShell script on each machine, or use PowerShell remoting to query them from one management machine. Both take minutes and produce a CSV you can merge.
Can I find the serial number of a device that is powered off? Not from software. For powered-off devices, the physical label or a recorded inventory entry is your only source.
Serial numbers are not an IT mystery; they are just data that lives in the firmware. With a few commands you can read them on demand, and with a short script you can inventory an entire fleet without leaving your desk. The sticker will fade, but the number — and your ability to find it — does not have to.
