Daily Tech Dispatch

PC Troubleshooting

Check Windows Update History: 5 Methods (Win 11/10)

Learn 5 ways to check Windows Update history. Use GUI, PowerShell, and Event Viewer to view installed patches. Troubleshoot missing updates.

You click "Check for updates," see the spinner, and then wonder: What actually got installed? More often than not, the user-facing dashboard gives you a vague sense of activity, but not the specific KB numbers or timestamps needed for troubleshooting or compliance audits. I’ve spent the last 15 years working with systems where a missing KB number meant a failed deployment or a security gap, so I know the frustration when the standard "Update history" tab looks empty or inconsistent.

The confusion usually stems from a mismatch between what Microsoft displays in the Settings app and what actually exists in the underlying system logs. Sometimes, an update installs but doesn't show up in the UI until a reboot or a service restart. In other cases, the SoftwareDistribution folder gets corrupted, wiping out the visual record entirely.

This guide moves beyond the basic click-path. We are going to compare the graphical interface with the command line and raw log files. Whether you are an IT admin trying to export data for a security report or a home user chasing a bug that appeared after Tuesday’s patch, here is how to actually verify what happened on your machine.

Minimalist close-up of ChatGPT interface displayed on a dark monitor screen, highlighting AI technology.

Method 1: View Update History via Windows Settings (GUI)

The most intuitive way to view Windows update history is through the Settings app. It’s fast, requires no command line knowledge, and covers 90% of user needs. However, navigation differs slightly between Windows 11 and Windows 10, which trips up a lot of users who switch operating systems frequently.

Windows 11 & 10 Navigation Path

On Windows 11, the path is straightforward but deeply nested. Start by hitting the Windows key + I shortcut to open Settings directly. Navigate to Windows Update on the left sidebar, then click on Update history near the bottom. You’ll see two distinct sections: "Install history" and "Feature updates."

The Install history tab lists quality updates, security patches, and driver updates by date. This is your go-to for quick checks. For instance, if your app crashes only after a specific patch, you can look up the date of the crash and cross-reference it with the list here. Note that this view is accessible to standard users; you don’t need admin rights just to read the list.

On Windows 10, the journey is slightly different. Open Settings, scroll down to Update & Security, select Windows Update, and then click the link labeled View update history. The interface feels a bit more legacy, but the data source is the same. The key difference in UX is that Windows 10 often requires you to wait a few seconds longer for the list to populate, especially on slower mechanical hard drives.

Control Panel Legacy Method

If the Settings app feels sluggish or you’re working on a domain-joined machine where policy blocks the modern UI, the Control Panel remains a reliable fallback. Press Win + R, type appwiz.cpl, and hit Enter. In the left pane, click View installed updates.

This view is granular but less intuitive. It lists updates by KB number and installation date but doesn’t group them by monthly release cycles as cleanly as the modern Settings app. I recommend this method primarily when you need to uninstall a specific, problematic update that the newer interface hides behind a "Restore" button. For simple historical browsing, stick to Settings. It’s cleaner and less prone to policy interference.

Bold 'UPDATE' text written in chalk on a blackboard. Perfect for concepts of change and communication.

Method 2: Automate Checks with PowerShell Commands

When you need to script checks across multiple machines or export data for analysis, the GUI falls short. This is where PowerShell shines. It’s not just about running a command; it’s about getting structured data (JSON/CSV) that you can actually do something with.

Using Get-HotFix for Basic Tracking

The Get-HotFix cmdlet is the workhorse for basic tracking. Open PowerShell and run:

Get-HotFix -LocalInstalled | Sort-Object InstallDate -Descending

This returns a table of installed hotfixes. The columns are straightforward:

  • HotFixID: This is the KB number (e.g., KB5034441). This is the identifier you will use in Microsoft’s support documentation.
  • Description: A brief text summary of the patch.
  • InstalledBy: The user account that installed the update. Useful in shared environments.
  • InstallDate: The timestamp.

In my experience, Get-HotFix is fast because it queries the registry directly rather than parsing log files. However, it only shows installed items. It won’t tell you about failed downloads or pending reboots. Think of it as the "receipt" for what is currently on your system.

Advanced: Get-WindowsUpdateLog & Exporting to CSV

For deeper insight, specifically for troubleshooting why an update failed or downloaded, you need the full Windows Update Log. Microsoft provides the Get-WindowsUpdateLog cmdlet for this.

To generate a readable log file, run:

Get-WindowsUpdateLog -LogFile C:\Logs\update.log

This consolidates the raw ETL (Event Trace Log) files into a single, human-readable .log text file. If you need to export the history programmatically, such as for a compliance dashboard, you can query the Windows Update history via the COM object and convert it to CSV:


$Session = New-Object -ComObject "Microsoft.Update.Session"
$Searcher = $Session.CreateUpdateSearcher()
$historyCount = $Searcher.GetTotalHistoryCount()

if ($historyCount -gt 0) {
    $Searcher.QueryHistory(0, $historyCount) | 
    Select-Object Title, Date, ResultCode, @{name="Status"; expression={
        switch($_.ResultCode) {
            0 {"Success"}
            1 {"Success, but reboot required"}
            2 {"Downloaded, but not installed"}
            4 {"Ignored"}
            5 {"Hidden"}
            6 {"Needed"}
            7 {"In progress"}
            8 {"On hold"}
            9 {"Error: 80091007 - User cancelled"}
            10 {"Error: 80091008 - No updates found"}
            11 {"Error: 8009100F - Scan not started"}
            12 {"Error: 80240010 - Scan failed"}
            13 {"Error: 80240011 - Download failed"}
            14 {"Error: 80070001 - Installation failed"}
            default {"Unknown"}
        }
    }} | 
    Export-Csv -Path C:\Logs\update_history.csv -NoTypeInformation
}

This script is invaluable for IT admins. It captures the ResultCode, which the GUI completely hides. If an update shows as "failed" in the UI but the log says "Downloaded, but not installed," you know the issue is likely a pending reboot or a blocked service, not a download problem.

Method 3: Deep Dive into Windows Update Log Files

Sometimes, the tools above aren’t enough. You need to look at the raw data where Windows Update actually records its actions. This is the forensic approach.

Locating the SoftwareDistribution Folder

The primary storage location for Windows Update metadata is the SoftwareDistribution folder. Specifically, the log file is located at:

C:\Windows\SoftwareDistribution\DataStore\Logs\WindowsUpdate.log

Note: In recent builds of Windows 10/11, the log is often stored in ETL format rather than plain text. You may need to use the Get-WindowsUpdateLog command mentioned earlier to convert it for reading.

Accessing these files requires administrator privileges. Right-click your text editor (Notepad) and select "Run as administrator," then navigate to the path above. If the file is locked, the Windows Update service might be running. You can stop the service temporarily using net stop wuauserv in an admin prompt, but do so at your own risk and restart it immediately after reading.

The difference between the .log and .etl formats is significant. .etl files are binary, efficient, and meant for machine parsing. .log files are text-based, human-readable, and meant for debugging. If you are trying to understand why a specific update stalled at 99%, the .log file is your friend.

Interpreting Entries: KB Numbers & Timestamps

Reading a raw Windows Update log is like reading a flight recorder for your computer. It’s dense. Here’s how to break it down:

  1. Timestamps: The log is chronological. Look for large gaps in time. A jump from 10:00:00 to 10:45:00 with no entries usually means the system was idle, or the update process was waiting for a trigger (like a scheduled install time).
  2. Component Names: You’ll see terms like AGENT, HANDLER, and DOWNLOAD.
    • AGENT: The main service handling the update.
    • HANDLER: The installer engine. If you see errors here, the installation itself failed.
    • DOWNLOAD: Network-related errors will show up here.
  3. Status Flags: Search for the string Failed. This will highlight all lines where an error occurred. Follow the timestamp of that failure back a few lines to see what was being processed. You’ll often find the specific KB number or Update ID (a GUID) associated with the failure.

I’ve found that using a text editor with "Word Wrap" disabled makes it much easier to scan these logs horizontally. It’s not pretty, but it tells the truth.

Method 4: Using Event Viewer for System Audit

If the logs are too verbose or you need to correlate updates with other system events (like service crashes), Event Viewer is the bridge. It’s not the primary source for update history, but it provides the context that logs often miss.

Navigating the System Log

Open Event Viewer (eventvwr.msc). Navigate to Windows Logs > System. This is a large feed, so you need to filter it.

Right-click on the "System" log and select Filter Current Log…. In the "Sources" field, add:

  • Microsoft-Windows-WindowsUpdateClient
  • Microsoft-Windows-WMI

Now, look for specific Event IDs:

  • Event ID 19: Usually indicates that Windows Update was started.
  • Event ID 20: Often indicates that an update was successfully installed.
  • Event ID 19/20 with Errors: If you see these IDs with a severity of "Error," it means the update process itself failed at the service level.

This method is particularly useful for detecting "silent" failures. For example, you might see no updates in the Settings app because the UI cache is stuck, but Event Viewer will show a clear error code (like 0x80070056, an unknown error) at the exact time the update should have run. I use this to validate whether a "missing" update in the GUI is actually missing or just not displayed. It’s a quick sanity check that requires no script writing.

Troubleshooting: Why is Windows Update History Missing?

You’ve tried Settings, you’ve run PowerShell, and you get nothing. Or, the list stops at three months ago, even though you know you’ve been patching. This is a common issue, and it’s rarely catastrophic. It’s usually a data integrity problem.

Common Causes & Fixes

1. The "History" Reset After Major Feature Updates Microsoft occasionally clears the visual update history when you install a major feature update (like moving from 22H2 to 23H2). This is by design in some enterprise environments to reset the baseline, though it’s annoying for tracking. If your history vanished right after a big upgrade, you likely won’t get it back in the GUI. You have to rely on the logs or Event Viewer for the past, and the new history will start fresh.

2. Corrupt SoftwareDistribution Folder This is the most frequent cause of persistent missing history. If the cache database gets corrupt, the UI can’t read it.

  • The Fix:
    1. Open Services (services.msc).
    2. Stop Windows Update and WMI Provider Host.
    3. Navigate to C:\Windows\SoftwareDistribution.
    4. Rename the folder to SoftwareDistribution.old (don’t delete it yet).
    5. Start the services.
    6. Windows will recreate the folder and re-sync with the server.

3. Registry Permission Issues On managed systems, Group Policy might restrict who can view the history, even if the updates are installed. Check if the "Windows Update" policy in your local Group Policy Editor (gpedit.msc) has any restrictions on reporting or installation. Usually, this isn’t the issue for home users, but for IT admins, it’s the first place to look if a batch of machines all "lost" their history simultaneously.

If these steps don’t work, run the built-in Windows Update Troubleshooter (Settings > System > Recovery > Troubleshoot > Additional troubleshooters). It’s less sophisticated than a manual reset, but it catches basic service mismatches that often hide in plain sight.

Quick Comparison: UI vs. CLI vs. Log Files

Choosing the right method depends on your goal. Are you a user trying to remember if a specific security patch is on? Or are you an auditor needing a timestamped CSV report?

MethodDifficultyDetail LevelBest ForData Format
Settings (GUI)LowLowQuick casual checksVisual List
Control PanelLowMediumUninstalling specific KBsVisual List
PowerShellMediumHighScripting & AuditingText / CSV / JSON
Event ViewerMediumHighCorrelating failuresEvent Log
Raw LogsHighVery HighForensic debuggingText / ETL
My Recommendation:
  • For Beginners: Stick to Settings. It’s safe and fast.
  • For IT Professionals: Master PowerShell. It’s the only way to automate compliance checks across 500 PCs.
  • For Troubleshooters: Use Event Viewer + Raw Logs. The GUI will lie to you if the cache is corrupt; the logs won’t.

FAQ

How do I check Windows Update history on Windows 11? The path is Settings > Windows Update > Update history. It’s visually similar to Windows 10 but with the updated Fluent UI design. The data source is identical, so if you’re comfortable with the Win 10 path, you’ll be fine.

Can I view Windows Update history without admin rights? Yes. The GUI method in Settings and the basic Get-HotFix PowerShell command do not require elevation. However, writing log files to the C:\Windows directory or resetting the SoftwareDistribution folder does require administrator privileges.

What is the default file location for Windows Update history logs? The primary log is at C:\Windows\SoftwareDistribution\DataStore\Logs\WindowsUpdate.log. In older versions of Windows 10, it might be at C:\Windows\WindowsUpdate.log. Note that modern systems often use .etl files that need conversion.

Why is my Windows Update history empty or missing? This usually happens after a major feature update or if the SoftwareDistribution cache is corrupt. It does not mean updates are no longer installing; it just means the visual record was cleared or failed to write. Run the Windows Update Troubleshooter or rename the SoftwareDistribution folder to reset it.

Conclusion

There is no single "correct" way to check Windows update history; there is only the right tool for the specific job. For the vast majority of users, the Settings app is sufficient and should be your first stop. But if you are managing a fleet of devices, investigating a stubborn bug, or preparing for a compliance audit, you need to move beyond the GUI.

PowerShell gives you the structure; raw logs give you the truth. I strongly recommend keeping a simple PowerShell script on your system that exports the last 30 days of update history to a CSV file. It takes 30 seconds to write and will save you hours when that "ghost" bug appears and you need to prove which patch caused it.

If you’re looking for the next step after auditing your history, check out our guide on Rolling back Windows Updates when a patch causes trouble. Knowing how to check your history is half the battle; knowing how to undo it is the other half.

Back to Home