LicenseSeat

HWID checker: how to find your hardware ID

Your hardware ID (HWID) is a unique fingerprint that identifies your computer. Here's how to find it on any platform, what it means, and how software developers use it for licensing.

HWID checker: how to find your hardware ID

Every computer has a unique set of hardware identifiers baked into its components. Your CPU has a serial number. Your motherboard has a UUID. Your disk drive has a serial. Your network adapter has a MAC address. Combined, these identifiers form what's known as a hardware ID, or HWID.

Software vendors, game anti-cheat systems, and licensing platforms use HWIDs to tie access to specific machines. When you activate a license key on your computer, the licensing system often records your HWID so that key only works on your hardware. That's node-locked licensing in action.

If you need to find your hardware ID, whether you're troubleshooting a driver, checking a license activation, or building licensing into your own software, here's exactly how to do it on every major platform.

How to check your HWID on Windows

Windows exposes hardware identifiers through several built-in tools. No downloads required.

Using Command Prompt

Open Command Prompt (press Win + R, type cmd, hit Enter) and run the commands below. Note: wmic is deprecated on Windows 11 24H2 and later. If these commands don't work, use the PowerShell alternatives in the next section.

Motherboard UUID (the most common HWID):

wmic csproduct get UUID

CPU serial number:

wmic cpu get ProcessorId

Disk drive serial numbers:

wmic diskdrive get SerialNumber

Motherboard serial number:

wmic baseboard get SerialNumber

MAC addresses (network adapters):

getmac

Using PowerShell

PowerShell gives you more structured output. Open PowerShell and run:

Full system hardware fingerprint:

Get-CimInstance -ClassName Win32_ComputerSystemProduct | Select-Object UUID
Get-CimInstance -ClassName Win32_Processor | Select-Object ProcessorId
Get-CimInstance -ClassName Win32_DiskDrive | Select-Object SerialNumber, Model
Get-CimInstance -ClassName Win32_BaseBoard | Select-Object SerialNumber
Get-NetAdapter | Select-Object Name, MacAddress

All-in-one script (copy and run the whole block):

Write-Host "`nMachine UUID:" -ForegroundColor Cyan
(Get-CimInstance Win32_ComputerSystemProduct).UUID

Write-Host "`nCPU ID:" -ForegroundColor Cyan
(Get-CimInstance Win32_Processor).ProcessorId

Write-Host "`nDisk Serials:" -ForegroundColor Cyan
Get-CimInstance Win32_DiskDrive | ForEach-Object { "$($_.Model): $($_.SerialNumber)" }

Write-Host "`nMotherboard:" -ForegroundColor Cyan
(Get-CimInstance Win32_BaseBoard).SerialNumber

Write-Host "`nMAC Addresses:" -ForegroundColor Cyan
Get-NetAdapter | Where-Object Status -eq 'Up' | ForEach-Object { "$($_.Name): $($_.MacAddress)" }

Using Device Manager

For a graphical approach:

  1. Right-click the Start button and select Device Manager
  2. Expand any hardware category (e.g., Disk drives, Network adapters)
  3. Right-click a device and select Properties
  4. Go to the Details tab
  5. In the Property dropdown, select Hardware Ids

The values shown are the device's hardware identifiers as Windows sees them. These are the identifiers that drivers use to match devices, and they're the same identifiers that licensing systems can use.

How to check your HWID on macOS

macOS stores hardware identifiers through the system_profiler and ioreg commands.

Hardware UUID (the primary machine identifier):

system_profiler SPHardwareDataType | grep "Hardware UUID"

Serial number:

system_profiler SPHardwareDataType | grep "Serial Number"

MAC address:

ifconfig en0 | grep ether

Disk UUID (target a specific partition, not the whole disk):

diskutil info disk0s1 | grep "Disk / Partition UUID"

All hardware info at once:

system_profiler SPHardwareDataType

This outputs your model, chip, serial number, hardware UUID, and provisioning UDID in a single command.

Using System Information (GUI)

Click the Apple menu, hold down Option, and click System Information. The Hardware Overview section shows your Hardware UUID and Serial Number.

How to check your HWID on Linux

Linux exposes hardware identifiers through the /sys filesystem and dmidecode.

Machine ID (distribution-level identifier):

cat /etc/machine-id

Motherboard UUID (requires root):

sudo dmidecode -s system-uuid

CPU info:

cat /proc/cpuinfo | grep "model name\|Serial"

Disk serial numbers:

lsblk --nodeps -o NAME,SERIAL

MAC addresses:

ip link show | grep ether

DMI system information:

sudo dmidecode -t system

This last command outputs the full system identification: manufacturer, product name, version, serial number, UUID, and SKU number.

What HWID components mean

A hardware ID isn't a single value. It's a combination of identifiers from different components. Here's what each one tells you and how stable it is:

Component Identifier Stability Notes
Motherboard UUID System UUID from BIOS/UEFI Very high Survives OS reinstalls. Changes only when motherboard is replaced. Most reliable single identifier.
CPU ID Processor serial/model identifier Very high Identifies the CPU model and stepping. The same across all chips of the same model, so it's best combined with other identifiers. Doesn't change unless you swap processors.
Disk serial Drive manufacturer serial number High Changes when you replace your drive. SSDs and HDDs both have unique serials.
MAC address Network adapter physical address Medium Can be spoofed in software. Changes if you swap network cards. WiFi and Ethernet adapters have separate MACs.
Motherboard serial Board manufacturer serial number Very high Factory-assigned. Almost never changes. Some cheaper boards report generic values.
Machine ID OS-level identifier (Linux) Medium Generated at install time. Changes on OS reinstall. Not tied to hardware.

Which components should you use?

For software licensing, the best approach is combining multiple components into a composite fingerprint. A single identifier is easy to spoof or might change unexpectedly. A combination of CPU ID + motherboard UUID + disk serial creates a fingerprint that's:

  • Stable enough that normal usage doesn't trigger reactivation
  • Unique enough to distinguish individual machines
  • Resistant to casual spoofing (changing one component doesn't bypass the check)

Most licensing platforms hash these combined values into a single device fingerprint string. If too many components change at once (like a full hardware upgrade), the system treats it as a new machine and requires reactivation.

HWID and software licensing

Hardware IDs are the backbone of node-locked licensing, the most common model for desktop apps, games, and plugins. Here's how it works:

  1. A customer purchases your software and receives a license key
  2. When they activate the software, your app collects their HWID (a hash of hardware identifiers)
  3. The HWID is sent to your license server alongside the key
  4. The server records this key-to-device binding
  5. On subsequent launches, the app validates that the current machine's HWID matches the recorded activation

This prevents a single license key from being shared across dozens of machines. You typically allow 2-3 activations per key so customers can use the software on their home and work computers without friction.

Handling hardware changes

The main challenge with HWID-based licensing is hardware upgrades. When a customer replaces their motherboard or swaps their SSD, their HWID changes. If your licensing system treats this as a completely new machine, the customer loses their activation.

Good licensing systems handle this by:

  • Using a fuzzy match — if 3 out of 5 hardware components still match, accept the activation
  • Providing self-service deactivation — customers can release an old device and reactivate on new hardware
  • Setting activation limits, not locks — allow 3 activations instead of exactly 1, so hardware changes don't immediately block access

Collecting HWID in your software

If you're building software that needs HWID-based licensing, here's how to collect hardware identifiers programmatically.

C# (.NET / Unity on Windows)

using System.Management;

string GetHardwareFingerprint()
{
    var cpu = new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor")
        .Get().Cast<ManagementObject>().First()["ProcessorId"].ToString();

    var board = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_BaseBoard")
        .Get().Cast<ManagementObject>().First()["SerialNumber"].ToString();

    var disk = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_DiskDrive")
        .Get().Cast<ManagementObject>().First()["SerialNumber"].ToString();

    var combined = $"{cpu}-{board}-{disk}";
    using var sha = System.Security.Cryptography.SHA256.Create();
    var hash = sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(combined));
    return Convert.ToHexString(hash);
}

Swift (macOS)

import IOKit

func getMachineUUID() -> String? {
    let service = IOServiceGetMatchingService(
        kIOMainPortDefault,
        IOServiceMatching("IOPlatformExpertDevice")
    )
    defer { IOObjectRelease(service) }

    let uuid = IORegistryEntryCreateCFProperty(
        service,
        kIOPlatformUUIDKey as CFString,
        kCFAllocatorDefault, 0
    )?.takeRetainedValue() as? String

    return uuid
}

C++ (Windows / Unreal Engine)

#include <windows.h>
#include <intrin.h>
#include <string>

std::string getCPUID() {
    int cpuInfo[4] = {0};
    __cpuid(cpuInfo, 1);
    char buf[64];
    snprintf(buf, sizeof(buf), "%08X%08X",
             cpuInfo[3], cpuInfo[0]);
    return std::string(buf);
}

Python

import uuid
import hashlib
import platform
import subprocess

def get_hwid():
    mac = uuid.getnode()
    system = platform.node()
    processor = platform.processor()

    combined = f"{mac}-{system}-{processor}"
    return hashlib.sha256(combined.encode()).hexdigest()

Using an SDK instead

Writing hardware fingerprinting code yourself means dealing with edge cases: virtual machines, containers, hardware that reports generic serials, OS permission requirements, and cross-platform inconsistencies.

A licensing SDK like LicenseSeat handles hardware fingerprinting automatically across platforms. Your code calls a single activate() function, and the SDK collects, hashes, and transmits the device fingerprint behind the scenes. No manual WMI queries or platform-specific code.

Common questions about HWID

What does HWID stand for?

HWID stands for Hardware Identification, or Hardware ID. It's a unique identifier derived from your computer's physical components: CPU, motherboard, disk drives, and network adapters.

Can I change my HWID?

Your HWID changes naturally when you replace hardware components. The motherboard UUID changes with a new motherboard, disk serials change with new drives, and MAC addresses change with new network adapters. Some tools claim to "spoof" HWIDs by intercepting system calls or modifying registry values, but these modifications are often temporary or unreliable and don't change the actual physical hardware identifiers.

What is an HWID ban?

Games like Fortnite, Valorant, and Roblox use HWID bans to prevent cheaters from creating new accounts. When you're HWID-banned, the game records your hardware fingerprint and blocks any account that plays from that machine. This is harder to circumvent than an account ban because the ban is tied to your physical hardware, not just a username.

Is my HWID the same as my serial number?

Not exactly. Your serial number is one component of your HWID. A complete HWID typically combines multiple identifiers: motherboard UUID, CPU ID, disk serial, and MAC address. Together, these create a composite fingerprint that's more unique and harder to spoof than any single serial number.

Can someone track me using my HWID?

Your HWID is only accessible to software running on your machine. Websites in a browser cannot read your hardware identifiers directly. Only installed applications with appropriate system permissions can collect HWID data. Software that does collect your HWID should disclose this in their privacy policy.

How do I reset my HWID for a software license?

If you've changed hardware and need to reactivate software, most licensing systems provide a self-service option. You can typically deactivate your old device through a customer portal or by contacting the software vendor, then reactivate on your new hardware. With LicenseSeat, customers manage their own activations through a whitelabeled portal without contacting support.

Does HWID work in virtual machines?

Yes, but with caveats. Virtual machines have their own hardware identifiers, assigned by the hypervisor. These are different from the host machine's HWID. VMs can have their hardware identifiers changed more easily than physical machines, which is why some licensing systems include VM detection as an additional check.

The bottom line

Your hardware ID is a fundamental identifier that ties software licenses, game accounts, and system configurations to specific machines. Whether you need to check your HWID for troubleshooting, verify a license activation, or build hardware-based licensing into your own software, the commands above work on any platform.

For developers building commercial software that needs HWID-based protection, LicenseSeat handles the entire workflow. Hardware fingerprinting, license key validation, activation management, and customer self-service, all through native SDKs for Swift, C#, C++, and JavaScript. Set up in 15 minutes, protect your revenue, and skip the months of building licensing infrastructure yourself.

For a broader overview of licensing approaches, see our complete guide to software licensing. For details on tying licenses to specific devices, read about node-locked licensing.