PowerShell: Windows – Inventory Installed Software Across a Domain

.\Get-SoftwareInventory.ps1 -ComputerName SRV-APP01, SRV-APP02, SRV-SQL01

.\Get-SoftwareInventory.ps1 -ComputerListPath C:\Lists\workstations.txt -OutputPath C:\Reports\software-inventory.csv

$computers = Get-ADComputer -Filter 'Enabled -eq $true' | Select-Object -ExpandProperty Name
.\Get-SoftwareInventory.ps1 -ComputerName $computers -ThrottleLimit 64

Querying 3 computer(s) with a throttle limit of 32 ...
Completed SRV-APP01 (231 entries)
Completed SRV-APP02 (187 entries)
WARNING: Failed SRV-SQL01: Connecting to remote server SRV-SQL01 failed with the following error message : WinRM cannot process the request...
Inventory written to .\software-inventory.csv (418 rows from 2 of 3 computers)
WARNING: Unreachable or failed computers: SRV-SQL01

Import-Csv -Path .\software-inventory.csv |
    Where-Object { $_.DisplayName -like "*Java*" } |
    Sort-Object -Property ComputerName |
    Format-Table ComputerName, DisplayName, DisplayVersion, Scope -AutoSize

<#
.SYNOPSIS
    Remotely enumerates installed software from the registry across a list of
    Windows computers and consolidates the results into one CSV.
.DESCRIPTION
    Reads the 64-bit and 32-bit (WOW6432Node) Uninstall keys under HKLM, plus the
    Uninstall key of every user hive currently loaded under HKEY_USERS, on each target
    over PowerShell remoting. One Invoke-Command call fans out to all computers; each
    computer runs as a child job, so failures are reported per computer. Never queries
    Win32_Product.
.PARAMETER ComputerName
    One or more computer names to inventory.
.PARAMETER ComputerListPath
    Path to a text file with one computer name per line, used when -ComputerName
    is not supplied.
.PARAMETER OutputPath
    Path to the consolidated CSV. Defaults to .\software-inventory.csv.
.PARAMETER ThrottleLimit
    Maximum number of concurrent remote connections. Defaults to 32.
.EXAMPLE
    .\Get-SoftwareInventory.ps1 -ComputerListPath C:\Lists\workstations.txt
.NOTES
    Author  : Thomas Lasswell (https://www.techcolumnist.com)
    Version : 1.0 (2025-08-27)
    Requires: PowerShell remoting (WinRM) on every target; Administrators or
              Remote Management Users membership on each target
#>
[CmdletBinding()]
param(
    [string[]]$ComputerName,

    [string]$ComputerListPath,

    [string]$OutputPath = ".\software-inventory.csv",

    [int]$ThrottleLimit = 32
)

if (-not $ComputerName) {
    if (-not $ComputerListPath -or -not (Test-Path -Path $ComputerListPath)) {
        throw "Supply -ComputerName or a valid -ComputerListPath."
    }

    $ComputerName = Get-Content -Path $ComputerListPath | Where-Object { $_.Trim() -ne "" } | ForEach-Object { $_.Trim() }
}

$ComputerName = @($ComputerName | Sort-Object -Unique)
if ($ComputerName.Count -eq 0) {
    throw "No computer names to query. Check -ComputerName or the contents of -ComputerListPath."
}
Write-Host "Querying $($ComputerName.Count) computer(s) with a throttle limit of $ThrottleLimit ..."

# The script block that runs on each remote computer.
$inventoryScript = {
    $sources = @(
        @{ Scope = "Machine64"; Path = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" },
        @{ Scope = "Machine32"; Path = "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" },
        @{ Scope = "User"; Path = "Registry::HKEY_USERS\*\Software\Microsoft\Windows\CurrentVersion\Uninstall\*" }
    )

    foreach ($source in $sources) {
        Get-ItemProperty -Path $source.Path -ErrorAction SilentlyContinue |
            Where-Object { $_.DisplayName } |
            ForEach-Object {
                [pscustomobject]@{
                    ComputerName    = $env:COMPUTERNAME
                    Scope           = $source.Scope
                    DisplayName     = $_.DisplayName
                    DisplayVersion  = $_.DisplayVersion
                    Publisher       = $_.Publisher
                    InstallDate     = $_.InstallDate
                    SystemComponent = $_.SystemComponent
                    KeyName         = $_.PSChildName
                }
            }
    }
}

$parentJob = Invoke-Command -ComputerName $ComputerName -ScriptBlock $inventoryScript -AsJob -ThrottleLimit $ThrottleLimit
$parentJob | Wait-Job | Out-Null

$results = New-Object System.Collections.Generic.List[object]
$failures = New-Object System.Collections.Generic.List[string]

# One child job per computer: read each separately so one failure doesn't hide the rest.
foreach ($child in $parentJob.ChildJobs) {
    $target = $child.Location

    if ($child.State -eq "Failed") {
        $reason = $child.JobStateInfo.Reason.Message
        $failures.Add($target)
        Write-Warning "Failed $target`: $reason"
        continue
    }

    $rows = @(Receive-Job -Job $child -ErrorAction SilentlyContinue |
        Select-Object -Property ComputerName, Scope, DisplayName, DisplayVersion, Publisher, InstallDate, SystemComponent, KeyName)
    $results.AddRange([object[]]$rows)
    Write-Host "Completed $target ($($rows.Count) entries)"
}

Remove-Job -Job $parentJob -Force

$results | Export-Csv -Path $OutputPath -NoTypeInformation

$succeeded = $ComputerName.Count - $failures.Count
Write-Host "Inventory written to $OutputPath ($($results.Count) rows from $succeeded of $($ComputerName.Count) computers)"

if ($failures.Count -gt 0) {
    Write-Warning "Unreachable or failed computers: $($failures -join ', ')"
}