Move Your Windows 11 Apps with WinGet Export and Import

Moving to a new PC often means remembering dozens of applications before the old machine is reset. WinGet can turn the applications it recognizes into a portable JSON inventory and use that inventory for batch installation on another Windows PC. The useful part is not blind automation: it is having a list that can be inspected, trimmed, transferred, and checked after restoration.

This workflow deliberately does not promise a clone of the old computer. WinGet handles supported application packages; documents, application data, accounts, license keys, certificates, drivers, and most preferences need separate migration plans.

Scope

Platform: Windows 11

Version: 25H2 (OS build 26200)

Utility: Windows Package Manager (WinGet) 1.29.280 stable

The procedure creates an app inventory on a source PC, reviews the resulting JSON, transfers it through a storage method the reader already trusts, imports available packages on a destination PC, and compares the requested identifiers with WinGet’s installed-app listing. Microsoft lists Windows 11 25H2 in the General Availability Channel, while the official WinGet repository identifies 1.29.280 as the latest stable v1.29 release at the time of review.

Prerequisites

Use two Windows 11 25H2 PCs, or one PC before and after a clean installation. Sign in normally so Windows can register App Installer; Microsoft distributes WinGet as part of that system component. Confirm that the source PC has a current package-source index and that the destination PC has working internet access.

Choose a trusted transfer method before resetting or retiring the source PC. The example stores the export under the current user’s Documents folder and expects the transferred file under Downloads on the destination PC. Do not place credentials, license keys, private configuration, or unrelated personal data in the JSON.

Decide whether the destination should receive current available releases or the exact versions installed on the old PC. This guide exports package identifiers without pinning versions, so import normally selects versions currently available from the configured sources. That is usually more practical for a personal migration. A controlled business environment may need a separately maintained and reviewed version policy.

Procedure

On the source PC, open PowerShell as the normal signed-in user. Create a dedicated directory, display the installed WinGet version, refresh package metadata, and export the applications WinGet can identify. These commands do not claim that every installed application will be captured: Microsoft says matching depends on metadata in both the configured source and Windows’ installed-program records.

$ExportDir = Join-Path (Join-Path $env:USERPROFILE 'Documents') 'WinGetMigration'
$ExportFile = Join-Path $ExportDir 'apps.json'
New-Item -ItemType Directory -Path $ExportDir -Force | Out-Null
winget --version
winget source update
winget export --output $ExportFile

The first output should identify WinGet v1.29.280 for this exact workflow. If another version appears, consult that version’s documentation and release notes before continuing because available options and JSON behavior can change. Read any export warnings; they are a migration checklist, not harmless noise. An unmatched program needs a separate reinstall plan.

Review the JSON before transferring it. The following read-only inspection prints each package identifier grouped under the sources in the export file. It also leaves the original file unchanged.

$ExportDir = Join-Path (Join-Path $env:USERPROFILE 'Documents') 'WinGetMigration'
$ExportFile = Join-Path $ExportDir 'apps.json'
$Inventory = Get-Content -LiteralPath $ExportFile -Raw | ConvertFrom-Json
$Inventory.Sources | ForEach-Object { $_.Packages } | Select-Object PackageIdentifier

Open the JSON in a text editor if unwanted applications need to be removed. Keep valid JSON syntax: deleting an entry carelessly can leave a trailing comma or an incomplete object. Preserve an untouched copy until the destination has been checked.

Transfer only the reviewed apps.json file through a trusted removable drive, local transfer, or already-configured encrypted storage service. On the destination PC, place it in Downloads. Do not erase the source PC merely because the file transferred successfully; first confirm that the separate data backup is readable and that important applications appear in the inventory or in written exception notes.

On the destination PC, open PowerShell as the normal signed-in user. Confirm that the file exists and parses as JSON before changing package state.

$ImportFile = Join-Path (Join-Path $env:USERPROFILE 'Downloads') 'apps.json'
Test-Path -LiteralPath $ImportFile
Get-Content -LiteralPath $ImportFile -Raw | ConvertFrom-Json | Out-Null

Continue only when the first command returns True and JSON conversion produces no error. Refresh WinGet’s sources, then import. The options below continue past packages that are no longer available and request currently available versions rather than versions that might be recorded in a modified inventory. Package and source agreement flags are intentionally omitted so WinGet can present applicable terms instead of accepting them silently.

$ImportFile = Join-Path (Join-Path $env:USERPROFILE 'Downloads') 'apps.json'
winget source update
winget import --import-file $ImportFile --ignore-unavailable --ignore-versions

Microsoft documents that import attempts the requested installations serially and reports when an application is unavailable or already installed. Watch the output and retain the names or identifiers of failures. An import that reaches its final line is not proof that every application, setting, or data file migrated.

Verification and expected outcome

Use the transferred inventory as the expected set and compare its identifiers with the destination PC’s installed-package output. WinGet 1.29 improved redirected list output so columns are not truncated merely because output is captured in a variable.

$ImportFile = Join-Path (Join-Path $env:USERPROFILE 'Downloads') 'apps.json'
$Inventory = Get-Content -LiteralPath $ImportFile -Raw | ConvertFrom-Json
$ExpectedIds = $Inventory.Sources | ForEach-Object { $_.Packages } | ForEach-Object { $_.PackageIdentifier } | Sort-Object -Unique
$InstalledRows = winget list
$ExpectedIds | ForEach-Object {
    [pscustomobject]@{
        PackageIdentifier = $_
        Listed = [bool]($InstalledRows -match [regex]::Escape($_))
    }
} | Format-Table -AutoSize

Expected outcome: Every intended, supported package identifier appears with Listed set to True; identifiers marked False correspond to packages that need review, a different installer, or a source-availability check.

This check confirms package recognition, not application health or restored user data. Open critical applications individually, confirm their publisher and version, sign in through the application’s normal interface, and restore data only from the separate trusted backup.

Cautions

Import launches third-party package installers and can request administrator elevation. Read publisher information, license prompts, and installer dialogs rather than treating the JSON as an authority. Remove packages you do not recognize before import. On a managed work or school PC, follow organizational deployment policy instead of importing a personal inventory.

The export can omit applications that WinGet cannot match. It also does not preserve documents, most application preferences, browser state, local databases, credentials, certificates, VPN profiles, specialized drivers, or license entitlements. Keep those items out of the package JSON and migrate them through separate trusted procedures.

The v1.29 release can preserve previously stored custom or override installer arguments in an export/import round trip. That can be useful, but it also makes review important: inspect the exported package entries before moving them to a different machine, particularly when the old device had unusual install locations or organization-specific switches.

Rollback or removal

WinGet import is a series of package installations, not a single reversible transaction. If an imported application is unwanted, close it and remove it individually from Settings > Apps > Installed apps after confirming its name and publisher. For an application with important local data, use its documented export or backup function before removal.

Do not reset the destination PC as a first response to one failed package. Record the failed identifier, review WinGet’s message, and either retry that package through its trusted source or use the publisher’s official installer. Keep the reviewed JSON and exception notes until critical applications and data have been confirmed. Delete extra transferred copies of the inventory afterward if they are no longer needed; although the normal file should contain package identifiers rather than secrets, minimizing stale migration artifacts reduces confusion during the next rebuild.

The practical result is a bounded migration aid: WinGet handles repeatable application installation, while the reader retains control over selection, agreements, unsupported software, data restoration, and final verification.