Skip to main content

How to Find Where a Command is Located (WHERE) in Batch Script

When you type a command like git or python into the command prompt, how does Windows know where to find the actual git.exe or python.exe file? It searches through a list of directories defined in the PATH environment variable. In batch scripting, you often need to perform this same lookup to verify that a required tool is installed and available, or to diagnose path issues where the wrong version of a program is being run.

This guide will teach you how to use the powerful, built-in WHERE command. You will learn how to use it to find the exact location of any executable, how to find all instances of a command if multiple exist, and how to use it with %ERRORLEVEL% to create robust prerequisite checks in your scripts.

The Core Command: WHERE​

The WHERE command is a command-line utility that searches for files matching a specific pattern within the directories defined in the PATH variable, as well as the current directory. It is the batch script equivalent of the which or whereis commands in Linux.

The basic syntax is: WHERE [options] pattern

For finding commands, the pattern is simply the name of the executable.

Basic Example: Locating a Command​

For example, let's find the location of the notepad.exe executable.

C:\> WHERE notepad

In the output, WHERE finds the command and prints its full, absolute path.

C:\Windows\System32\notepad.exe

If the command is not found, WHERE will print an informational message and set a non-zero exit code.

How the Search Works (Using the PATH)​

The WHERE command mimics the exact same process cmd.exe uses when you try to run a command:

  1. It checks the current directory first.
  2. Then, it goes through every single directory listed in your %PATH% environment variable, in order.
  3. In each directory, it looks for a file matching the name you provided. It also automatically checks for extensions in the %PATHEXT% variable (like .EXE, .CMD, .BAT), so you don't need to type WHERE notepad.exe.

The first match it finds is the one it reports, which is the same one that would run if you typed the command.

Finding All Occurrences of a Command (/R)​

Sometimes, you might have multiple versions of a tool installed (e.g., Python 2 and Python 3). This can cause conflicts. The /R switch tells WHERE to perform a Recursive search and find all matches, not just the first one.

C:\> WHERE /R C:\ python.exe

As seen in the output, this command might reveal multiple installations, helping you diagnose path issues.

c:\Python27\python.exe
c:\Users\Admin\AppData\Local\Programs\Python\Python39\python.exe

Using ERRORLEVEL for Scripting (The Main Use Case)​

For automation, you usually don't need the path; you just need to know if the command exists at all. WHERE sets the %ERRORLEVEL% variable based on the outcome, which is perfect for scripting.

  • %ERRORLEVEL% = 0: The command was found.
  • %ERRORLEVEL% <> 0: The command was not found.

For example, this script checks if git is installed and available before proceeding.

@ECHO OFF
ECHO Checking for Git installation...

REM Run WHERE silently by redirecting its output to NUL.
WHERE git > NUL 2> NUL

IF %ERRORLEVEL% EQU 0 (
    ECHO [SUCCESS] Git is installed and available in the PATH.
) ELSE (
    ECHO [FAILURE] Git was not found. Please install it and ensure it's in the PATH.
)

Common Pitfalls and How to Solve Them​

Problem: It Can't Find Internal Commands (like ECHO)​

The WHERE command can only find external commands, programs that exist as separate files on the disk (e.g., .exe, .bat). It cannot find commands that are built directly into the command processor (cmd.exe).

Example of script with error:

C:\> WHERE CD
INFO: Could not find files for the given pattern(s).

This is true for commands like CD, MD, SET, IF, ECHO, GOTO, etc.

Solution: This is expected behavior. You should only use WHERE to check for external dependencies that might be missing from a system. You can always assume that internal commands are available.

Problem: Hiding the "File Found" Output​

When using WHERE in a script, you often don't want to see the path printed to the screen if the command is found.

Solution: Redirect the command's output to the NUL device. It's important to redirect both standard output (> NUL) and standard error (2> NUL) to make the command completely silent.

WHERE mytool > NUL 2> NUL

Practical Example: A Prerequisite Checker Script​

This script is designed to run before a complex process. It checks for all required command-line tools and provides a clear report of what is missing.

@ECHO OFF
SETLOCAL
ECHO --- Checking for required software dependencies ---
SET "ErrorCount=0"

CALL :CheckForCommand git
CALL :CheckForCommand curl
CALL :CheckForCommand "ffmpeg"

ECHO.
IF %ErrorCount% GTR 0 (
    ECHO [FAILURE] Found %ErrorCount% missing dependencies. Please install them and try again.
    EXIT /B 1
) ELSE (
    ECHO [SUCCESS] All required tools are available.
)
GOTO :EOF

:CheckForCommand
    SET "CmdToCheck=%~1"
    WHERE %CmdToCheck% > NUL 2> NUL
    IF %ERRORLEVEL% EQU 0 (
        ECHO [OK] Found: %CmdToCheck%
    ) ELSE (
        ECHO [MISSING] Could not find: %CmdToCheck%
        SET /A "ErrorCount+=1"
    )
GOTO :EOF

Conclusion​

The WHERE command is the definitive tool for verifying the existence and location of external programs from a batch script. It allows you to write robust scripts that can gracefully handle missing dependencies.

Key takeaways:

  • Use WHERE command_name to find the exact executable that would run.
  • WHERE searches the current directory and the system PATH.
  • For scripting, the most important result is the %ERRORLEVEL% (0 for found, non-zero for not found).
  • Run the command silently using WHERE command > NUL 2> NUL.
  • Use WHERE as a prerequisite check at the beginning of your scripts to ensure all required tools are available.

Table of Contents