Skip to main content

How to Pipe Command Output to Another Command (|) in Batch Script

The command line is powerful because it's built on a philosophy of small, specialized tools that do one thing well. The true power emerges when you can chain these tools together, creating a data processing assembly line. The pipe operator (|) is the fundamental tool that makes this possible. It allows you to take the output of one command and use it directly as the input for another, without needing temporary files.

This guide will teach you the core concept of piping. You will learn how it connects the Standard Output and Standard Input streams, see how to use it for powerful filtering and processing, and understand its limitations.

The Core Concept: The Pipe Operator (|)​

The pipe operator, represented by a vertical bar (|), creates a pipeline between two commands. It takes the output that the first command would normally print to the screen and "pipes" it directly to the second command as its input.

Think of it like a plumbing pipe: the water (output) from one source flows directly to the next destination, without spilling onto the floor (the screen).

Syntax: CommandA | CommandB

Standard Output and Standard Input Explained​

To understand the pipe, you need to know about the two standard data streams for any command-line program:

  • Standard Output (stdout): This is the normal channel where a program writes its results. When you run DIR, the list of files is its stdout.
  • Standard Input (stdin): This is the channel where a program reads its input from. By default, this is connected to your keyboard.

The pipe operator (|) disconnects CommandA's stdout from the screen and CommandB's stdin from the keyboard, and connects them directly to each other.

Basic Example: A Simple DIR and FIND Filter​

This is the classic example of piping. We want to list all the files in the Windows directory, but we only want to see the ones that are log files.

Without a Pipe​

DIR C:\Windows would produce a very long list of all files.

With a Pipe​

We can pipe this long list to the FIND command to filter it.

@ECHO OFF
ECHO --- Finding all .log files in the Windows directory ---
DIR C:\Windows | FIND /I ".log"

Output: instead of the full list, you get a clean, filtered result containing only the lines that FIND matched.

--- Finding all .log files in the Windows directory ---
10/27/2023  09:00 AM             1,234 setupact.log
10/25/2023  10:15 AM            56,789 WindowsUpdate.log
...

How the Pipe Works (A Step-by-Step Breakdown)​

Let's trace the execution of DIR C:\Windows | FIND /I ".log":

  1. The cmd.exe interpreter sees the pipe and sets up a connection in memory.
  2. DIR C:\Windows starts to execute.
  3. Instead of printing its output (the file list) to the console screen, the operating system redirects it into the memory pipeline.
  4. FIND /I ".log" starts to execute.
  5. Instead of waiting for you to type something on the keyboard, it reads its input directly from the pipeline, which contains the output from DIR.
  6. FIND processes each line it receives, checks if it contains ".log", and if it does, FIND prints its own output to the console.

Chaining Multiple Commands​

You are not limited to just two commands. You can chain multiple pipes together to create more complex filtering operations.

For example, this command gets a list of all services, filters it down to just the service names, and then filters that list again to find a specific service.

SC QUERY | findstr "SERVICE_NAME" | findstr "Spooler"

Common Pitfalls and How to Solve Them​

Problem: Not All Commands Can Receive Piped Input​

This is the most important limitation. The command on the right side of the pipe must be designed to read from Standard Input.

Classic "filter" commands that work well are:

  • FIND
  • FINDSTR
  • SORT
  • MORE

A command like MD (Make Directory) or COPY does not read from Standard Input, so this will not work: ECHO MyNewFolder | MD (This fails).

Solution: There is no workaround. The pipe can only be used with commands that are designed to be filters.

Problem: The Output Format is Messy​

The pipe sends raw text. If the output of the first command has complex formatting, headers, or inconsistent spacing, the second command may not be able to parse it correctly.

Solution: This is why commands with script-friendly output formats (like /B for DIR or /FO CSV for WMIC and tasklist) are so valuable. By generating clean, predictable text, you make it much easier for the next command in the pipeline to do its job.

Practical Example: Finding the PID of a Specific Process​

This is a very common administrative task. We need to find the Process ID (PID) of a running application.

This example shows how a pipeline is often used inside a FOR /F loop's command block to pre-process data before the loop captures it.

@ECHO OFF
SETLOCAL
SET "ProcessName=chrome.exe"
SET "ProcessPID="

ECHO --- Finding the PID for %ProcessName% ---
ECHO.

REM --- The Pipeline ---
REM 1. Get the full list of processes.
REM 2. Pipe it to FINDSTR to get only the line for our process.
REM 3. Use FOR /F to parse that single line and get the PID.
FOR /F "tokens=2" %%P IN ('tasklist ^| findstr /I "%ProcessName%"') DO (
    SET "ProcessPID=%%P"
    GOTO :Found
)

:Found
IF NOT DEFINED ProcessPID (
    ECHO [FAILURE] The process was not found.
) ELSE (
    ECHO [SUCCESS] The PID for %ProcessName% is: %ProcessPID%
)

ENDLOCAL

Conclusion​

The pipe operator (|) is a cornerstone of efficient command-line work. It allows you to build complex operations by chaining together simple, specialized tools.

Key takeaways:

  • The pipe | connects the Standard Output of one command to the Standard Input of another.
  • It is primarily used for filtering (find, findstr), sorting (sort), and paging (more) command output.
  • The command on the right side of the pipe must be a "filter" command that is designed to accept piped input.
  • Piping is often combined with a FOR /F loop to capture the final, processed output in a script.

Table of Contents