Saber quais programas estão instalados em um computador parece uma tarefa simples. Basta abrir Configurações → Aplicativos → Aplicativos instalados e consultar a lista.

Mas existe uma diferença importante entre visualizar os aplicativos instalados e criar um inventário técnico dos softwares existentes no Windows 11.

Imagine que você precise descobrir:

• nome do programa;
• versão instalada;
• fabricante;
• arquitetura;
• local de instalação;
• comando de desinstalação;
• data registrada da instalação;
• aplicativos instalados apenas para determinado usuário;
• programas de 32 bits;
• programas de 64 bits;
• aplicativos instalados pela Microsoft Store.

Talvez você também queira salvar tudo em:

TXT

ou:

CSV

para abrir posteriormente no Excel.

Esse tipo de relatório é útil antes de:

• formatar um computador;
• substituir um SSD;
• migrar para outro PC;
• fazer manutenção;
• comparar duas máquinas;
• verificar softwares antigos;
• documentar um computador empresarial;
• identificar programas esquecidos;
• preparar uma reinstalação do Windows.

Neste tutorial, vamos aprender diferentes maneiras de criar esse relatório utilizando principalmente ferramentas que já fazem parte do Windows 11.

Entre elas:

Configurações
PowerShell
Registro do Windows
winget

Também vamos entender uma questão importante:

por que duas ferramentas podem apresentar quantidades diferentes de programas instalados?

---

O Windows não possui apenas uma lista universal de programas

Esse é o primeiro conceito que precisamos entender.

Quando instalamos softwares no Windows, eles podem ser registrados de maneiras diferentes.

Um instalador tradicional pode criar informações no Registro.

Um aplicativo da Microsoft Store utiliza outro mecanismo.

Alguns programas são instalados para:

todos os usuários

enquanto outros ficam disponíveis somente para:

um usuário específico

Também existem diferenças entre softwares:

32 bits

e:

64 bits

Por isso, um comando pode encontrar 85 entradas enquanto outro encontra 92.

Isso não significa necessariamente que um deles esteja errado.

Talvez estejam consultando fontes diferentes.

---

O que significa “programa instalado”?

Até essa definição merece atenção.

Imagine um programa portátil.

Você baixa:

Ferramenta.zip

extrai para:

C:\Ferramentas\Programa

e executa:

Programa.exe

Ele funciona normalmente.

Mas nunca passou por um instalador.

Talvez não exista entrada correspondente em:

Aplicativos instalados

nem nas chaves tradicionais de desinstalação do Registro.

Tecnicamente existe um software no computador, mas ele pode não aparecer como um programa instalado.

Isso significa que nenhum método baseado somente no inventário de instalação consegue localizar absolutamente todos os executáveis existentes no disco.

---

Método 1 — Consultar Aplicativos Instalados

O método mais simples é abrir:

Configurações
→ Aplicativos
→ Aplicativos instalados

Aqui encontramos uma lista amigável dos aplicativos conhecidos pelo Windows.

Podemos pesquisar pelo nome e, dependendo do item, visualizar informações como:

• nome;
• tamanho;
• versão;
• opções;
• desinstalação.

Para uma consulta rápida, isso normalmente é suficiente.

Mas se precisamos produzir um relatório com dezenas ou centenas de entradas, copiar manualmente essa tela não é eficiente.

Precisamos automatizar.

---

Método 2 — Usar winget para listar programas

Abra o:

Terminal

ou:

PowerShell

e execute:

winget list

Quando o Windows Package Manager está disponível no sistema, o comando apresenta uma lista de pacotes detectados.

Podemos encontrar colunas semelhantes a:

Nome
ID
Versão
Disponível
Origem

Isso já fornece uma visão bastante útil.

---

Exemplo conceitual

O resultado pode seguir aproximadamente esta estrutura:

Nome                  ID                       Versão
----------------------------------------------------------
Programa A            Fabricante.ProgramaA     5.2.1
Programa B            Empresa.ProgramaB        10.4
Programa C            Outro.ProgramaC          2.8

Os nomes e valores naturalmente dependem do computador.

---

winget list não é apenas uma lista de pacotes instalados pelo winget

Esse detalhe é importante.

Muitas pessoas imaginam que:

winget list

mostra apenas programas que foram originalmente instalados com:

winget install

Não é tão simples.

O Windows Package Manager pode identificar vários softwares instalados através de outras fontes e relacioná-los ao catálogo quando consegue determinar sua identidade.

Por isso, winget list pode ser muito útil mesmo em computadores onde os programas foram instalados tradicionalmente.

---

Salvar a saída do winget em TXT

Podemos redirecionar a saída:

winget list > "$env:USERPROFILE\Desktop\programas.txt"

Depois procure:

programas.txt

na Área de Trabalho.

Agora temos um arquivo que pode ser arquivado antes de uma manutenção.

---

Problemas de formatação em relatórios de texto

Redirecionar a saída de um comando para TXT é rápido, mas nem sempre é a melhor maneira de criar dados estruturados.

Colunas podem ficar difíceis de processar posteriormente.

Se queremos:

• ordenar;
• filtrar;
• pesquisar;
• abrir no Excel;
• comparar computadores;

CSV costuma ser mais adequado.

Para isso, o PowerShell será muito mais poderoso.

---

Método 3 — Consultar programas pelo Registro com PowerShell

Grande parte dos programas tradicionais registra informações de desinstalação no Registro do Windows.

Uma das áreas importantes é:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall

Podemos consultar essa área com PowerShell.

Exemplo:

Get-ItemProperty `
"HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" |
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate

Esse comando começa a transformar o Registro em um inventário.

---

O que significa HKLM?

No PowerShell:

HKLM:

representa:

HKEY_LOCAL_MACHINE

Essa área contém configurações relacionadas à máquina.

Portanto, estamos consultando softwares registrados no contexto do computador.

---

Remova entradas sem nome

Ao consultar a chave de desinstalação, podemos encontrar entradas que não possuem DisplayName.

Podemos filtrar:

Get-ItemProperty `
"HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" |
Where-Object {$_.DisplayName} |
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate

Agora exibimos somente entradas que possuem nome.

---

Ordene alfabeticamente

Adicione:

Sort-Object DisplayName

Ficando:

Get-ItemProperty `
"HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" |
Where-Object {$_.DisplayName} |
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
Sort-Object DisplayName

Agora temos um inventário mais organizado.

---

O que cada coluna significa?

DisplayName

É o nome exibido para o programa.

Exemplo:

Aplicativo Exemplo

---

DisplayVersion

Representa a versão registrada pelo instalador.

Exemplo:

7.4.2

Mas atenção:

o valor depende das informações fornecidas pelo próprio instalador.

---

Publisher

Normalmente identifica o fabricante ou desenvolvedor.

Exemplo:

Empresa Exemplo Ltda.

---

InstallDate

Alguns instaladores registram uma data.

Ela pode aparecer no formato:

20260911

que podemos interpretar como:

2026-09-11

Mas existe uma limitação importante.

---

InstallDate não é uma prova absoluta da data original de instalação

Nem todo programa cria esse valor.

Além disso, determinados instaladores podem atualizar essa informação durante:

• atualização;
• reparo;
• reinstalação.

Portanto, não devemos afirmar:

InstallDate sempre mostra quando o programa foi instalado pela primeira vez.

O mais correto é interpretar como:

data registrada pelo instalador para aquela entrada, quando disponível.

---

E os programas de 32 bits?

Em um Windows de 64 bits, também precisamos consultar outra área importante:

HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall

Ela pode conter registros relacionados a aplicativos de 32 bits.

No PowerShell:

Get-ItemProperty `
"HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" |
Where-Object {$_.DisplayName} |
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
Sort-Object DisplayName

Agora nosso inventário ficou mais completo.

---

Por que existe WOW6432Node?

Em sistemas Windows de 64 bits, existe infraestrutura para compatibilidade com aplicativos de 32 bits.

O Registro também possui mecanismos de separação/redirecionamento relacionados a essas arquiteturas.

Por isso, ao fazer um inventário técnico, consultar apenas uma chave pode deixar programas de fora.

---

Ainda falta outra área: programas instalados por usuário

Alguns softwares registram informações no perfil do usuário.

Podemos consultar:

HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall

No PowerShell:

Get-ItemProperty `
"HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" |
Where-Object {$_.DisplayName} |
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
Sort-Object DisplayName

---

O que significa HKCU?

HKCU:

representa:

HKEY_CURRENT_USER

Ou seja, estamos consultando dados associados ao usuário atual.

Agora percebemos por que um inventário realmente completo exige mais de uma consulta.

---

Temos pelo menos três fontes importantes

Até aqui:

HKLM 64 bits

HKLM 32 bits

HKCU usuário atual

Podemos combinar as três.

---

Método 4 — Criar uma lista consolidada

No PowerShell:

$paths = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
Sort-Object DisplayName

Agora consultamos as três áreas de uma vez.

---

Podemos encontrar duplicidades?

Sim.

Dependendo de como um software foi registrado, o relatório pode apresentar entradas parecidas ou duplicadas.

Isso pode ocorrer com:

• componentes auxiliares;
• versões diferentes;
• arquitetura;
• instaladores;
• atualizações;
• entradas por usuário.

Não remova automaticamente duplicidades sem entender o motivo.

Duas entradas com nomes semelhantes podem representar componentes diferentes.

---

Adicione o local de instalação

Alguns programas registram:

InstallLocation

Podemos incluir:

$paths = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object DisplayName,
              DisplayVersion,
              Publisher,
              InstallDate,
              InstallLocation |
Sort-Object DisplayName

Quando preenchido, esse campo pode revelar onde o programa está instalado.

---

Nem todo programa informa InstallLocation

Esse é outro ponto importante.

Uma entrada vazia não significa que o software não está instalado.

Significa apenas que aquela informação não foi registrada nesse campo.

O instalador determina grande parte dos dados disponíveis.

---

Adicione o comando de desinstalação

Existe ainda:

UninstallString

Podemos consultar:

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object DisplayName,
              DisplayVersion,
              Publisher,
              InstallDate,
              InstallLocation,
              UninstallString |
Sort-Object DisplayName

Agora o relatório começa a ficar muito interessante para suporte técnico.

---

O que é UninstallString?

É o comando registrado para iniciar o processo de desinstalação.

Podemos encontrar algo relacionado a:

uninstall.exe

ou comandos do Windows Installer.

Isso ajuda a identificar como determinado software foi registrado.

Mas não execute UninstallString automaticamente em massa.

Nosso objetivo aqui é inventário.

---

Método 5 — Exportar o relatório para CSV

Agora chegamos a uma das partes mais úteis.

Podemos exportar:

$paths = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object DisplayName,
              DisplayVersion,
              Publisher,
              InstallDate,
              InstallLocation,
              UninstallString |
Sort-Object DisplayName |
Export-Csv "$env:USERPROFILE\Desktop\programas-instalados.csv" `
-NoTypeInformation -Encoding UTF8

Depois procure na Área de Trabalho:

programas-instalados.csv

Esse arquivo pode ser aberto no Excel ou em outros programas compatíveis com CSV.

---

O relatório agora possui estrutura

Em vez de um TXT simples, teremos campos como:

DisplayName
DisplayVersion
Publisher
InstallDate
InstallLocation
UninstallString

Isso permite:

• ordenar por fabricante;
• procurar versão;
• filtrar programas;
• comparar máquinas;
• arquivar inventários.

---

Renomeando as colunas para português

Podemos deixar o relatório mais amigável.

Exemplo:

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Desinstalador';Expression={$_.UninstallString}} |
Sort-Object Programa |
Export-Csv "$env:USERPROFILE\Desktop\programas-instalados.csv" `
-NoTypeInformation -Encoding UTF8

Agora as colunas ficam mais fáceis de entender.

---

Podemos adicionar a origem da entrada

Esse é um refinamento interessante.

Se quisermos saber se uma entrada veio de:

HKLM 64 bits
HKLM 32 bits
HKCU

podemos consultar cada caminho separadamente e adicionar uma coluna.

Isso será especialmente útil quando quisermos identificar arquitetura e contexto de instalação.

---

E os aplicativos da Microsoft Store?

Aqui encontramos outra diferença importante.

Nem todos os aplicativos modernos devem ser tratados exatamente como programas Win32 registrados nas chaves tradicionais de desinstalação.

Para consultar pacotes do usuário atual, podemos usar:

Get-AppxPackage

Uma visualização simples:

Get-AppxPackage |
Select-Object Name, PackageFullName, Version

Agora aparecerá outro conjunto de componentes.

---

Por que a lista Get-AppxPackage pode ser enorme?

Porque ela pode incluir pacotes e componentes que o usuário normalmente não considera “programas instalados”.

Portanto, não devemos simplesmente misturar tudo e afirmar:

este computador possui 250 programas

É melhor separar categorias.

Por exemplo:

Programas tradicionais

e:

Pacotes Appx/MSIX

---

Exportando os pacotes para CSV

Podemos criar outro relatório:

Get-AppxPackage |
Select-Object Name, PackageFullName, Version, Publisher |
Sort-Object Name |
Export-Csv "$env:USERPROFILE\Desktop\aplicativos-store.csv" `
-NoTypeInformation -Encoding UTF8

Agora teremos:

aplicativos-store.csv

separado do relatório Win32.

---

Por que separar os relatórios?

Porque são inventários conceitualmente diferentes.

Isso deixa o diagnóstico mais claro.

Podemos ter:

programas-instalados.csv

para programas tradicionais.

E:

aplicativos-store.csv

para pacotes Appx/MSIX.

---

Método 6 — Descobrir versão exata de um programa

Se você precisa apenas de um programa específico, não precisa gerar tudo.

Podemos filtrar.

Exemplo:

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName -like "*Chrome*"} |
Select-Object DisplayName, DisplayVersion, Publisher

Troque:

Chrome

pelo programa desejado.

---

Pesquisa parcial é muito útil

Por exemplo:

Where-Object {$_.DisplayName -like "*Office*"}

ou:

Where-Object {$_.DisplayName -like "*Adobe*"}

Isso ajuda durante suporte remoto quando precisamos descobrir rapidamente quais componentes de determinado fabricante estão instalados.

---

Método 7 — Agrupar programas por fabricante

Podemos fazer:

Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Group-Object Publisher |
Sort-Object Count -Descending

Isso mostra quais fabricantes possuem mais entradas registradas.

Pode ajudar a localizar conjuntos de:

• drivers;
• utilitários;
• programas de impressora;
• ferramentas empresariais.

---

Como contar as entradas encontradas?

Podemos armazenar o resultado:

$programas = Get-ItemProperty $paths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName}

$programas.Count

Mas lembre:

esse número representa entradas encontradas nessas fontes, não necessariamente a quantidade absoluta de softwares existentes no computador.

Programas portáteis continuam sendo um exemplo de exceção.

---

Cuidado com Win32_Product

Ao pesquisar na Internet por comandos para listar programas instalados, você ainda pode encontrar exemplos como:

Get-CimInstance Win32_Product

ou o antigo uso de:

wmic product

Apesar de Win32_Product conseguir retornar informações sobre produtos instalados via Windows Installer, ele não é uma boa escolha como método geral para inventariar todos os programas do computador.

---

Por que evitar Win32_Product como primeira opção?

Um dos problemas é que essa classe está relacionada aos produtos gerenciados pelo Windows Installer e não representa necessariamente todo o conjunto de softwares instalados.

Além disso, consultas a Win32_Product historicamente podem provocar verificações de consistência/reconfiguração de pacotes MSI.

Para um simples inventário, isso é desnecessário.

Prefira consultar as chaves de desinstalação ou utilizar ferramentas apropriadas como winget.

---

Não confunda “programas instalados” com processos em execução

Nosso relatório responde:

quais softwares estão registrados como instalados?

Ele não responde:

quais estão funcionando agora?

Para processos em execução usamos:

Get-Process

São perguntas diferentes.

---

Também não confunda programas com serviços

Um software pode instalar:

programa
+
serviço
+
driver

Nosso relatório de programas pode mostrar o produto principal, mas não necessariamente detalhar todos os serviços e drivers criados por ele.

Para isso precisamos de inventários adicionais.

---

Antes de formatar um computador, esse relatório é suficiente?

Ele é excelente como referência, mas não deve ser a única preparação.

Antes de uma reinstalação, também vale registrar:

• programas;
• drivers importantes;
• impressoras;
• contas;
• navegadores;
• favoritos;
• arquivos pessoais;
• configurações;
• certificados;
• softwares licenciados.

E, principalmente, realizar backup dos dados importantes.

---

Relatório não faz backup dos programas

Esse é um erro que precisamos evitar.

Salvar:

programas-instalados.csv

não salva os aplicativos.

Ele salva apenas informações sobre eles.

Depois da reinstalação do Windows, os programas ainda precisarão ser reinstalados.

---

Licenças também não são copiadas pelo relatório

O relatório pode identificar:

Programa X
Versão Y
Fabricante Z

Mas isso não significa que tenhamos:

• licença;
• chave;
• conta;
• instalador.

Softwares comerciais podem exigir credenciais ou mecanismos próprios de ativação.

Prepare essas informações separadamente quando necessário.

---

Um bom inventário começa antes da manutenção

Imagine receber um computador com dezenas de programas.

O usuário diz:

“Pode formatar, depois instala tudo de novo.”

Mas o que significa “tudo”?

Sem inventário, essa informação depende da memória do usuário.

Com um relatório, podemos registrar o estado anterior da máquina.

Isso reduz esquecimentos e facilita a conferência posterior.

---

Exemplo de relatório técnico

Podemos chegar a algo como:

Programa: Aplicativo Exemplo
Versão: 8.2.4
Fabricante: Empresa Exemplo
Origem: HKLM 64 bits
Local: C:\Program Files\Empresa\

Outro:

Programa: Utilitário Exemplo
Versão: 3.1
Fabricante: Fabricante Exemplo
Origem: HKCU
Local: perfil do usuário

Isso é muito mais útil do que uma fotografia da tela de Aplicativos Instalados.

---

O próximo nível: automatizar todo o inventário

Até aqui aprendemos os componentes necessários.

Na próxima parte vamos montar um script PowerShell completo capaz de gerar automaticamente uma pasta de inventário contendo relatórios separados de:

programas tradicionais
aplicativos Appx/MSIX
processos
serviços
drivers

Também vamos acrescentar:

• nome do computador;
• usuário;
• edição do Windows;
• versão;
• build;
• data do relatório;
• arquitetura;
• exportação em CSV;
• arquivo TXT de resumo.

Assim, em vez de apenas uma lista de programas, teremos um pequeno inventário técnico do Windows 11, muito útil antes de formatação, troca de SSD, manutenção ou migração para outro computador.

Como criar automaticamente um inventário completo do Windows 11 com PowerShell

Na primeira parte aprendemos que não existe uma única lista capaz de representar perfeitamente todos os softwares existentes em um computador.

Programas tradicionais podem aparecer em diferentes áreas do Registro.

Aplicativos modernos podem utilizar pacotes Appx/MSIX.

Programas portáteis talvez não apareçam em nenhum inventário tradicional.

Agora vamos transformar esses conceitos em algo muito mais prático.

Vamos criar uma pasta contendo relatórios como:

Inventario-Windows
│
├── programas-instalados.csv
├── aplicativos-appx.csv
├── servicos.csv
├── processos.csv
├── drivers.csv
└── resumo-computador.txt

Esse tipo de inventário pode ser criado antes de:

• formatação;
• reinstalação do Windows;
• troca de SSD;
• migração para outro computador;
• manutenção preventiva;
• suporte remoto;
• comparação entre máquinas;
• auditoria básica de software.

---

Etapa 1 — Abra o PowerShell

Clique com o botão direito no botão Iniciar.

Abra:

Terminal

ou:

PowerShell

Algumas informações podem ser consultadas como usuário comum.

Outras podem ficar mais completas quando o terminal é executado com privilégios administrativos.

Para um inventário técnico, podemos utilizar:

Executar como administrador

quando necessário.

---

Etapa 2 — Crie uma pasta para os relatórios

Vamos começar definindo o local.

Execute:

$PastaRelatorio = "$env:USERPROFILE\Desktop\Inventario-Windows"

New-Item -ItemType Directory -Path $PastaRelatorio -Force

Agora deverá existir na Área de Trabalho:

Inventario-Windows

---

O que significa $env?

É uma variável de ambiente que aponta para o perfil do usuário atual.

Normalmente corresponde a algo semelhante a:

C:\Users\NomeDoUsuario

Por isso:

"$env:USERPROFILE\Desktop"

aponta para a Área de Trabalho quando ela utiliza esse caminho tradicional.

Em computadores com redirecionamento de pastas ou configurações corporativas, o local real pode ser diferente. Por isso, sempre confirme onde o arquivo foi criado.

---

Etapa 3 — Gere o relatório dos programas tradicionais

Vamos definir novamente os caminhos do Registro:

$UninstallPaths = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

Agora consulte:

$Programas = Get-ItemProperty $UninstallPaths -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Desinstalador';Expression={$_.UninstallString}} |
Sort-Object Programa

Nesse momento, o resultado fica armazenado em:

$Programas

---

Visualize antes de exportar

Execute:

$Programas

Você poderá verificar se os dados fazem sentido.

Também podemos contar:

$Programas.Count

Lembre novamente:

esse número representa as entradas retornadas pelas fontes consultadas.

Não significa necessariamente a quantidade absoluta de softwares existentes no computador.

---

Exporte para CSV

Execute:

$Programas |
Export-Csv "$PastaRelatorio\programas-instalados.csv" `
-NoTypeInformation -Encoding UTF8

Agora teremos:

Inventario-Windows
└── programas-instalados.csv

---

Etapa 4 — Adicione a origem de cada programa

Podemos melhorar bastante o relatório.

Queremos saber se uma entrada veio de:

Máquina 64 bits
Máquina 32 bits
Usuário atual

Para isso, vamos consultar separadamente.

---

Programas registrados em HKLM 64 bits

$Programas64 = Get-ItemProperty `
"HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" `
-ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Origem';Expression={'HKLM-64'}}

---

Programas registrados na área de 32 bits

$Programas32 = Get-ItemProperty `
"HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" `
-ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Origem';Expression={'HKLM-32'}}

---

Programas registrados para o usuário atual

$ProgramasUsuario = Get-ItemProperty `
"HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" `
-ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Origem';Expression={'HKCU'}}

---

Junte os três relatórios

Agora:

$ProgramasComOrigem = @(
    $Programas64
    $Programas32
    $ProgramasUsuario
) | Sort-Object Programa

Exporte:

$ProgramasComOrigem |
Export-Csv "$PastaRelatorio\programas-com-origem.csv" `
-NoTypeInformation -Encoding UTF8

Agora temos uma coluna extra:

Origem

---

A origem HKLM-32 prova que o executável é 32 bits?

Não devemos tratar essa coluna como uma análise completa da arquitetura do executável.

Ela mostra de qual área do Registro obtivemos a entrada.

Na maioria dos inventários isso já fornece contexto útil, mas uma verificação definitiva da arquitetura de um binário é outra tarefa.

Por isso, o nome:

Origem

é mais seguro do que afirmar:

ArquiteturaDoPrograma

---

Etapa 5 — Liste aplicativos Appx/MSIX

Agora vamos gerar outro arquivo.

Execute:

$Appx = Get-AppxPackage |
Select-Object Name,
              Version,
              Publisher,
              PackageFullName |
Sort-Object Name

Depois:

$Appx |
Export-Csv "$PastaRelatorio\aplicativos-appx.csv" `
-NoTypeInformation -Encoding UTF8

Agora temos:

aplicativos-appx.csv

---

Por que não juntar Appx e programas tradicionais?

Porque são fontes e modelos diferentes.

Separando:

programas-instalados.csv

e:

aplicativos-appx.csv

mantemos o inventário mais fácil de interpretar.

---

Etapa 6 — Gere um relatório de processos em execução

Agora vamos registrar o estado atual da máquina.

Execute:

Get-Process |
Select-Object ProcessName,
              Id,
              CPU,
              WorkingSet |
Sort-Object ProcessName |
Export-Csv "$PastaRelatorio\processos.csv" `
-NoTypeInformation -Encoding UTF8

Isso cria:

processos.csv

---

Processos não são programas instalados

Esse relatório representa uma fotografia do momento em que o comando foi executado.

Se o computador for reiniciado, a lista poderá mudar.

Ela serve para responder:

O que estava em execução quando o inventário foi feito?

---

Por que isso pode ser útil antes de uma formatação?

Imagine que um usuário utilize um pequeno programa que inicia automaticamente e esqueça o nome.

Ele pode aparecer em:

processos.csv

mesmo que o usuário não se lembre dele.

Depois podemos relacionar o nome do processo ao software correspondente.

---

Etapa 7 — Gere um relatório de serviços

Execute:

Get-CimInstance Win32_Service |
Select-Object Name,
              DisplayName,
              State,
              StartMode,
              StartName,
              PathName |
Sort-Object DisplayName |
Export-Csv "$PastaRelatorio\servicos.csv" `
-NoTypeInformation -Encoding UTF8

Agora temos:

servicos.csv

---

Por que usar Win32_Service aqui?

Porque queremos mais informações do que apenas:

Get-Service

A consulta CIM pode fornecer campos úteis como:

StartName
PathName
StartMode

Isso ajuda a identificar serviços pertencentes a softwares de terceiros.

---

Exemplo

Podemos encontrar:

DisplayName: Serviço de Backup
State: Running
StartMode: Auto
StartName: LocalSystem
PathName: C:\Program Files\Backup\Agent.exe

Isso ajuda muito na reconstrução de uma máquina depois de manutenção.

---

Etapa 8 — Gere um relatório de drivers

Podemos começar com o comando nativo:

driverquery

Para salvar:

driverquery > "%USERPROFILE%\Desktop\drivers.txt"

Mas como estamos trabalhando dentro de um inventário PowerShell, podemos usar uma abordagem estruturada.

---

Consultando drivers assinados

Execute:

Get-CimInstance Win32_PnPSignedDriver |
Select-Object DeviceName,
              Manufacturer,
              DriverVersion,
              DriverDate,
              InfName,
              IsSigned |
Sort-Object DeviceName |
Export-Csv "$PastaRelatorio\drivers.csv" `
-NoTypeInformation -Encoding UTF8

Agora temos:

drivers.csv

---

O que esse relatório pode mostrar?

Dependendo do dispositivo:

DeviceName
Manufacturer
DriverVersion
DriverDate
InfName
IsSigned

Isso é extremamente útil antes de reinstalar o Windows em uma máquina que possui hardware específico.

---

Mas o relatório não é um backup do driver

Salvar:

drivers.csv

não salva os arquivos do driver.

Ele apenas registra informações.

Se você pretende preservar pacotes de drivers, existe outro procedimento.

---

Como exportar drivers de terceiros

O Windows possui:

pnputil

Podemos criar uma pasta:

$PastaDrivers = "$PastaRelatorio\Backup-Drivers"

New-Item -ItemType Directory -Path $PastaDrivers -Force

Depois, em um terminal administrativo, podemos utilizar uma operação de exportação suportada pelo PnPUtil, por exemplo:

pnputil /export-driver * "C:\caminho\Backup-Drivers"

Substitua o caminho pelo diretório realmente criado.

Esse procedimento é diferente do CSV.

Agora estamos falando de preservar pacotes de drivers disponíveis no Driver Store.

---

Não confunda exportar driver com criar instalador

Mesmo quando exportamos um pacote de driver, softwares auxiliares do fabricante podem não estar incluídos.

Por exemplo, uma impressora pode depender de:

driver
+
aplicativo de digitalização
+
utilitário

Exportar o driver não significa preservar todo o pacote do fabricante.

---

Etapa 9 — Registre informações do Windows

Agora vamos criar um resumo do sistema.

Comece com:

$SO = Get-CimInstance Win32_OperatingSystem
$Computador = Get-CimInstance Win32_ComputerSystem

Podemos consultar:

$SO.Caption
$SO.Version
$SO.BuildNumber
$SO.OSArchitecture
$Computador.Manufacturer
$Computador.Model

---

Crie um arquivo de resumo

Execute:

$Resumo = @"
RELATÓRIO DO COMPUTADOR

Data do relatório: $(Get-Date)
Nome do computador: $env:COMPUTERNAME
Usuário: $env:USERNAME

Windows: $($SO.Caption)
Versão: $($SO.Version)
Build: $($SO.BuildNumber)
Arquitetura: $($SO.OSArchitecture)

Fabricante: $($Computador.Manufacturer)
Modelo: $($Computador.Model)

Programas registrados: $($ProgramasComOrigem.Count)
Pacotes Appx do usuário consultado: $($Appx.Count)
"@

$Resumo |
Out-File "$PastaRelatorio\resumo-computador.txt" -Encoding UTF8

Agora temos:

resumo-computador.txt

---

O relatório começa a ficar profissional

Nossa pasta agora pode ter:

Inventario-Windows
│
├── programas-instalados.csv
├── programas-com-origem.csv
├── aplicativos-appx.csv
├── processos.csv
├── servicos.csv
├── drivers.csv
├── resumo-computador.txt
└── Backup-Drivers

Dependendo das etapas executadas.

---

Etapa 10 — Registre informações do processador

Podemos acrescentar:

$CPU = Get-CimInstance Win32_Processor

Depois:

$CPU.Name

Isso pode ser incluído no resumo.

---

Registre memória RAM

Podemos calcular aproximadamente a RAM total:

$RAMGB = [math]::Round($Computador.TotalPhysicalMemory / 1GB, 2)

Depois:

$RAMGB

---

Registre discos

Podemos consultar discos físicos:

Get-PhysicalDisk |
Select-Object FriendlyName,
              MediaType,
              BusType,
              HealthStatus,
              Size

E exportar:

Get-PhysicalDisk |
Select-Object FriendlyName,
              MediaType,
              BusType,
              HealthStatus,
              Size |
Export-Csv "$PastaRelatorio\discos.csv" `
-NoTypeInformation -Encoding UTF8

Agora teremos:

discos.csv

---

Cuidado ao interpretar HealthStatus

Um valor indicando:

Healthy

não deve ser interpretado como um diagnóstico completo de saúde do SSD ou HD.

É apenas uma informação fornecida pela camada consultada.

Para avaliação aprofundada de armazenamento, precisamos analisar SMART e outras métricas específicas.

---

Etapa 11 — Liste adaptadores de rede

Podemos executar:

Get-NetAdapter |
Select-Object Name,
              InterfaceDescription,
              Status,
              MacAddress,
              LinkSpeed |
Export-Csv "$PastaRelatorio\adaptadores-rede.csv" `
-NoTypeInformation -Encoding UTF8

Isso cria:

adaptadores-rede.csv

Útil principalmente em computadores com:

• Ethernet;
• Wi-Fi;
• VPN;
• adaptadores virtuais.

---

Não publique esse inventário inteiro na Internet

Esse tipo de relatório pode conter informações específicas da máquina.

Dependendo do que você incluir, poderá revelar:

• nome do computador;
• usuário;
• programas empresariais;
• caminhos;
• endereços de hardware;
• estrutura interna.

Use o relatório para manutenção e documentação.

Antes de compartilhar publicamente, revise os dados.

---

Etapa 12 — Liste impressoras

Antes de formatar um computador, isso pode ser muito útil.

Execute:

Get-Printer |
Select-Object Name,
              DriverName,
              PortName,
              Type,
              Shared |
Export-Csv "$PastaRelatorio\impressoras.csv" `
-NoTypeInformation -Encoding UTF8

Agora teremos:

impressoras.csv

---

Por que registrar a porta da impressora?

A coluna:

PortName

pode revelar informações importantes.

Por exemplo:

USB001

ou uma porta TCP/IP.

Isso ajuda muito quando precisamos reconstruir uma configuração de impressão depois de reinstalar o Windows.

---

Etapa 13 — Liste tarefas agendadas

Podemos consultar:

Get-ScheduledTask |
Select-Object TaskName,
              TaskPath,
              State |
Sort-Object TaskPath, TaskName |
Export-Csv "$PastaRelatorio\tarefas-agendadas.csv" `
-NoTypeInformation -Encoding UTF8

Agora temos:

tarefas-agendadas.csv

---

Por que isso é útil?

Alguns softwares dependem de tarefas agendadas para:

• atualizar;
• sincronizar;
• executar backup;
• iniciar agentes;
• realizar manutenção.

Depois de uma reinstalação, comparar essa lista pode ajudar a descobrir componentes esquecidos.

---

Etapa 14 — Liste programas da inicialização

Podemos consultar:

Get-CimInstance Win32_StartupCommand |
Select-Object Name,
              Command,
              Location,
              User |
Sort-Object Name |
Export-Csv "$PastaRelatorio\inicializacao.csv" `
-NoTypeInformation -Encoding UTF8

Agora teremos:

inicializacao.csv

Esse relatório é particularmente interessante.

Ele mostra programas configurados para iniciar automaticamente através de determinadas fontes conhecidas pelo Windows.

---

O inventário começa a contar a história do computador

Agora não sabemos apenas:

quais programas estão instalados

Também começamos a descobrir:

quais processos estavam funcionando

quais serviços existem

quais drivers estão registrados

quais impressoras existem

quais programas iniciam automaticamente

quais tarefas estão agendadas

Isso é muito mais útil antes de uma manutenção.

---

Etapa 15 — Gere tudo automaticamente

Depois de entender cada comando individualmente, podemos reuni-los em um script.

Isso é importante:

não comece simplesmente copiando um script enorme sem entender o que ele coleta.

Nós fizemos o caminho contrário.

Primeiro entendemos:

fonte
↓
comando
↓
informação
↓
arquivo gerado

Agora podemos automatizar com segurança.

---

Estrutura que queremos produzir

O script final poderá gerar algo semelhante a:

Inventario-Windows-2026-09-11
│
├── 01-resumo-computador.txt
├── 02-programas.csv
├── 03-aplicativos-appx.csv
├── 04-processos.csv
├── 05-servicos.csv
├── 06-drivers.csv
├── 07-discos.csv
├── 08-rede.csv
├── 09-impressoras.csv
├── 10-inicializacao.csv
└── 11-tarefas-agendadas.csv

A data no nome da pasta ajuda a comparar inventários realizados em momentos diferentes.

---

Podemos comparar dois inventários?

Sim.

E isso abre uma possibilidade ainda mais interessante.

Imagine:

Inventario-Antes

e:

Inventario-Depois

Podemos comparar os CSVs para descobrir:

• programa novo;
• programa removido;
• versão alterada;
• novo serviço;
• novo driver;
• nova tarefa;
• nova inicialização automática.

Isso transforma nosso relatório em uma ferramenta de diagnóstico.

---

Exemplo

Antes:

Programa A — 1.0
Programa B — 5.2
Programa C — 8.0

Depois:

Programa A — 1.0
Programa B — 5.3
Programa C — 8.0
Programa D — 2.1

Podemos descobrir:

Programa B foi atualizado
Programa D apareceu

Isso é extremamente útil quando um problema começa depois de alguma alteração.

---

O relatório também pode ajudar na troca de SSD

Antes da migração:

gere inventário
↓
faça backup
↓
troque SSD
↓
instale Windows
↓
reinstale programas
↓
gere novo inventário
↓
compare

Assim fica muito mais fácil descobrir o que ainda falta.

---

Inventário não substitui imagem do sistema

Existe uma diferença enorme entre:

inventário

e:

imagem/backup do sistema

O inventário documenta.

O backup preserva dados.

Uma imagem do sistema pode preservar muito mais do estado da instalação, dependendo do método utilizado.

Nosso CSV não faz isso.

---

Também não salve senhas em CSV

Evite transformar esse inventário em um arquivo contendo:

• senhas;
• tokens;
• chaves privadas;
• credenciais.

Nosso objetivo é documentação técnica.

Dados sensíveis devem seguir procedimentos específicos de backup e segurança.

Script PowerShell completo para criar um inventário técnico do Windows 11

Depois de entender cada consulta separadamente, podemos montar um script único.

Isso é útil quando você precisa repetir o processo em vários computadores ou criar rapidamente uma documentação antes de:

• formatação;
• troca de SSD;
• manutenção;
• migração;
• diagnóstico;
• inventário empresarial;
• comparação entre duas máquinas.

A vantagem da automação é evitar que você precise executar manualmente dezenas de comandos.

---

O que este script vai gerar?

A estrutura poderá ficar assim:

Inventario-Windows-2026-09-11-122500
│
├── 01-resumo-computador.txt
├── 02-programas-instalados.csv
├── 03-aplicativos-appx.csv
├── 04-processos.csv
├── 05-servicos.csv
├── 06-drivers.csv
├── 07-discos.csv
├── 08-rede.csv
├── 09-impressoras.csv
├── 10-inicializacao.csv
└── 11-tarefas-agendadas.csv

A data e o horário ajudam a diferenciar vários inventários realizados na mesma máquina.

---

Etapa 16 — Script completo

Abra o PowerShell.

Para obter o máximo de informações, prefira executar como administrador.

Cole:

# ==========================================
# INVENTÁRIO TÉCNICO DO WINDOWS 11
# ==========================================

$Data = Get-Date -Format "yyyy-MM-dd-HHmmss"

$PastaRelatorio = Join-Path `
$env:USERPROFILE `
"Desktop\Inventario-Windows-$Data"

New-Item `
-ItemType Directory `
-Path $PastaRelatorio `
-Force | Out-Null


# ==========================================
# INFORMAÇÕES DO SISTEMA
# ==========================================

$SO = Get-CimInstance Win32_OperatingSystem

$Computador = Get-CimInstance Win32_ComputerSystem

$CPU = Get-CimInstance Win32_Processor

$RAMGB = [math]::Round(
    $Computador.TotalPhysicalMemory / 1GB,
    2
)


# ==========================================
# PROGRAMAS INSTALADOS
# ==========================================

$Programas64 = Get-ItemProperty `
"HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" `
-ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Desinstalador';Expression={$_.UninstallString}},
@{Name='Origem';Expression={'HKLM-64'}}


$Programas32 = Get-ItemProperty `
"HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*" `
-ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Desinstalador';Expression={$_.UninstallString}},
@{Name='Origem';Expression={'HKLM-32'}}


$ProgramasUsuario = Get-ItemProperty `
"HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*" `
-ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}},
@{Name='DataInstalacao';Expression={$_.InstallDate}},
@{Name='LocalInstalacao';Expression={$_.InstallLocation}},
@{Name='Desinstalador';Expression={$_.UninstallString}},
@{Name='Origem';Expression={'HKCU'}}


$Programas = @(
    $Programas64
    $Programas32
    $ProgramasUsuario
) |
Sort-Object Programa


$Programas |
Export-Csv `
"$PastaRelatorio\02-programas-instalados.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# PACOTES APPX / MSIX
# ==========================================

$Appx = Get-AppxPackage |
Select-Object `
Name,
Version,
Publisher,
PackageFullName |
Sort-Object Name


$Appx |
Export-Csv `
"$PastaRelatorio\03-aplicativos-appx.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# PROCESSOS EM EXECUÇÃO
# ==========================================

Get-Process |
Select-Object `
ProcessName,
Id,
CPU,
WorkingSet,
Handles |
Sort-Object ProcessName |
Export-Csv `
"$PastaRelatorio\04-processos.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# SERVIÇOS
# ==========================================

Get-CimInstance Win32_Service |
Select-Object `
Name,
DisplayName,
State,
StartMode,
StartName,
PathName |
Sort-Object DisplayName |
Export-Csv `
"$PastaRelatorio\05-servicos.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# DRIVERS
# ==========================================

Get-CimInstance Win32_PnPSignedDriver |
Select-Object `
DeviceName,
Manufacturer,
DriverVersion,
DriverDate,
InfName,
IsSigned |
Sort-Object DeviceName |
Export-Csv `
"$PastaRelatorio\06-drivers.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# DISCOS
# ==========================================

Get-PhysicalDisk |
Select-Object `
FriendlyName,
MediaType,
BusType,
HealthStatus,
OperationalStatus,
Size |
Export-Csv `
"$PastaRelatorio\07-discos.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# ADAPTADORES DE REDE
# ==========================================

Get-NetAdapter |
Select-Object `
Name,
InterfaceDescription,
Status,
MacAddress,
LinkSpeed |
Sort-Object Name |
Export-Csv `
"$PastaRelatorio\08-rede.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# IMPRESSORAS
# ==========================================

Get-Printer |
Select-Object `
Name,
DriverName,
PortName,
Type,
Shared |
Sort-Object Name |
Export-Csv `
"$PastaRelatorio\09-impressoras.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# PROGRAMAS DA INICIALIZAÇÃO
# ==========================================

Get-CimInstance Win32_StartupCommand |
Select-Object `
Name,
Command,
Location,
User |
Sort-Object Name |
Export-Csv `
"$PastaRelatorio\10-inicializacao.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# TAREFAS AGENDADAS
# ==========================================

Get-ScheduledTask |
Select-Object `
TaskName,
TaskPath,
State |
Sort-Object TaskPath, TaskName |
Export-Csv `
"$PastaRelatorio\11-tarefas-agendadas.csv" `
-NoTypeInformation `
-Encoding UTF8


# ==========================================
# RESUMO DO COMPUTADOR
# ==========================================

$Resumo = @"
INVENTÁRIO TÉCNICO DO WINDOWS

Data do relatório:
$(Get-Date)

Nome do computador:
$env:COMPUTERNAME

Usuário:
$env:USERNAME


SISTEMA OPERACIONAL

Windows:
$($SO.Caption)

Versão:
$($SO.Version)

Build:
$($SO.BuildNumber)

Arquitetura:
$($SO.OSArchitecture)


HARDWARE

Fabricante:
$($Computador.Manufacturer)

Modelo:
$($Computador.Model)

Processador:
$($CPU.Name)

Memória RAM:
$RAMGB GB


INVENTÁRIO

Programas registrados:
$($Programas.Count)

Pacotes Appx:
$($Appx.Count)


PASTA DO RELATÓRIO

$PastaRelatorio
"@


$Resumo |
Out-File `
"$PastaRelatorio\01-resumo-computador.txt" `
-Encoding UTF8


# ==========================================
# FINALIZAÇÃO
# ==========================================

Write-Host ""
Write-Host "Inventário concluído."
Write-Host ""
Write-Host "Pasta:"
Write-Host $PastaRelatorio
Write-Host ""

---

O script altera alguma configuração do Windows?

Não.

O objetivo principal desse script é consulta.

Ele lê informações do sistema e grava relatórios em uma pasta.

Ele não:

• desinstala programas;
• altera Registro;
• remove drivers;
• para serviços;
• modifica tarefas;
• altera configurações de rede.

Isso torna o procedimento adequado para inventário e documentação.

---

Ainda assim, revise qualquer script antes de executar

Essa é uma boa prática geral.

Mesmo quando um script parece seguro, leia o conteúdo.

Procure comandos como:

Remove-Item

Remove-AppxPackage

Stop-Service

Set-ItemProperty

Remove-ItemProperty

sc delete

Nosso script de inventário não precisa dessas operações.

---

Etapa 17 — Onde ficam os arquivos?

O script cria uma pasta na Área de Trabalho.

Algo parecido com:

Inventario-Windows-2026-09-11-122500

Dentro dela estarão os arquivos CSV e TXT.

---

E se a Área de Trabalho estiver no OneDrive?

Em alguns computadores, a Área de Trabalho pode estar redirecionada para o OneDrive.

Nesse caso, usar literalmente:

$env:USERPROFILE\Desktop

pode não representar exatamente a pasta exibida como Área de Trabalho.

Se isso acontecer, podemos obter a localização pela API do Windows.

Uma alternativa mais robusta é:

$Desktop = [Environment]::GetFolderPath('Desktop')

Depois:

$PastaRelatorio = Join-Path `
$Desktop `
"Inventario-Windows-$Data"

Essa abordagem é melhor em máquinas com redirecionamento.

---

Versão recomendada da criação da pasta

Podemos substituir o início por:

$Data = Get-Date -Format "yyyy-MM-dd-HHmmss"

$Desktop = [Environment]::GetFolderPath('Desktop')

$PastaRelatorio = Join-Path `
$Desktop `
"Inventario-Windows-$Data"

New-Item `
-ItemType Directory `
-Path $PastaRelatorio `
-Force | Out-Null

Assim o script tende a acompanhar melhor a localização configurada da Área de Trabalho.

---

Etapa 18 — Abra automaticamente a pasta ao terminar

Se quiser, acrescente ao final:

Start-Process explorer.exe $PastaRelatorio

Quando a coleta terminar, o Explorador de Arquivos abrirá a pasta criada.

Isso é opcional.

---

Etapa 19 — Como salvar o script em um arquivo .ps1

Em vez de colar tudo no PowerShell toda vez, podemos criar um arquivo.

Abra o Bloco de Notas.

Cole o script.

Salve como:

inventario-windows.ps1

Certifique-se de não acabar com:

inventario-windows.ps1.txt

---

O que significa .ps1?

A extensão:

.ps1

é usada por scripts PowerShell.

Um arquivo desses contém comandos que o PowerShell consegue interpretar.

---

Como executar um script PowerShell?

O Windows possui políticas de execução que podem afetar scripts .ps1.

Isso existe como uma camada de controle administrativo e não deve ser contornado aleatoriamente.

Se a execução estiver bloqueada, verifique primeiro a política atual:

Get-ExecutionPolicy -List

Isso mostra políticas aplicadas em diferentes escopos.

---

Não mude ExecutionPolicy sem entender o ambiente

Em máquinas corporativas, a política pode ser controlada por administrador ou política de grupo.

Não tente alterar essas configurações para driblar uma regra empresarial.

Para uso técnico em computador próprio ou autorizado, analise a política e utilize o procedimento apropriado ao ambiente.

---

Outra alternativa: executar os comandos diretamente

Se você não precisa automatizar permanentemente, pode simplesmente abrir o PowerShell e colar os comandos.

Assim, não precisa necessariamente criar um arquivo .ps1.

---

Etapa 20 — Como abrir CSV corretamente no Excel

Um CSV é um arquivo de texto estruturado.

Dependendo da configuração regional do Windows e do Excel, a abertura direta pode interpretar delimitadores de maneiras diferentes.

Se o Excel não separar corretamente as colunas, use o recurso de importação de texto/CSV.

Isso permite escolher:

• codificação;
• delimitador;
• formato das colunas.

---

Podemos usar ponto e vírgula?

Sim.

O Export-Csv permite especificar delimitador.

Exemplo:

Export-Csv `
"$PastaRelatorio\programas.csv" `
-NoTypeInformation `
-Encoding UTF8 `
-Delimiter ';'

Em algumas configurações brasileiras, isso pode facilitar a abertura em planilhas.

---

Ou podemos usar o separador regional

Outra possibilidade é:

Export-Csv `
"$PastaRelatorio\programas.csv" `
-NoTypeInformation `
-Encoding UTF8 `
-UseCulture

-UseCulture utiliza o separador de lista definido na cultura atual do sistema.

Isso pode melhorar compatibilidade com o Excel local.

---

Etapa 21 — Como encontrar programas adicionados entre dois inventários

Agora imagine que temos dois relatórios:

Antes\02-programas-instalados.csv

e:

Depois\02-programas-instalados.csv

Podemos importar:

$Antes = Import-Csv "C:\Inventario-Antes\02-programas-instalados.csv"

$Depois = Import-Csv "C:\Inventario-Depois\02-programas-instalados.csv"

Depois comparar:

Compare-Object `
$Antes.Programa `
$Depois.Programa

---

Como interpretar Compare-Object?

A saída possui uma coluna:

SideIndicator

Você pode encontrar:

=>

e:

<=

Eles indicam em qual conjunto o item existe.

Se usamos:

Compare-Object $Antes.Programa $Depois.Programa

então, de forma geral:

=>

indica item presente no segundo conjunto.

Ou seja:

Depois

Já:

<=

indica item presente no primeiro conjunto.

Ou seja:

Antes

---

Exemplo

Antes:

Programa A
Programa B
Programa C

Depois:

Programa A
Programa C
Programa D

Podemos encontrar algo equivalente a:

Programa B    <=
Programa D    =>

Isso indica:

Programa B desapareceu
Programa D apareceu

---

Mas e se apenas a versão mudou?

Comparar somente o nome não detecta isso.

Precisamos comparar:

nome + versão

Podemos criar uma propriedade:

$AntesComparacao = $Antes |
ForEach-Object {
    "$($_.Programa)|$($_.Versao)"
}

$DepoisComparacao = $Depois |
ForEach-Object {
    "$($_.Programa)|$($_.Versao)"
}

Compare-Object `
$AntesComparacao `
$DepoisComparacao

Agora uma atualização de versão poderá aparecer como diferença.

---

Exemplo

Antes:

Programa A|1.0

Depois:

Programa A|1.1

A comparação indicará mudança.

Mas ainda existe uma forma melhor.

Podemos comparar objetos pelo nome e depois analisar a versão.

---

Etapa 22 — Descubra quais programas mudaram de versão

Exemplo:

foreach ($ProgramaDepois in $Depois) {

    $ProgramaAntes = $Antes |
    Where-Object {
        $_.Programa -eq $ProgramaDepois.Programa
    } |
    Select-Object -First 1

    if ($ProgramaAntes) {

        if ($ProgramaAntes.Versao -ne $ProgramaDepois.Versao) {

            [PSCustomObject]@{
                Programa = $ProgramaDepois.Programa
                VersaoAntes = $ProgramaAntes.Versao
                VersaoDepois = $ProgramaDepois.Versao
            }
        }
    }
}

Isso pode gerar uma tabela semelhante a:

Programa       VersaoAntes     VersaoDepois
------------------------------------------------
Programa A     2.1             2.4
Programa B     10.3            10.4

Agora conseguimos identificar atualizações.

---

Esse método tem limitações

O nome registrado por um software pode mudar entre versões.

Por exemplo:

Programa 2025

pode virar:

Programa 2026

Nesse caso, a comparação pode interpretar como:

um removido
+
um adicionado

mesmo sendo uma atualização.

A automação ajuda, mas ainda exige interpretação humana.

---

Etapa 23 — Compare serviços antes e depois

Podemos fazer algo semelhante com:

05-servicos.csv

Exemplo:

$ServicosAntes = Import-Csv `
"C:\Inventario-Antes\05-servicos.csv"

$ServicosDepois = Import-Csv `
"C:\Inventario-Depois\05-servicos.csv"

Compare-Object `
$ServicosAntes.Name `
$ServicosDepois.Name

Isso pode revelar um serviço novo instalado por determinado software.

---

Compare drivers

Também podemos comparar:

06-drivers.csv

principalmente:

DeviceName
DriverVersion
InfName

Isso pode ajudar quando um problema começou depois da instalação de:

• impressora;
• placa de vídeo;
• adaptador;
• VPN;
• software de segurança.

---

Compare inicialização automática

Outra comparação extremamente útil:

10-inicializacao.csv

Talvez um software tenha adicionado um componente de inicialização sem que o usuário perceba.

---

Compare tarefas agendadas

Compare:

11-tarefas-agendadas.csv

Programas frequentemente criam tarefas para:

• atualização;
• telemetria;
• manutenção;
• sincronização.

Um inventário antes e depois pode mostrar isso.

---

O inventário pode ajudar a descobrir o que um instalador adicionou?

Sim, parcialmente.

Imagine:

Inventário 1
↓
instala programa
↓
reinicia se necessário
↓
Inventário 2
↓
compara

Podemos detectar mudanças em:

• programas;
• serviços;
• drivers;
• inicialização;
• tarefas.

Isso não mostra absolutamente tudo que o instalador modificou, mas cria um excelente primeiro nível de análise.

---

Para análise realmente detalhada existe Process Monitor

Se o objetivo for observar em tempo real alterações em:

arquivos
Registro
processos

uma ferramenta como Process Monitor oferece um nível muito mais profundo.

O inventário antes/depois responde:

o que está diferente agora?

Já o Process Monitor tenta responder:

qual processo fez determinada operação?

São técnicas complementares.

---

Etapa 24 — Identifique programas sem fabricante

Podemos pesquisar:

$Programas |
Where-Object {
    -not $_.Fabricante
}

Essas entradas merecem atenção durante um inventário.

Mas não significa que sejam maliciosas.

Alguns instaladores simplesmente não preenchem o campo Publisher.

---

Identifique programas sem versão

$Programas |
Where-Object {
    -not $_.Versao
}

Novamente, falta de versão pode significar apenas que o instalador não forneceu a informação.

---

Procure programas de determinado fabricante

Exemplo:

$Programas |
Where-Object {
    $_.Fabricante -like "*Microsoft*"
}

Ou:

$Programas |
Where-Object {
    $_.Fabricante -like "*Adobe*"
}

Troque o nome conforme necessário.

---

Procure um programa pelo nome

$Programas |
Where-Object {
    $_.Programa -like "*Office*"
}

Muito útil durante suporte remoto.

---

Ordene pela data registrada

Podemos tentar:

$Programas |
Sort-Object DataInstalacao -Descending

Mas lembre que:

• nem toda entrada possui data;
• a data pode representar atualização;
• formatos podem variar.

Por isso, não use esse campo como prova absoluta.

---

Como deixar o inventário ainda mais completo?

Podemos acrescentar outros relatórios, como:

hotfixes

recursos opcionais

versão do BIOS

placa-mãe

GPU

endereços IP

partições

Mas existe um equilíbrio.

Quanto mais informações coletamos, maior fica o relatório.

O ideal é adaptar ao objetivo.

---

Para uma formatação, o que considero essencial?

Um inventário prático deveria registrar pelo menos:

programas
drivers
impressoras
rede
inicialização
serviços de terceiros relevantes
informações do hardware

Além disso, deve existir um backup real dos dados pessoais.

---

Relatório não substitui Google Drive, OneDrive ou backup externo

Vale reforçar.

Inventário significa:

documentação

Backup significa:

cópia dos dados

São coisas diferentes.

---

Etapa 25 — Compacte a pasta do inventário

Depois de gerar tudo, você pode compactar a pasta.

No Explorador:

botão direito
→ Compactar para arquivo ZIP

Ou utilizar PowerShell:

Compress-Archive `
-Path "$PastaRelatorio\*" `
-DestinationPath "$PastaRelatorio.zip"

Agora teremos um único arquivo ZIP.

---

Cuidado antes de enviar o ZIP

Revise o conteúdo.

O inventário pode conter informações internas do computador.

Por exemplo:

nome do usuário
nome da máquina
caminhos de programas
MAC Address
programas instalados
tarefas
serviços

Compartilhe apenas com pessoas autorizadas.

---

Uma ideia interessante: gerar hash do inventário

Podemos calcular:

Get-FileHash `
"$PastaRelatorio.zip" `
-Algorithm SHA256

Isso produz um hash SHA-256 do arquivo.

Serve para verificar posteriormente se aquele ZIP continua exatamente igual.

---

Exemplo conceitual

SHA256:
B7F3...etc

Se qualquer byte do ZIP mudar, o hash também muda.

Isso não criptografa o arquivo.

Apenas fornece uma verificação de integridade.

Depois de montar um inventário completo do Windows 11, é importante entender até onde esse tipo de relatório consegue chegar.

A automação ajuda muito, mas não transforma o Windows em um sistema de inventário perfeito.

Existem diferenças entre:

• programa instalado;
• aplicativo portátil;
• pacote Appx/MSIX;
• serviço;
• driver;
• componente do Windows;
• aplicação instalada para outro usuário;
• software empresarial;
• arquivo executável isolado.

Por isso, o relatório precisa ser interpretado tecnicamente.

---

Versão resumida: listar somente nome, versão e fabricante

Nem sempre precisamos gerar dezenas de arquivos.

Se o objetivo for apenas criar uma lista simples dos programas registrados no Windows, podemos usar um script muito menor.

$Caminhos = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

Get-ItemProperty $Caminhos -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}} |
Sort-Object Programa

Esse comando já fornece uma boa visão geral.

---

Exportar a versão simples para CSV

Para salvar na Área de Trabalho:

$Desktop = [Environment]::GetFolderPath('Desktop')

$Caminhos = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

Get-ItemProperty $Caminhos -ErrorAction SilentlyContinue |
Where-Object {$_.DisplayName} |
Select-Object `
@{Name='Programa';Expression={$_.DisplayName}},
@{Name='Versao';Expression={$_.DisplayVersion}},
@{Name='Fabricante';Expression={$_.Publisher}} |
Sort-Object Programa |
Export-Csv `
(Join-Path $Desktop "programas-instalados.csv") `
-NoTypeInformation `
-Encoding UTF8

Depois procure:

programas-instalados.csv

na Área de Trabalho.

---

Quando usar o relatório simples?

Ele é suficiente quando precisamos:

• documentar programas antes de formatar;
• conferir versões;
• identificar fabricantes;
• comparar rapidamente duas máquinas;
• enviar uma lista para suporte técnico.

Já o inventário completo faz mais sentido quando precisamos também de:

• serviços;
• drivers;
• impressoras;
• tarefas;
• programas de inicialização;
• rede;
• hardware.

---

Limitação 1 — Programas portáteis podem não aparecer

Um programa portátil pode existir apenas como:

C:\Ferramentas\Programa\Programa.exe

sem criar uma entrada de desinstalação.

Nesse caso, consultar:

Uninstall

não é suficiente.

---

Como localizar programas portáteis?

Não existe uma solução perfeita.

Podemos pesquisar arquivos executáveis em pastas específicas, mas isso gera muitos resultados.

Por exemplo:

Get-ChildItem "C:\Ferramentas" `
-Filter *.exe `
-Recurse `
-ErrorAction SilentlyContinue

Isso encontra executáveis, mas não prova que cada arquivo representa um programa portátil usado pelo usuário.

---

Não faça uma busca indiscriminada em todo o disco sem necessidade

Executar uma pesquisa recursiva por todos os .exe do C:\ pode gerar milhares de resultados.

O Windows, drivers e aplicativos possuem inúmeros executáveis internos.

Para procurar programas portáteis, prefira locais prováveis, como:

Área de Trabalho
Downloads
Documentos
C:\Ferramentas
pastas criadas pelo usuário

---

Limitação 2 — HKCU representa apenas o usuário consultado

Quando utilizamos:

HKCU:

estamos consultando:

HKEY_CURRENT_USER

Ou seja, o perfil atualmente carregado.

Se o computador possui vários usuários, outro perfil pode possuir programas registrados individualmente.

---

Exemplo

Computador:

Usuário A
Usuário B
Usuário C

Você executa o script como:

Usuário A

A consulta a:

HKCU

representará principalmente o contexto daquele usuário.

Ela não significa automaticamente:

todos os programas de todos os perfis

---

Limitação 3 — Get-AppxPackage também depende do contexto

Por padrão:

Get-AppxPackage

consulta pacotes associados ao usuário atual.

Existem outras opções administrativas para trabalhar com mais usuários, mas isso deve ser feito conscientemente.

Por exemplo, existe:

Get-AppxPackage -AllUsers

Entretanto, a saída pode ser muito maior e incluir pacotes do sistema e de vários perfis.

Para um inventário simples antes de manutenção, muitas vezes é melhor manter os relatórios separados.

---

Limitação 4 — Nem toda entrada representa um aplicativo comum

As chaves de desinstalação podem conter:

• runtimes;
• redistribuíveis;
• drivers;
• componentes auxiliares;
• ferramentas de atualização;
• módulos de suporte;
• plug-ins.

Por exemplo, componentes do Microsoft Visual C++ podem aparecer como entradas separadas.

Eles não devem ser interpretados simplesmente como “programas que o usuário instalou manualmente”.

---

Limitação 5 — Versão pode estar ausente

Algumas entradas possuem:

DisplayVersion

vazio.

Isso não significa necessariamente que o programa esteja corrompido.

O instalador pode simplesmente não ter registrado aquele valor.

---

Limitação 6 — Fabricante também pode estar ausente

Da mesma maneira:

Publisher

pode estar vazio.

Isso não prova que o software seja suspeito.

É apenas um dado ausente.

---

Limitação 7 — InstallDate pode enganar

Já vimos que:

InstallDate

não deve ser interpretado automaticamente como:

primeiro dia em que o programa entrou no computador

Uma atualização ou reparo pode modificar informações relacionadas à instalação.

Use essa coluna como pista, não como prova absoluta.

---

Limitação 8 — O inventário não mostra todos os arquivos do programa

Uma entrada pode indicar:

Programa X
Versão 5.2

mas o software pode possuir arquivos espalhados em:

Program Files
ProgramData
AppData
Registro
Serviços
Drivers
Tarefas

Nosso inventário registra vários desses elementos separadamente, mas não cria um mapa completo de cada arquivo pertencente ao programa.

---

Limitação 9 — O relatório não é um desinstalador

Encontrar:

UninstallString

não significa que devemos executar automaticamente todos os comandos encontrados.

Alguns podem:

• exigir parâmetros;
• abrir assistentes;
• precisar de elevação;
• executar procedimentos específicos.

Use essa informação para diagnóstico.

---

Limitação 10 — O relatório não substitui backup

Esta talvez seja a limitação mais importante.

Ter:

programas-instalados.csv

não preserva:

• documentos;
• fotos;
• bancos de dados;
• arquivos de trabalho;
• perfil do navegador;
• e-mails locais;
• certificados;
• configurações específicas;
• licenças;
• senhas.

O inventário deve fazer parte de uma estratégia maior.

---

Checklist antes de formatar o Windows 11

Antes de apagar uma instalação, revise pelo menos estes pontos.

1. Arquivos pessoais

Confira:

Área de Trabalho
Documentos
Downloads
Imagens
Vídeos
Músicas

Além de pastas específicas criadas pelo usuário.

---

2. OneDrive e outros serviços de nuvem

Confirme se os arquivos realmente terminaram de sincronizar.

Um ícone de arquivo existente no Explorador não significa necessariamente que ele esteja disponível offline.

---

3. Navegadores

Verifique:

• favoritos;
• perfis;
• extensões importantes;
• sincronização;
• senhas, quando o usuário utiliza o recurso de sincronização e deseja preservá-las.

---

4. Programas essenciais

Gere o relatório deste tutorial.

Depois marque os programas realmente necessários.

Isso evita reinstalar dezenas de utilitários esquecidos.

---

5. Licenças

Confirme como os softwares comerciais são ativados.

Eles podem depender de:

• conta;
• assinatura;
• chave;
• servidor de licença;
• certificado;
• hardware.

---

6. Impressoras

Registre:

nome
driver
porta
IP, quando aplicável

Nosso arquivo:

09-impressoras.csv

ajuda bastante.

---

7. Drivers especiais

Principalmente em:

• notebooks;
• equipamentos antigos;
• dispositivos industriais;
• interfaces específicas;
• impressoras especiais.

Não dependa exclusivamente da ideia de que o Windows Update encontrará absolutamente tudo.

---

8. Certificados digitais

Usuários que trabalham com:

• contabilidade;
• advocacia;
• sistemas governamentais;
• assinatura digital;

podem depender de certificados e tokens.

O inventário de programas não faz backup desses itens.

---

9. Arquivos de e-mail locais

Dependendo do programa usado, podem existir arquivos locais que precisam de backup.

Verifique antes da formatação.

---

10. Programas empresariais

Softwares específicos podem depender de:

• banco de dados;
• pasta compartilhada;
• certificado;
• licença;
• serviço;
• servidor;
• configuração de rede.

Nesses casos, nunca trate a reinstalação como simples instalação de um .exe.

---

11. Máquinas virtuais

Se o computador utiliza:

• Hyper-V;
• VMware;
• VirtualBox;

localize e preserve os arquivos necessários das máquinas virtuais.

---

12. Scripts e automações

Verifique:

• PowerShell;
• BAT;
• CMD;
• tarefas agendadas;
• scripts de login.

Alguns desses arquivos podem ser fundamentais para o funcionamento da máquina.

---

13. Pastas AppData e ProgramData

Não copie essas pastas inteiras indiscriminadamente esperando restaurar todos os programas.

Mas determinados aplicativos armazenam configurações importantes nesses locais.

A análise deve ser feita por software.

---

14. Confirme o backup antes de formatar

Não basta iniciar uma cópia.

Abra o destino e verifique se os arquivos importantes realmente estão presentes.

Se possível, teste a abertura de alguns documentos.

---

15. Tenha os instaladores ou fontes de download

Uma lista de programas ajuda, mas é melhor saber também onde obter cada software novamente.

Prefira sempre:

• site oficial;
• Microsoft Store;
• winget;
• portal oficial da empresa.

Evite sites aleatórios de download.

---

Erro comum 1 — Tirar apenas uma foto de Aplicativos Instalados

Uma captura de tela pode ajudar, mas normalmente contém pouca informação.

Um CSV permite:

• pesquisar;
• filtrar;
• ordenar;
• comparar.

Para manutenção técnica, é muito mais útil.

---

Erro comum 2 — Usar somente winget list e considerar o inventário completo

winget list é excelente.

Mas, dependendo do objetivo, consultar também Registro, Appx, serviços e drivers oferece uma visão mais ampla.

---

Erro comum 3 — Achar que todos os programas aparecem em Program Files

Não.

Existem softwares em:

C:\Program Files
C:\Program Files (x86)
AppData
pastas personalizadas

Além de aplicativos empacotados e programas portáteis.

---

Erro comum 4 — Usar Win32_Product para tudo

Como já explicado, Win32_Product não deve ser a primeira escolha para inventário geral.

Prefira métodos menos intrusivos e mais abrangentes.

---

Erro comum 5 — Remover tudo o que parece desconhecido

Um inventário contém muitos componentes técnicos.

Um nome desconhecido pode pertencer a:

• driver;
• runtime;
• impressora;
• VPN;
• antivírus;
• aplicativo corporativo.

Pesquise antes de desinstalar.

---

Erro comum 6 — Confundir entrada duplicada com erro

Podem existir duas entradas legítimas do mesmo fabricante.

Por exemplo:

componente principal
componente auxiliar
versão 32 bits
versão 64 bits

Analise versão, origem e nome completo.

---

Erro comum 7 — Formatar antes de terminar o inventário

Depois que a instalação anterior foi apagada, algumas informações podem se tornar difíceis de reconstruir.

O inventário deve ser feito antes da manutenção destrutiva.

---

Um fluxo recomendado antes da reinstalação

Podemos resumir:

1. Conversar com o usuário
        ↓
2. Identificar dados importantes
        ↓
3. Gerar inventário
        ↓
4. Fazer backup
        ↓
5. Verificar o backup
        ↓
6. Registrar softwares e licenças
        ↓
7. Registrar impressoras e rede
        ↓
8. Separar drivers especiais
        ↓
9. Reinstalar Windows
        ↓
10. Atualizar Windows e drivers
        ↓
11. Reinstalar programas
        ↓
12. Restaurar dados
        ↓
13. Conferir o inventário

Esse processo reduz bastante a chance de esquecer algo importante.

---

Um inventário também pode ajudar sem formatar

Não pense nesse relatório apenas como preparação para reinstalação.

Ele pode ser útil para diagnóstico.

Imagine que um computador começou a apresentar problemas depois de determinado dia.

Se você possui inventários periódicos, pode comparar:

antes

e:

depois

e procurar:

• novo programa;
• atualização;
• novo serviço;
• driver diferente;
• nova tarefa agendada.

Isso ajuda a reduzir o campo de investigação.

---

Podemos usar esse método em suporte remoto?

Sim.

Um técnico pode orientar o usuário a gerar o relatório e enviar apenas os arquivos necessários.

Mas revise os dados antes do compartilhamento.

Evite enviar informações além do necessário.

---

Posso executar o script em Windows 10?

Grande parte dos comandos apresentados também existe no Windows 10.

Entretanto, disponibilidade e comportamento de determinados cmdlets podem depender da versão do Windows, dos módulos presentes e da configuração da máquina.

Este tutorial foi organizado pensando principalmente no Windows 11.

---

Posso usar no Windows Server?

Algumas consultas são aplicáveis.

Mas Windows Server possui diferenças importantes:

• funções;
• recursos;
• serviços;
• ambiente corporativo;
• políticas;
• múltiplos usuários.

Para servidores, o inventário deve ser adaptado.

---

Posso fazer um inventário em vários computadores da rede?

Sim, tecnicamente é possível automatizar consultas remotas com PowerShell e ferramentas de gerenciamento.

Mas isso exige:

• autorização;
• permissões;
• configuração remota;
• segurança;
• tratamento de credenciais.

Esse é um cenário diferente do tutorial local apresentado aqui.

---

O relatório revela se um programa é vírus?

Não.

Encontrar um programa no Registro não determina se ele é seguro ou malicioso.

Da mesma maneira, ausência no inventário também não significa malware.

Para investigar software suspeito, precisamos analisar outros elementos, como:

• assinatura digital;
• fabricante;
• caminho;
• hash;
• comportamento;
• processos;
• conexões;
• ferramentas de segurança.

---

Posso usar o hash SHA-256 para identificar um programa?

O hash identifica o conteúdo exato de um arquivo.

Por exemplo:

Get-FileHash "C:\Caminho\Programa.exe" -Algorithm SHA256

Ele pode ajudar a verificar integridade ou comparar arquivos.

Mas o hash sozinho não informa automaticamente se o arquivo é seguro.

---

Conclusão

Criar uma lista de programas instalados no Windows 11 pode ser tão simples quanto abrir Configurações.

Mas quando precisamos de um inventário realmente útil para manutenção, migração ou diagnóstico, precisamos ir além.

Neste tutorial utilizamos:

PowerShell
Registro do Windows
winget
Get-AppxPackage
Get-CimInstance
Get-Process
Get-Printer
Get-NetAdapter
Get-PhysicalDisk
Get-ScheduledTask

para construir uma visão muito mais completa da máquina.

Aprendemos também que não existe uma única fonte perfeita.

Programas podem ser registrados:

• para toda a máquina;
• por usuário;
• como aplicativos empacotados;
• como programas portáteis;
• acompanhados de serviços;
• acompanhados de drivers.

Por isso, um bom inventário combina diferentes fontes.

O mais importante é usar o relatório como documentação.

Ele ajuda a responder:

“O que existia neste computador antes da manutenção?”

Essa pergunta parece simples, mas pode economizar muito tempo depois de uma formatação, troca de SSD ou migração.

---

FAQ — Perguntas frequentes

Como ver todos os programas instalados no Windows 11?

A maneira mais simples é abrir:

Configurações
→ Aplicativos
→ Aplicativos instalados

Para criar um relatório, PowerShell, winget e as chaves de desinstalação do Registro fornecem mais informações.

---

Qual comando mostra os programas instalados?

Uma opção rápida é:

winget list

Para inventário estruturado, também podemos consultar as chaves Uninstall pelo PowerShell.

---

Como salvar a lista de programas em CSV?

Você pode consultar o Registro com PowerShell e enviar o resultado para:

Export-Csv

Isso cria um arquivo que pode ser aberto em programas de planilha.

---

Como ver a versão dos programas instalados?

Nas entradas tradicionais, procure:

DisplayVersion

No PowerShell, podemos selecionar essa propriedade junto com DisplayName.

---

Como descobrir o fabricante do programa?

O campo:

Publisher

normalmente contém o fabricante registrado pelo instalador.

Nem todos os programas preenchem esse dado.

---

Como ver a data em que um programa foi instalado?

Algumas entradas possuem:

InstallDate

Entretanto, essa informação pode estar ausente ou ter sido alterada por atualizações e reparos.

Não a trate como prova absoluta da data original.

---

winget list mostra todos os programas?

Ele consegue identificar muitos softwares, mas não deve ser considerado uma fonte universal e perfeita para todo tipo de programa.

Programas portáteis são um exemplo de software que pode não aparecer como instalação tradicional.

---

Programas portáteis aparecem no Registro?

Nem sempre.

Se o software não utiliza instalador nem cria uma entrada própria, ele pode não aparecer nas chaves tradicionais de desinstalação.

---

Get-AppxPackage mostra programas normais?

Ele trabalha principalmente com pacotes Appx/MSIX.

Por isso, é melhor tratá-lo como uma fonte complementar ao inventário de programas tradicionais.

---

Posso usar Win32_Product?

É possível consultá-lo, mas ele não é a melhor escolha para inventário geral.

Além de representar principalmente produtos Windows Installer, consultas históricas a essa classe podem provocar verificações/reconfigurações de pacotes MSI.

---

O CSV faz backup dos programas?

Não.

Ele contém somente informações sobre os programas.

Os aplicativos precisarão ser reinstalados depois de uma formatação.

---

O inventário salva minhas licenças?

Não necessariamente.

Licenças podem depender de conta, chave, assinatura, hardware ou sistemas próprios do fabricante.

---

Posso executar o script sem administrador?

Muitas consultas funcionam sem ele.

Entretanto, executar com privilégios administrativos pode permitir acesso mais completo a determinados dados.

---

Esse script modifica o Windows?

A versão apresentada neste tutorial é voltada principalmente para leitura e exportação de informações.

Ela não foi criada para remover programas ou alterar configurações.

---

É seguro enviar o relatório para outra pessoa?

Revise antes.

Ele pode conter:

• nome do computador;
• usuário;
• programas;
• caminhos;
• adaptadores;
• serviços.

Envie apenas para pessoas autorizadas e somente os arquivos necessários.

---

Precisa de ajuda para inventariar, formatar ou migrar seu computador?

A VMIA – Manutenção e Configuração realiza diagnóstico, manutenção e configuração de computadores Windows, incluindo preparação para formatação, troca de SSD, reinstalação do sistema, instalação de programas, drivers, impressoras, redes e recuperação de configurações.

O atendimento pode ser realizado por acesso remoto ou visita técnica, sempre com agendamento.

VMIA – Manutenção e Configuração

Telefone e WhatsApp: (11) 99779-7772

Site: https://vmia.site

Blog: https://vmia.com.br

WhatsApp: https://whats.vmia.com.br

Endereço: Rua Prof. Sud Menucci, 291 – Vila Mariana – São Paulo – SP – 04017-080

Antes de formatar um computador ou trocar um SSD, documentar corretamente programas, drivers, impressoras e configurações pode evitar muitas horas de trabalho depois.