How to Get All Properties of an Object in PowerShell

If you’ve been working with PowerShell for a while, you’ve probably run into situations where you need to see what properties an object has.

Today, I’m going to walk you through everything you need to know about getting all properties of an object in PowerShell. We will see different methods with examples.

When you run a PowerShell command, you don’t always see everything. PowerShell shows you a default view – usually just the properties it thinks you’ll find most useful. But there’s often way more information hiding under the hood.

For example, when you run Get-Process, you see the process name, CPU usage, and maybe memory. But each process object has dozens of other properties you can access – things like the process ID, start time, thread count, and more.

So, in this type of scenario, you need to get all the properties of an object in PowerShell.

Table of Contents

The Main Methods to Get All Properties in PowerShell

There are several ways to get all properties of an object in PowerShell. Let me show you each one, starting with the most common.

Method 1: Using Get-Member

This is probably the most popular way to see what’s inside an object in PowerShell

Here’s how it works:

Get-Process | Get-Member

This command gets all running processes and pipes them to Get-Member, which shows you all the properties and methods available.

The output looks something like this:

Name                       MemberType     Definition
----                       ----------     ----------
Handles                    AliasProperty  Handles = Handlecount
Name                       AliasProperty  Name = ProcessName
NPM                        AliasProperty  NPM = NonpagedSystemMemorySize64
PM                         AliasProperty  PM = PagedMemorySize64
SI                         AliasProperty  SI = SessionId
VM                         AliasProperty  VM = VirtualMemorySize64
WS                         AliasProperty  WS = WorkingSet64
Parent                     CodeProperty   System.Object Parent{get=GetParentProcess;} ...

Here is the exact output in the screenshot below:

Get All Properties of an Object in PowerShell

To see only properties (and filter out methods, events, etc.):

Get-Process | Get-Member -MemberType Property

This is cleaner and shows you exactly what you’re looking for.

Pro tip: Save the output to a variable first if you’re exploring the same object multiple times:

$process = Get-Process -Name "chrome"
$process | Get-Member -MemberType Property

This way, you’re not repeatedly running commands that might take time to execute.

Check out Get the Type of an Object in PowerShell

Method 2: Using Select-Object *

This method actually shows you the property names AND their values, which is super helpful. Here is an example.

Get-Process -Name "chrome" | Select-Object *

The asterisk (*) tells PowerShell to select all properties. You’ll see output like:

Name                       : chrome
Id                        : 12345
CPU                       : 125.34
StartTime                 : 2/7/2026 9:30:15 AM
...

This is my go-to method when I want to see what data is actually available for a specific object.

If you want to run the same cmdlet on macOS, you might get an error because the process name there is “Google Chrome”.

Get-Process -Name "Google Chrome" | Select-Object *

I run the above PowerShell cmdlet, and you can see the exact output in the screenshot below:

PowerShell Get All Properties of an Object

Output:

Name                       : Google Chrome
Id                         : 14523
PriorityClass              : Normal
FileVersion                : 
HandleCount                : 0
WorkingSet                 : 353107968
PagedMemorySize            : 0
PrivateMemorySize          : 0
VirtualMemorySize          : 753729536
TotalProcessorTime         : 00:00:33.1610843
SI                         : 1
Handles                    : 0
VM                         : 550509543424
WS                         : 353107968
PM                         : 0
NPM                        : 0
Path                       : /Applications/Google Chrome.app/Contents/MacOS/Google Chrome
CommandLine                : 
Parent                     : 
Company                    : 
CPU                        : 33.1610843

Important note: If you’re working with multiple objects, use Select-Object -First 1 to limit the output:

Get-Process | Select-Object -First 1 *

Otherwise, you’ll get all properties for every single process, which can be overwhelming.

Read Get the Type of a Variable in PowerShell

Method 3: Using Format-List *

In PowerShell, you can also use the Format-List * method to get all the properties of an object.

This is similar to Select-Object, but with different formatting:

Get-Process -Name "chrome" | Format-List *

This displays properties in a list format (one per line) instead of a table. It’s easier to read when you have many properties or when property values are long.

The output looks like:

Name      : chrome
Id        : 12345
CPU       : 125.34
StartTime : 2/7/2026 9:30:15 AM

When to use Format-List vs Select-Object:

Use Format-List * when you want a quick, readable view
Use Select-Object * when you might want to export the data or process it further

Here’s why: Format-List produces formatted output that’s meant for display only. Once you pipe it somewhere else, it’s just text. But Select-Object maintains the object structure, so you can keep working with it.

Check out PowerShell Select-Object -First [With Examples]

Method 4: Using Get-Member with Format-Table

If you want a cleaner view of just the property names and types, you can use the Get-Member with Format-Table option.

Here is an example.

Get-Process | Get-Member -MemberType Property | Format-Table Name, Definition -AutoSize

This gives you a nice table showing property names and what type of data they hold (string, integer, datetime, etc.).

Read Measure-Object in PowerShell

Method 5: Accessing PSObject Properties

Every PowerShell object has a hidden property called PSObject that contains metadata about the object itself.

$process = Get-Process -Name "chrome" | Select-Object -First 1
$process.PSObject.Properties

This shows you all properties along with their values and types. It’s more programmatic and useful when you’re writing scripts that need to dynamically work with unknown objects.

You can also do things like:

$process.PSObject.Properties.Name

This gives you just the property names as an array, which you can loop through or manipulate.

Check out PowerShell Select-Object Value Only

Working with Nested Properties

Sometimes objects have properties that are themselves objects with more properties. This can get tricky.

Let’s say you’re working with a service:

$service = Get-Service -Name "wuauserv"
$service | Select-Object *

You might see a property like ServicesDependedOn. If you look at just that property:

$service.ServicesDependedOn

You’ll see it contains other service objects. To see properties of those nested objects:

$service.ServicesDependedOn | Get-Member

Or to see all properties and values:

$service.ServicesDependedOn | Select-Object *

This is where PowerShell’s piping really shines – you can keep drilling down into objects.

Check out Create Custom Objects in PowerShell

Filtering Properties

Sometimes you don’t want ALL properties – just ones that match a certain pattern.

Get properties with specific names:

Get-Process | Get-Member -MemberType Property | Where-Object {$_.Name -like "*Time*"}

This shows only properties with “Time” in the name.

Get properties and values matching a pattern:

Get-Process -Name "chrome" | Select-Object * | Format-List *Id*

This displays only properties with “Id” in the name along with their values.

Dealing with Hidden Properties

Some properties don’t show up by default, even with Select-Object *. These are usually called “NoteProperties” that get added dynamically.

To see absolutely everything:

$process = Get-Process -Name "chrome" | Select-Object -First 1
$process.PSObject.Properties | Select-Object Name, Value, MemberType

This reveals properties you might not see otherwise.

Check out Create a Credential Object in PowerShell

Practical Examples

Let me show you some real-world examples where knowing how to get all properties helps.

Example 1: Finding File Properties

You want to see what information is available about files:

Get-ChildItem C:\Temp\test.txt | Select-Object *

This shows properties like FullName, CreationTime, LastWriteTime, Length, Attributes, and more.

Example 2: Exploring Active Directory Users

You’re working with AD and need to see what user properties exist:

Get-ADUser -Identity username -Properties * | Select-Object *

Note: For Active Directory cmdlets, you often need to specify -Properties * in the original command, not just when selecting.

Example 3: Checking Network Adapter Details

You need detailed info about network adapters:

Get-NetAdapter | Select-Object -First 1 * | Format-List

This reveals properties like LinkSpeed, MediaConnectionState, DriverInformation, and tons more.

Example 4: Building a Custom Report

You want to create a CSV with specific properties:

# First, see what's available
Get-Process -Name "chrome" | Select-Object -First 1 * | Get-Member

# Then select what you need
Get-Process | Select-Object Name, Id, CPU, WorkingSet, StartTime | Export-Csv -Path C:\Temp\processes.csv -NoTypeInformation

Tips and Best Practices

Here are some things I’ve learned over the years:

Always test with one object first. Before running commands on hundreds of objects, pipe to Select-Object -First 1 to see what you’re working with.

Use variables for exploration. Store objects in variables so you can examine them multiple times without re-running expensive commands.

Understand the difference between display and data. Commands like Format-List and Format-Table are for display. Once you use them, you can’t easily process that data further. Save formatting for last.

Pay attention to property types. Some properties are strings, others are integers or datetime objects. Knowing the type helps when you’re filtering or manipulating data.

Use Get-Member to learn. When you encounter a new cmdlet, immediately pipe it to Get-Member to understand what it returns.

Read PowerShell Sort-Object

Common Mistakes to Avoid

Here are some common mistakes you should avoid while working with this.

Mistake 1: Assuming you see everything by default

When you run Get-Process, you don’t see all properties. Always check with Select-Object * or Get-Member.

Mistake 2: Formatting too early

Running something like this:

Get-Process | Format-List * | Where-Object {$_.CPU -gt 100}

Won’t work because Format-List converts the object to formatted text. The CPU property is no longer accessible. Filter first, format last.

Mistake 3: Not specifying -Properties * for some cmdlets

Some cmdlets (especially Active Directory ones) don’t retrieve all properties unless you ask:

Get-ADUser username  # Limited properties
Get-ADUser username -Properties *  # All properties

Wrapping Up

In this tutorial, I explained several methods for retrieving all the properties of an object in PowerShell.

Here’s your quick reference:

Use Get-Member -MemberType Property to see what properties exist
Use Select-Object * to see property names and values
Use Format-List * for a readable display
Use PSObject.Properties for programmatic access

Do let me know in the comments if this tutorial helps you!