Skip to main content

How to Calculate the Number of Days Between Two Dates in a Batch Script

A frequent requirement in logging, reporting, and data processing scripts is to calculate the duration between two dates. You might need to find the age of a file, determine if a license has expired, or calculate how long a task has been running. This task is nearly impossible to do reliably with pure batch script commands. Batch has no native "date" data type; it only understands strings, and its SET /A command is limited to integer math, which cannot handle the complexities of calendars (like different month lengths and leap years).

The only robust and reliable solution is to delegate the calculation to a more powerful, date-aware scripting language that is built into Windows. This guide will teach you the modern, standard, and highly recommended method using PowerShell. You will also learn the classic alternative using VBScript.

The Core Challenge: Batch Has No Date Logic​

You cannot simply subtract one date from another in a batch script. A command like SET /A "Days = 20231101 - 20231031" results in 70, not 1. Any pure-batch solution would require an extraordinarily complex script that manually calculates leap years and days in each month, which is slow and highly prone to error. For this reason, it is not a recommended approach.

PowerShell has native, powerful [datetime] objects and can perform date calculations effortlessly. It can parse date strings, subtract them, and return the difference as a TimeSpan object, from which we can get the total number of days.

PowerShell Command: powershell -Command "(New-TimeSpan -Start 'YYYY-MM-DD' -End 'YYYY-MM-DD').TotalDays"

  • New-TimeSpan: The cmdlet that calculates the duration between two points in time.
  • -Start and -End: The two dates for the calculation.
  • .TotalDays: The property of the result that gives us the exact number of days.

This single command is a complete solution.

The Classic Method: Using a Temporary VBScript​

For compatibility with older systems (pre-Windows 7), VBScript was the standard way to handle this. The logic involves writing a temporary .vbs file, executing it with the cscript engine, and capturing its output.

VBScript Logic: WScript.Echo DateDiff("d", "10/27/2023", "11/15/2023")

  • DateDiff("d", ...): The VBScript function to get the difference in days.

While this works perfectly, it is slower and more cumbersome than the PowerShell one-liner because it requires creating and deleting a temporary file.

Example Script: Capturing the Result from PowerShell​

To use the PowerShell result in your batch script, you must wrap the command in a FOR /F loop to capture its output into a variable.

@ECHO OFF
SET "StartDate=2023-10-01"
SET "EndDate=2023-12-25"
SET "DaysBetween="

ECHO --- Calculating the number of days between two dates ---
ECHO Start: %StartDate%
ECHO End:   %EndDate%
ECHO.

FOR /F %%D IN (
    'powershell -NoProfile -ExecutionPolicy Bypass -Command "(New-TimeSpan -Start '%StartDate%' -End '%EndDate%').TotalDays"'
) DO (
    SET "DaysBetween=%%D"
)

ECHO The number of days between the two dates is: %DaysBetween%

Common Pitfalls and How to Solve Them​

  • Date Formats: This is the most critical pitfall. Date parsing is highly dependent on the system's regional settings (MM/DD/YYYY vs. DD/MM/YYYY). A script that works in the US might fail in the UK.

    • Solution: The most robust solution is to always format your dates into the ISO 8601 standard (YYYY-MM-DD) before passing them to PowerShell, as shown in the examples. PowerShell's parser handles this format universally and without ambiguity.

  • PowerShell Execution Policy: On a highly restricted system, the PowerShell command could be blocked.

    • Solution: As shown in the script, using the -ExecutionPolicy Bypass switch is a robust way to ensure your command runs, regardless of the system policy.

Practical Example: Calculating the Age of a File in Days​

This script is a perfect real-world use case. It gets a file's "last modified" date, gets the current date, and then uses the PowerShell method to calculate how many days old the file is.

@ECHO OFF
SETLOCAL
SET "TargetFile=C:\Windows\System32\kernel32.dll"

ECHO --- Calculating the age of a file ---
ECHO File: "%TargetFile%"
ECHO.

IF NOT EXIST "%TargetFile%" (ECHO File not found. & GOTO :EOF)

REM --- Step 1: Get the file's last modified date and format it ---
FOR %%F IN ("%TargetFile%") DO (
    SET "FileDateRaw=%%~tF"
)
REM This parsing is for a US-style date "MM/DD/YYYY HH:MM AM/PM"
SET "FileDateFormatted=%FileDateRaw:~10,4%-%FileDateRaw:~4,2%-%FileDateRaw:~7,2%"
ECHO File's Last Modified Date: %FileDateFormatted%

REM --- Step 2: Get today's date and format it ---
FOR /F "tokens=2 delims==" %%I IN ('WMIC OS GET LocalDateTime /VALUE') DO SET "dt=%%I"
SET "TodayFormatted=%dt:~0,4%-%dt:~4,2%-%dt:~6,2%"
ECHO Today's Date: %TodayFormatted%

REM --- Step 3: Call PowerShell to calculate the difference ---
SET "FileAge="
FOR /F %%A IN (
    'powershell -Command "(New-TimeSpan -Start '%FileDateFormatted%' -End '%TodayFormatted%').TotalDays"'
) DO (
    SET "FileAge=%%A"
)

ECHO.
ECHO The file is %FileAge% days old.

ENDLOCAL

Conclusion​

Calculating the number of days between two dates is a task that demonstrates the limitations of pure batch and the power of leveraging modern, built-in tools.

  • A pure-batch solution is not recommended as it is extraordinarily complex and unreliable.
  • The PowerShell New-TimeSpan method is the modern, robust, and highly recommended approach. It is fast, accurate, and handles all date logic internally.
  • The VBScript DateDiff method is a valid alternative, especially for ensuring compatibility with very old Windows systems.
  • To avoid errors, always try to format your dates as YYYY-MM-DD before passing them to the calculation engine.

Table of Contents