Dateien älter als X Tage löschen mit PowerShell

Mit PowerShell kannst Du Dateien älter als X Tage löschen, anstatt evtl. einen ganzen Ordner zu löschen. Das ist besonders interessant bei älteren Dateien, die nach einer bestimmten Zeit gelöscht werden sollen. Dies kann auch aus Speichermangel notwendig sein. Oder es können damit auch Aufbewahrungsfristen eingehalten werden.

In dieser Anleitung arbeitest Du zunächst mit einer Vorschau. Anschließend kannst Du die Auswahl um Unterordner, Dateitypen und Ausnahmen erweitern. Für eine regelmäßige Bereinigung findest Du außerdem ein Skript mit Protokollierung und einen passenden Ablauf für die Windows-Aufgabenplanung.

Wie löscht PowerShell Dateien, die älter als X Tage sind?

PowerShell verbindet dafür drei Aufgaben: Get-ChildItem ermittelt die Dateien, Where-Object vergleicht deren Zeitstempel mit einem Stichtag und Remove-Item übernimmt die Löschung. Für die Altersgrenze wird häufig das Datum der letzten Änderung verwendet. Die Bedingung lautet dann: Änderungsdatum liegt vor dem aktuellen Zeitpunkt abzüglich X Tagen.

Wichtig: Remove-Item verschiebt Dateien nicht in den Windows-Papierkorb. Verlasse Dich deshalb nicht darauf, eine versehentliche Löschung anschließend einfach rückgängig machen zu können. Die Beispiele setzen voraus, dass die betroffenen Dateien entbehrlich oder unabhängig gesichert sind.

LastWriteTime, CreationTime oder LastAccessTime: Welches Datum zählt?

Eigenschaft	Bedeutung	Eignung für die Bereinigung
LastWriteTime	Zeitpunkt der letzten Änderung.	Sinnvoll, wenn seit X Tagen nicht mehr geschriebene Dateien entfernt werden sollen.
CreationTime	Erstellungszeitpunkt des Dateieintrags im Dateisystem.	Passend für eine ausdrücklich am Erstellungsdatum orientierte Regel. Nicht zwingend das ursprüngliche Entstehungsdatum des Inhalts.
LastAccessTime	Gespeicherter Zeitpunkt des letzten Zugriffs.	Keine verlässliche Standardregel für „seit X Tagen ungenutzt“, weil Aktualisierungen deaktiviert oder verzögert sein können.

Die folgenden Grundbeispiele verwenden LastWriteTime. Eine vor einem Jahr angelegte Datei bleibt damit erhalten, wenn sie gestern geändert wurde. Eine reine Altersprüfung sagt allerdings nichts darüber aus, ob eine Datei fachlich noch benötigt wird.

Vorbereitung: Ordner eingrenzen und Daten sichern

Verwende für den ersten Durchlauf einen überschaubaren Testordner. Als Beispiel dient hier C:\Daten\Logs. Ersetze diesen Pfad durch einen vorhandenen Ordner, dessen Inhalt Du kennst. Ein komplettes Laufwerk, Windows-Verzeichnisse oder Anwendungsordner sind kein geeigneter Ausgangspunkt für eine pauschale Altersbereinigung.

Die Befehle sind für Windows PowerShell 5.1 und PowerShell 7 unter Windows ausgelegt. Öffne über das Startmenü eine PowerShell oder wähle im Windows Terminal ein PowerShell-Profil. Administratorrechte sind nicht grundsätzlich erforderlich. Dein Konto benötigt aber die passenden Berechtigungen zum Auflisten und Löschen. Zur Einordnung Deiner Installation hilft Dir unsere Anleitung zu PowerShell Download und Update.

Bereinige möglichst nur abgeschlossene Dateien. Ein altes Änderungsdatum beweist nicht, dass keine Anwendung mehr damit arbeitet. Bei Ordnerverknüpfungen, Junctions oder Cloud-Platzhaltern solltest Du zunächst klären, welche tatsächlichen Speicherorte und Inhalte betroffen sind.

Dateien älter als 30 Tage löschen: Schritt für Schritt mit PowerShell

Führe die folgenden Schritte nacheinander in derselben PowerShell-Sitzung aus. Dabei werden zunächst nur Dateien direkt im angegebenen Ordner berücksichtigt. Unterordner kommen erst im nächsten Abschnitt hinzu.

1. Zielordner und Altersgrenze festlegen

$Ordner = 'C:\Daten\Logs'
[int]$Tage = 30

if ($Tage -lt 1) {
    throw 'Die Anzahl der Tage muss mindestens 1 sein.'
}

if (-not (Test-Path -LiteralPath $Ordner -PathType Container)) {
    throw "Der Zielordner existiert nicht: $Ordner"
}

$Stichtag = (Get-Date).AddDays(-$Tage)

"Zielordner: $Ordner"
"Stichtag: $Stichtag"

Für sieben Tage setzt Du $Tage = 7, für 90 Tage entsprechend $Tage = 90. Das Minuszeichen in AddDays(-$Tage) legt den Stichtag in die Vergangenheit. Ein positiver Wert würde in die Zukunft zeigen und könnte auch sehr junge Dateien auswählen.

Die Uhrzeit wird mit berücksichtigt: Läuft die Auswahl am 25. September um 14:00 Uhr, liegt der lokale Stichtag bei 30 Tagen am 26. August um 14:00 Uhr. Er wird einmal berechnet und anschließend für die gesamte Auswahl verwendet.

2. Betroffene Dateien anzeigen

$Dateien = @(Get-ChildItem -LiteralPath $Ordner -File -ErrorAction Stop |
    Where-Object { $_.LastWriteTime -lt $Stichtag })

$Dateien |
    Sort-Object LastWriteTime |
    Select-Object FullName, LastWriteTime, Length

"Gefundene Dateien: $($Dateien.Count)"

Der Parameter -File begrenzt die Auswahl auf Dateien. Der PowerShell-Befehl Get-ChildItem liefert dafür Dateiobjekte mit Eigenschaften wie vollständigem Pfad, Änderungsdatum und Größe. Length zeigt die Größe in Bytes. Die Schreibweise @(...) sorgt dafür, dass auch null oder ein Treffer als Sammlung behandelt wird.

-lt bedeutet „kleiner als“. Beim Datumsvergleich entspricht das „liegt vor“. Eine Datei mit exakt demselben Zeitstempel wie der Stichtag wird nicht ausgewählt. Wie sich solche Bedingungen kombinieren lassen, erklären unsere PowerShell-Vergleichsoperatoren.

3. Die Löschung mit WhatIf simulieren

foreach ($Datei in $Dateien) {
    Remove-Item -LiteralPath $Datei.FullName -WhatIf
}

Jetzt zeigt PowerShell die geplanten Löschvorgänge an, ohne die ausgewählten Dateien zu entfernen. Prüfe insbesondere die vollständigen Pfade. -LiteralPath behandelt den angegebenen Namen wörtlich. Dadurch werden beispielsweise eckige Klammern in einem Dateinamen nicht als Platzhalter interpretiert.

Eine passende Vorschau bestätigt Deine Auswahl, garantiert aber noch keinen erfolgreichen Löschvorgang. Zugriffsrechte, Dateisperren oder Veränderungen im Ordner können beim tatsächlichen Ausführen weiterhin eine Rolle spielen.

4. Geprüfte Dateien mit Bestätigung löschen

Erst nach der Kontrolle führst Du diesen Schritt aus. Im Gegensatz zur Vorschau löscht er tatsächlich Dateien. -Confirm fordert dafür eine Bestätigung an.

foreach ($Datei in $Dateien) {
    $Datei.Refresh()

    if ($Datei.Exists -and $Datei.LastWriteTime -lt $Stichtag) {
        Remove-Item -LiteralPath $Datei.FullName -Confirm -ErrorAction Stop
    }
}

Mit Refresh() werden die gespeicherten Dateiinformationen erneut eingelesen. Eine inzwischen geänderte Datei wird dadurch übersprungen, wenn ihr Änderungsdatum nicht mehr zur Altersregel passt. Das ist keine vollständige Absicherung gegen gleichzeitig arbeitende Programme. Für aktive Arbeitsverzeichnisse brauchst Du einen abgestimmten Bereinigungszeitpunkt.

Wurde der Ordner oder die Altersgrenze geändert, beginnst Du wieder bei Schritt 1. Eine bereits gefüllte Variable $Dateien aktualisiert sich nicht automatisch, nur weil Du $Ordner oder $Tage neu setzt.

Unterordner, Dateitypen und Ausnahmen berücksichtigen

Die folgenden Varianten ersetzen jeweils die Dateiauswahl aus Schritt 2. Sie verwenden $Ordner und $Stichtag aus Schritt 1 und löschen zunächst nichts. Kontrolliere danach erneut die Treffer und die WhatIf-Vorschau.

Alte Dateien einschließlich Unterordnern auswählen

$Dateien = @(Get-ChildItem -LiteralPath $Ordner -File -Recurse -ErrorAction Stop |
    Where-Object { $_.LastWriteTime -lt $Stichtag })

-Recurse erweitert die Suche auf Unterordner. Die Löschung erfolgt weiterhin einzeln anhand der gefundenen Dateien. Leere Ordner bleiben erhalten.

Verwechsle das nicht mit einer Auswahl alter Ordner, die anschließend mit Remove-Item -Recurse gelöscht werden. Ein alter Ordner kann neue Dateien enthalten. Eine Altersprüfung des Ordners schützt diese Inhalte nicht. Kontrolliere vor einer rekursiven Bereinigung außerdem vorhandene Verzeichnisverknüpfungen und deren Ziele.

Nur alte LOG-Dateien löschen

$Dateien = @(Get-ChildItem -LiteralPath $Ordner -File -Filter '*.log' -ErrorAction Stop |
    Where-Object {
        $_.Extension -eq '.log' -and $_.LastWriteTime -lt $Stichtag
    })

Mit -Filter '*.log' wird schon beim Auflisten nach passenden Namen gefiltert. Der zusätzliche Vergleich von Extension grenzt die Endung eindeutig ein. Für viele Dateien ist das günstiger, als zunächst sämtliche Dateitypen zu laden. Für LOG-Dateien in Unterordnern ergänzt Du zusätzlich -Recurse bei Get-ChildItem.

Mehrere Dateiendungen zulassen und einzelne Namen ausschließen

$Dateien = @(Get-ChildItem -LiteralPath $Ordner -File -ErrorAction Stop |
    Where-Object {
        $_.LastWriteTime -lt $Stichtag -and
        $_.Extension -in @('.log', '.tmp') -and
        $_.Name -notin @('aktuell.log', 'behalten.log')
    })

Diese Auswahl berücksichtigt LOG- und TMP-Dateien, schützt aber die beiden ausdrücklich genannten Dateinamen. Alle Bedingungen sind mit -and verbunden und müssen gleichzeitig erfüllt sein. Die Namensausnahme gilt bei einer zusätzlich aktivierten rekursiven Suche in jedem durchsuchten Ordner.

Eine solche Ausnahme ist keine Erkennung geöffneter Dateien. Lege bewusst fest, welche Namen Deine Anwendung für aktive Protokolle verwendet. Weitere Grundlagen zur Anpassung von Befehlen findest Du im Leitfaden zu PowerShell-Parametern.

Nach Erstellungsdatum oder ab Mitternacht bereinigen

Soll ausschließlich das Erstellungsdatum entscheiden, ersetzt Du in Auswahl und erneuter Prüfung LastWriteTime durch CreationTime. Ändere nicht nur einen der beiden Vergleiche, sonst verwenden Vorschau und tatsächliche Löschung unterschiedliche Regeln.

Für eine Grenze am Beginn eines Kalendertages berechnest Du den Stichtag stattdessen so:

$Stichtag = (Get-Date).Date.AddDays(-$Tage)

Bei -lt bleiben alle Dateien vom Tag des Stichtags erhalten. Nur frühere Zeitpunkte werden ausgewählt. Formatiere Datumswerte für den Vergleich nicht mit -Format in Text um. Für eine verlässliche Reihenfolge sollen echte Datumswerte verglichen werden.

Alte Dateien automatisch löschen: PowerShell-Skript mit Protokoll

Für eine wiederkehrende Bereinigung ist ein gespeichertes Skript übersichtlicher als eine lange Befehlszeile. Das folgende Beispiel verarbeitet bewusst nur LOG-Dateien direkt in C:\Daten\Logs. Es durchsucht keine Unterordner und überspringt Dateien mit dem Attribut ReparsePoint. Damit werden beispielsweise entsprechend gekennzeichnete Dateiverknüpfungen nicht zur Löschung ausgewählt.

Der Testlauf ist zunächst eingeschaltet. Er erzeugt ein Sitzungsprotokoll, löscht aber keine Zieldateien. Das Skript berechnet die Altersgrenze in UTC und vergleicht dazu passend LastWriteTimeUtc. Dadurch hängt die verstrichene Dauer nicht vom Wechsel zwischen Sommerzeit und Winterzeit ab. Protokollierte UTC-Uhrzeiten können entsprechend von der lokalen Uhrzeit abweichen.

Skript speichern und zuerst im Testmodus ausführen

Lege den Ordner C:\Scripts an und speichere den folgenden Inhalt als AlteDateienLoeschen.ps1. Passe die Einstellungen am Anfang an. Das Protokollverzeichnis muss außerhalb des zu bereinigenden Bereichs liegen. Verwende einen gewöhnlichen, bekannten Dateisystempfad ohne verknüpfte Verzeichnisse im Pfadverlauf. Die Prüfungen im Beispiel ersetzen keine vollständige Absicherung gegen fremde Änderungen am Verzeichnis.

# Nur diese Einstellungen an Deinen Anwendungsfall anpassen.
$Ordner = 'C:\Daten\Logs'
[int]$Tage = 30
$Dateiendung = '.log'
$Testlauf = $true
$ProtokollOrdner = 'C:\Scripts\Protokolle'

$ErrorActionPreference = 'Stop'
$ProtokollGestartet = $false
$ExitCode = 0
$Fehler = 0
$Geloescht = 0

try {
    if ($Tage -lt 1) {
        throw 'Die Aufbewahrungsdauer muss mindestens einen Tag betragen.'
    }

    $StichtagUtc = [DateTime]::UtcNow.AddDays(-$Tage)
    $Ziel = Get-Item -LiteralPath $Ordner -Force

    if ($Ziel -isnot [System.IO.DirectoryInfo]) {
        throw 'Das Ziel muss ein Dateisystemordner sein.'
    }

    if ($Ziel.FullName -eq $Ziel.Root.FullName) {
        throw 'Ein Laufwerks- oder Freigabestamm ist als Ziel nicht erlaubt.'
    }

    if ($Ziel.Attributes -band [System.IO.FileAttributes]::ReparsePoint) {
        throw 'Ein verknuepfter Zielordner wird nicht verarbeitet.'
    }

    New-Item -ItemType Directory -Path $ProtokollOrdner -Force | Out-Null

    $Logdatei = Join-Path $ProtokollOrdner (
        'Bereinigung-{0}.txt' -f (Get-Date -Format 'yyyyMMdd-HHmmss-fff')
    )

    Start-Transcript -Path $Logdatei -NoClobber | Out-Null
    $ProtokollGestartet = $true

    Write-Host "Ordner: $($Ziel.FullName)"
    Write-Host "Testlauf: $Testlauf; Dateiendung: $Dateiendung"
    Write-Host "Stichtag UTC: $($StichtagUtc.ToString('o'))"

    $Dateien = @(Get-ChildItem -LiteralPath $Ziel.FullName -File -Filter "*$Dateiendung" |
        Where-Object {
            $_.Extension -eq $Dateiendung -and
            $_.LastWriteTimeUtc -lt $StichtagUtc -and
            -not ($_.Attributes -band [System.IO.FileAttributes]::ReparsePoint)
        })

    Write-Host "Gefundene Kandidaten: $($Dateien.Count)"

    foreach ($Datei in $Dateien) {
        try {
            $Aktuell = Get-Item -LiteralPath $Datei.FullName

            if ($Aktuell -isnot [System.IO.FileInfo]) {
                continue
            }

            if ($Aktuell.Attributes -band [System.IO.FileAttributes]::ReparsePoint) {
                continue
            }

            if ($Aktuell.LastWriteTimeUtc -ge $StichtagUtc) {
                continue
            }

            if ($Testlauf) {
                Remove-Item -LiteralPath $Aktuell.FullName -WhatIf
            }
            else {
                Remove-Item -LiteralPath $Aktuell.FullName -Confirm:$false
                $Geloescht++
                Write-Host "GELOESCHT: $($Aktuell.FullName)"
            }
        }
        catch {
            $Fehler++
            Write-Warning "FEHLER bei '$($Datei.FullName)': $($_.Exception.Message)"
        }
    }

    Write-Host "Abschluss: $Geloescht geloescht; $Fehler Fehler."

    if ($Fehler -gt 0) {
        $ExitCode = 1
    }
}
catch {
    $ExitCode = 1
    Write-Error -Message $_.Exception.Message -ErrorAction Continue
}
finally {
    if ($ProtokollGestartet) {
        try {
            Stop-Transcript | Out-Null
        }
        catch {
            $ExitCode = 1
            Write-Warning "Protokollabschluss fehlgeschlagen: $($_.Exception.Message)"
        }
    }
}

exit $ExitCode

Das Skript sammelt die Kandidaten vollständig, bevor es mit Löschversuchen beginnt. Scheitert bereits das Auflisten, wird keine nur teilweise ermittelte Trefferliste abgearbeitet. Vor jedem Löschversuch werden Dateityp und Änderungsdatum erneut geprüft. Ein Fehler bei einer einzelnen Datei wird protokolliert; die übrigen Kandidaten werden weiter bearbeitet.

Der Rückgabecode 0 steht für einen Lauf ohne erkannten Fehler, auch wenn keine Datei zur Regel passt. Bei erfassten Fehlern liefert das Skript 1. Die Protokolle entstehen unter C:\Scripts\Protokolle. Begrenze auch deren Aufbewahrung nach einer eigenen, bewusst gewählten Regel und schütze sie vor unberechtigtem Zugriff, da sie Dateipfade enthalten.

Starte den ersten Test aus einer PowerShell mit folgendem Aufruf:

powershell.exe -NoProfile -File "C:\Scripts\AlteDateienLoeschen.ps1"

Nach Prüfung des Protokolls setzt Du im Skript $Testlauf = $false. Ab dem nächsten Aufruf wird tatsächlich und ohne einzelne Bestätigungsabfragen gelöscht. Hinweise zum Speichern und Starten findest Du auch in unserer Anleitung zu Skripten in PowerShell.

Bereinigung täglich über die Aufgabenplanung starten

1. Drücke Windows-Taste + R, gib taskschd.msc ein und öffne die Aufgabenplanung.
2. Wähle „Aufgabe erstellen“ und vergib beispielsweise den Namen „Alte LOG-Dateien bereinigen“. Verwende ein Konto mit den nötigen Ordnerrechten.
3. Lege unter „Trigger“ einen täglichen Zeitpunkt fest, an dem keine aktive Verarbeitung im Zielordner stattfindet.
4. Füge unter „Aktionen“ die Aktion „Programm starten“ mit den nachfolgenden Angaben hinzu.
5. Prüfe Bedingungen und Einstellungen. Verhindere parallele Instanzen derselben Aufgabe und teste einen manuellen Start zunächst mit eingeschaltetem Testlauf.

Programm oder Skript:

C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe

Argumente hinzufügen:

-NoProfile -NonInteractive -File "C:\Scripts\AlteDateienLoeschen.ps1"

Starten in:

C:\Scripts

Der Programmpfad gilt für eine Windows-Installation unter C:\Windows. Bei einem abweichenden Windows-Verzeichnis passt Du ihn an. Für PowerShell 7 verwendest Du stattdessen den tatsächlichen Pfad zu pwsh.exe. Trage in „Starten in“ nur das Verzeichnis ohne Anführungszeichen ein.

Soll die Aufgabe ohne angemeldeten Benutzer laufen, konfigurierst Du dafür das Ausführungskonto und dessen Anmeldung entsprechend. „Mit höchsten Privilegien ausführen“ ist keine allgemeine Voraussetzung. Kontrolliere nach dem Test sowohl das Protokoll als auch das letzte Ausführungsergebnis der Aufgabe. Ein ausgeschalteter Rechner führt den geplanten Lauf nicht zum vorgesehenen Zeitpunkt aus.

Typische Fehler beim Löschen alter Dateien mit PowerShell

Zugriff verweigert, Schreibschutz oder Datei in Verwendung

Prüfe zunächst, ob das ausführende Konto den Ordner auflisten und die betreffenden Dateien löschen darf. Bei einer Dateisperre musst Du die Anwendung oder den dazugehörigen Arbeitsablauf berücksichtigen. Ein pauschales Beenden fremder Prozesse ist dafür keine sinnvolle Standardlösung.

-Force hat unterschiedliche Aufgaben: Bei Get-ChildItem kann es versteckte und Systemdateien in die Auswahl aufnehmen. Bei Remove-Item ermöglicht es unter anderem das Entfernen schreibgeschützter Dateien. Es umgeht aber weder Zugriffsberechtigungen noch beliebige Dateisperren und ersetzt keine Bestätigungssteuerung. Setze es nicht vorsorglich überall ein. Die Möglichkeiten des Befehls erläutert unser Beitrag zu PowerShell Remove-Item.

Das Skript wird wegen der Ausführungsrichtlinie blockiert

Prüfe mit Get-ExecutionPolicy -List, welche Richtlinien gelten. Ob und in welchem Bereich Du eine Richtlinie ändern darfst, hängt von Deiner Umgebung ab. In verwalteten Firmennetzen können zentrale Vorgaben maßgeblich sein. Schalte die Prüfung nicht pauschal für den gesamten Rechner aus. Unsere Anleitung zu Set-ExecutionPolicy erklärt die Konfiguration ausführlicher.

Es werden keine Dateien gefunden oder zu viele ausgewählt

Kontrolliere zuerst Zielpfad, Stichtag und das tatsächlich verwendete Dateidatum. Ohne -Recurse werden Dateien in Unterordnern nicht erfasst. Ohne -Force bleiben versteckte Dateien standardmäßig außerhalb der Auflistung. Ein zu weiter Dateifilter oder eine versehentlich in die Zukunft gesetzte Grenze kann dagegen deutlich mehr Treffer liefern als erwartet.

Unterdrücke Probleme nicht einfach mit -ErrorAction SilentlyContinue. Sonst sieht eine Bereinigung möglicherweise erfolgreich aus, obwohl wichtige Bereiche gar nicht verarbeitet wurden.

Praxistipp: Aufbewahrungsregeln statt pauschaler Löschaktionen

Eine sinnvolle Bereinigung beginnt bei der Ordnerstruktur. Halte aktive Arbeitsdateien und abgeschlossene Ausgaben möglichst getrennt. Lege anschließend pro Ordner fest, welche Dateitypen wie lange benötigt werden. So muss ein Löschskript weniger Ausnahmen erraten und bleibt leichter nachvollziehbar.

Bei Unsicherheit ist ein separates Archiv der bessere Zwischenschritt. Mit Move-Item lassen sich Dateien zunächst verschieben, wobei Namenskonflikte und der Zugriff betroffener Anwendungen vorher geklärt werden müssen. Ein Archiv auf demselben Datenträger ersetzt allerdings keine unabhängige Datensicherung.

Geht es hauptsächlich um gewöhnliche temporäre Windows-Dateien, kann die integrierte automatische Bereinigung temporärer Dateien unter Windows 11 besser passen. PowerShell lohnt sich vor allem dort, wo Du eine eigene, klar abgegrenzte Aufbewahrungsregel benötigst.

FAQ: Häufige Fragen zum Löschen alter Dateien mit PowerShell

Fazit: Dateien nach Alter löschen, ohne die Kontrolle zu verlieren

Dateien älter als X Tage mit PowerShell zu löschen, ist mit einer klaren Aufbewahrungsregel und mit Hilfe von PowerShell gut durchführbar. Wichtig ist, dass vor dem eigentlichen Löschvorgang ein Backup der Daten angefertigt wurde. Starte immer mit dem manuellen Testlauf und automatisiere erst dann, wenn alles funktioniert.