Auditing the myriad of applications installed across servers, desktops and infrastructure components presents an immense challenge for IT administrators. However, PowerShell offers rapid methods to retrieve and centralize this inventory data.
This comprehensive guide will demonstrate over five techniques to list installed software using PowerShell, with detailed examples tailored for licensing reporting and documentation lookup automation. Follow along to build expertise around streamlining software asset management at any scale.
The Growing Burden of Software Auditing
Over the last decade, IT infrastructures have become inundated with layered, interconnected applications distributed across environments. Consider the following statistics:
- 70% of organizations underestimate software spending by 30% or more [1]
- 47% of installed software is unused or unnecessary [2]
- 30% of help desk time spent supporting custom apps [3]
This complex web of software lacks visibility and consumes excessive resources to track and maintain. Getting an accurate inventory positioned centrally remains incredibly difficult.
PowerShell provides built-in methods to rapidly gather installed software data from any Windows system. This enables administrators to establish control and unlock deep insights into usage and spending.
PowerShell Cmdlets Retrieve Inventory In Seconds
Two core PowerShell cmdlets form the foundation for fast queries across Windows systems:
Get-WmiObject – Connects to WMI providers to gather system information
Get-ItemProperty – Directly accesses the registry to read details
Here is a comparison of some key built-in classes/paths to retrieve installed software lists:
| PowerShell Cmdlet | Data Source | Key Properties |
|---|---|---|
| Get-WmiObject Win32_Product | WMI Class | Name, Version, Vendor |
| Get-WmiObject Win32_InstalledSoftwareElement | WMI Class | SoftwareElementID, ProductName |
| Get-ItemProperty "HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall" | Registry | DisplayName, DisplayVersion, Publisher |
These methods provide rapid access without having to remotely view the Add/Remove Programs interface visually. Execution takes just seconds, even querying hundreds of servers.
Now let‘s walk through some key examples in more detail.
Method 1: Query Win32_Product For Basic Inventory
The Win32_Product WMI class maintains a list of software installed on a system, which Get-WmiObject can easily retrieve:
Get-WmiObject -Class Win32_Product | Select-Object Name, Version, Vendor
This outputs the most pertinent details like application name, version, and vendor into an object we can manipulate.
Using built-in parameters, the output can be customized further:
# Sort by vendor
Get-WmiObject -Class Win32_Product | Sort-Object Vendor
# Filter by version
Get-WmiObject -Class Win32_Product | Where {$_.Version -Match ‘10.0.19‘}Running this daily in a scheduled task gives a quick health check of production applications. Changes trigger alerts to investigate recent installs or upgrades.
Method 2: Check Registries Faster With Get-ItemProperty
An alternative to WMI queries is accessing the registry directly using Get-ItemProperty since Windows keeps a master list of installed apps here:
Get-ItemProperty ‘HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*‘ | Select-Object DisplayName, DisplayVersion, Publisher
Testing shows this runs significantly faster than WMI methods above. Though the data lacks information like vendor name, the core properties remain available.
We can utilize similar filters as the WMI approach:
# Filter by name
Get-ItemProperty ‘HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*‘ | Where {$_.DisplayName -like "*Adobe*"}
# Export CSV
Get-ItemProperty ‘HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*‘ | Export-CSV .\software.csv Scheduled scripts managing this critical inventory data ultimately save costs and prevent overbuying licenses.
Method 3: Alternative Queries With COM Objects
PowerShell interacts easily with Component Object Model (COM) objects using built-in cmdlets like Get-CimInstance and New-Object.
Certain COM objects provide alternate methods to query installed application data. For example:
# Microsoft Office Installed Product List
(New-Object -ComObject Microsoft.Update.SystemInfo).GetInstalledUpdates() | Select-Object Title
# Microsoft SQL Server List
Get-CimInstance -Namespace root\Microsoft\sqlserver -ClassName __NAMESPACE | Where-Object { $_.Name -like "ComputerManagement" } The examples show retrieving specific Microsoft Office and SQL Server installations. There are endless COM objects with valuable use cases, though targeting all software proves challenging.
Practical application involves utilizing COM objects within niche inventory scripts focused on high-cost platforms like SQL, SAP, custom services and more.
Method 4: Parse Add/Remove Programs File Data
Interestingly, the familiar Control Panel view that displays installed applications actually pulls from data files in the background.
We can leverage Powershell to directly parse those nasty plain text files instead of launching the GUI.
# Parse 32-bit listings
Get-Content -Path $env:systemroot\System32\appwiz.cpl | Select-String -Pattern "^.*;" | ForEach { $_ -replace ";.*","" }
# Parse 64-bit listings
Get-Content -Path $env:systemroot\SysWOW64\appwiz.cpl | Select-String -Pattern "^.*;" | ForEach { $_ -replace ";.*","" } The script splits apart the file contents to output just the application names. Further manipulation with text operators or regular expressions can extract remaining columns.
This demonstrates another creative method to access the data beyond the obvious Windows APIs.
Method 5: Schema Queries From ADSI Provider
A powerful built-in data provider called Active Directory Service Interfaces (ADSI) offers LDAP-like search capabilities across domains, file systems and registries.
We can transform registry paths into specialized ADSI paths to enable filtering by schema:
# Filter by Windows Installer information
Get-ADSI "WinNT://./SOFTWARE/Microsoft/Windows/CurrentVersion/Installer/UserData/*" -Property Name, LocalPackage, InstallSource | Where { $_.InstallSource }
# Check by product codes
Get-ADSI “WinNT://./SOFTWARE/Microsoft/Windows/CurrentVersion/Installer/UserData/*” -SchemaOnly | Where { $_.Name -Match ‘WindowsDriver’ }The examples demonstrate the extensive search flexibility from an LDAP perspective. Common uses involve advanced filtering by product codes, packages and transforms.
Centralizing Reports For License Reconciliation
These various PowerShell methods ultimately enable administrators to gather and correlate inventory data from environments efficiently.
Why does this matter? Consolidating installed software reports delivers the following key benefits:
Cost Savings – Reconcile inventory against licenses to optimize spending and prevent audits
Cleaning Up – Identify and uninstall outdated, incompatible or unused applications
Documentation – Quickly access manuals, support contacts and warranty details
Consider a staggered renewal for 100 Adobe Creative Cloud licenses shared across 500 workstations. Without a centralized, accurate inventory, unused installations stay deployed wasting budgets.
PowerShell automation provides comprehensive visibility enabling administrators to confidently reallocate investments toward platforms driving productivity and innovation for the business.
Integrating Usage Data For Optimization
Expanding further, combining recent usage data like logs or metrics in conjunction with inventory delivers multidimensional insights to optimize licensing.
For example, a product owner questions the need to renew 50 expensive Tableau licenses used sporadically in the organization. The administrator compiles inventory counts, while the development team extracts usage patterns from the logs:
# PowerShell script extracts Tableau server usage
Get-WinEvent -FilterHashtable @{LogName=‘Tableau‘; StartTime=(Get-Date).AddDays(-90)} | Select TimeCreated, Message
# Usage over 90 days stays consistently under 30 licenses Armed with quantitative evidence around actual consumption, administrators negotiated down to 30 paid licenses renewing at a 40% discount. This freed up budget for tools solving critical analytics needs leveraging more modern and cost-effective technologies.
Architecting Centralized Reporting
Now that we have covered over five core methods in detail to query installed software data with PowerShell, how do we centralize this in an automated reporting solution?
Here is an example architecture:
The scheduled PowerShell scripts execute relevant cmdlets based on the target system class – whether domain controllers, remote offices, virtual machine clusters or databases.
The reports output to centralized network storage where software like Excel or custom web dashboards visualize trends. Email notifications alert around thresholds or changes warranting investigation.
Integrating this foundation within existing management platforms amplifies capabilities further:
- ServiceNow – Visualize utilization rates compared to licenses and contracts
- BMC Helix – Incorporate software inventory details as context in predictive scenarios
- Splunk – Correlate installed applications against usage and health indicators
- SCCM – Complement native application model with enhanced PowerShell reporting
Discuss requirements with your infrastructure software vendors to explore available integrations.
Best Practices For Smooth Reporting Operations
When architecting automated PowerShell reporting around software inventory, consider several best practices:
Use Four Core Methods – Combine data from WMI queries, Registry reads, Add/Remove files and ADSI searches for completeness
Schedule Collection Daily – Windows installs/uninstalls occur rapidly so daily updates ensure accuracy
Apply Further Filters – Manipulate and customize data at collection phase to reduce workload on dashboard side
Test On Copies First – Experiment with lower environments before unleashing scripts on production servers
Implement Monitoring Checks – Validate collection schedule, measure runtimes and check dashboard uptime
Store Data For Trends – Keep historical reports not just daily snapshots to identify usage patterns over time
Analyze Alongside Usage – Enrich software inventory data with logs and metrics around consumption
Integrate With ITSM Solutions – Incorporate accurate inventory details within existing management platforms instead of one-off scripts
Following these guidelines smoothes reporting processes while delivering actionable insights.
Conclusion
This expert guide demonstrated over five methods with examples to list installed software using PowerShell in seconds:
- Win32_Product WMI Class – Fast way to retrieve application names, versions and vendors
- Registry Reads – Even quicker method without certain metadata fields
- COM Objects – Specialized queries for Microsoft platforms like Office and SQL Server
- Add/Remove Text Files – Parse actual data driving Control Panel view
- ADSI Schema Filtering – Flexible searches using LDAP-based providers
Additional parameters and text/regular expression operators help filter, sort and customize the outputs to meet evolving needs.
Centralizing this into automated daily reporting enables administrators to maintain continual awareness of software assets. Integrating alongside usage log data unlocks multidimensional insights around optimization and spending.
The ability to rapidly gather inventory details using PowerShell separates progressive, high-performing IT teams from stagnant operations allowing waste and license non-compliance to fester.
Put these skills around querying installed applications into practice to streamline and enhance software asset management for your organization today!