Unix-Timestamp

Der Unix-Timestamp ist die Sekundenzahl seit dem 1. Januar 1970, 00:00 Uhr UTC. Er ist die universelle Sprache für Zeit in der Programmierung: kompakt, sortierbar, zeitzonenneutral, ohne Sonderfälle wie Sommerzeit oder Schaltsekunden. Wer mit Logs, APIs, Datenbanken oder Caching arbeitet, kommt am Timestamp nicht vorbei.

Das Tool oben zeigt dir den aktuellen Wert in Echtzeit. Weiter unten kannst du einen beliebigen Timestamp in ein Datum umrechnen oder umgekehrt - in beiden Richtungen, mit lokaler Zeit (Europe/Berlin) und UTC nebeneinander.

Timestamp in Datum umrechnen

Gib einen Unix-Timestamp ein, das Tool zeigt das entsprechende Datum in lokaler Zeit (Berlin) und UTC:

Datum in Timestamp umrechnen

Andersrum: ein Datum (Datum oder Datum mit Uhrzeit) wird zum Timestamp. Die Eingabe wird als Europe/Berlin interpretiert:

Was ist ein Unix-Timestamp?

Ein Unix-Timestamp ist eine Ganzzahl - keine Datumsstruktur, kein String, kein Format mit Trennzeichen. Er zählt die Sekunden, die seit der sogenannten Unix-Epoche vergangen sind: dem 1. Januar 1970 um 00:00:00 Uhr UTC. Dieses Datum wurde damals von den Entwicklern des Unix-Betriebssystems festgelegt - ein willkürlicher Bezugspunkt, der sich aus historischen Gründen weltweit durchgesetzt hat.

Beispiele zur Einordnung:

• 0 = 1. Januar 1970, 00:00:00 UTC
• 1000000000 = 9. September 2001, 01:46:40 UTC (das Internet feierte damals "eine Milliarde Sekunden Unix-Zeit")
• 1577836800 = 1. Januar 2020, 00:00:00 UTC
• 2147483647 = 19. Januar 2038, 03:14:07 UTC (32-Bit-Limit)

Die zentrale Stärke ist die Einfachheit. Zwei Timestamps lassen sich vergleichen wie zwei beliebige Zahlen: der kleinere ist früher. Die Differenz ist die Zeit dazwischen in Sekunden. Es gibt keine Komplikationen mit Monaten unterschiedlicher Länge, Schaltjahren, Sommerzeit oder Zeitzonenwechseln - der Timestamp ist immer UTC und immer sekundengenau.

Auch das Sortieren und Indexieren in Datenbanken ist schnell, weil Integer-Spalten kompakter und effizienter sind als String-Datumsfelder. Ein Eintrag updated_at = 1717718400 liegt klar vor updated_at = 1717804800 - kein String-Vergleich nötig.

Code-Snippets in vier Sprachen

So liest und schreibst du den aktuellen Unix-Timestamp in den vier gängigen Web-Sprachen. Achtung bei JavaScript: dort wird in Millisekunden gezählt, alle anderen in Sekunden.

PHP

// Aktueller Timestamp (Sekunden)
$now = time();                          // 1717804800

// Timestamp -> Datum
echo date('Y-m-d H:i:s', $now);         // "2026-06-07 12:00:00"

// Datum -> Timestamp
$ts = strtotime('2026-06-07 12:00:00'); // interpretiert in Server-Zeitzone

// Mit DateTime und expliziter Zeitzone
$dt = new DateTime('2026-06-07 12:00:00', new DateTimeZone('Europe/Berlin'));
$ts = $dt->getTimestamp();

JavaScript

// Aktueller Timestamp in Millisekunden (!)
const nowMs = Date.now();               // 1717804800000

// In Sekunden umrechnen
const nowSec = Math.floor(Date.now() / 1000);

// Timestamp -> Datum
const d = new Date(1717804800 * 1000);  // wichtig: * 1000
console.log(d.toISOString());           // "2026-06-07T10:00:00.000Z"

// Datum -> Timestamp
const ts = Math.floor(new Date('2026-06-07T12:00:00+02:00').getTime() / 1000);

Python

import time, datetime

# Aktueller Timestamp
now = int(time.time())                  # 1717804800

# Timestamp -> Datum
d = datetime.datetime.fromtimestamp(1717804800, tz=datetime.timezone.utc)
print(d.isoformat())                    # "2026-06-07T10:00:00+00:00"

# Datum -> Timestamp
dt = datetime.datetime(2026, 6, 7, 12, 0, 0,
        tzinfo=datetime.timezone(datetime.timedelta(hours=2)))
ts = int(dt.timestamp())

MySQL

-- Aktueller Timestamp
SELECT UNIX_TIMESTAMP();                -- 1717804800

-- Timestamp -> Datum
SELECT FROM_UNIXTIME(1717804800);       -- "2026-06-07 12:00:00" (Session-TZ)
SELECT FROM_UNIXTIME(1717804800, '%Y-%m-%d %H:%i:%s');

-- Datum -> Timestamp
SELECT UNIX_TIMESTAMP('2026-06-07 12:00:00');

Alle vier Sprachen kennen den Timestamp nativ. Bibliotheken sind nicht nötig - die Funktionen sind seit Jahrzehnten in den Standard-APIs verankert.

Y2038 - der 32-Bit-Überlauf

Das berühmteste Limit des Unix-Timestamps trifft 32-Bit-Systeme. Dort wird der Wert als signed int32 gespeichert, mit einem Wertebereich von -2147483648 bis 2147483647. Die positive Grenze wird am 19. Januar 2038, 03:14:07 UTC erreicht. Die nächste Sekunde wäre 2147483648, was aber als negative Zahl interpretiert wird - der Wert springt auf den 13. Dezember 1901 zurück.

Auswirkungen sind je nach Anwendung unterschiedlich:

• Moderne Server (Linux, macOS, Windows) laufen seit Jahren auf 64 Bit. Der Wertebereich reicht dann bis zum Jahr 292 277 026 596 - kein praktisches Problem.
• Eingebettete Geräte mit alter 32-Bit-Hardware (Router, Sensoren, alte SPS-Steuerungen, Smart-Meter, Auto-Steuergeräte) sind der kritische Bereich. Vieles davon wird bis 2038 noch im Einsatz sein.
• MySQL-TIMESTAMP ist ein 32-Bit-Wert und kann bis 2038 verwendet werden, danach gibt es Probleme. Wer in MySQL Zeitpunkte nach 2038 speichern muss, sollte DATETIME oder BIGINT nutzen.
• JavaScript verwendet 64-Bit-Floats für Datums-Timestamps in Millisekunden. Y2038 ist dort keine Sorge.

Die Industrie arbeitet seit Jahren an der Umstellung auf time_t als 64-Bit-Datentyp. Aktuelle Linux-Kernel seit Version 5.6 unterstützen 64-Bit-Timestamps auch auf 32-Bit-Plattformen. Die Übergangsphase wird vermutlich bis weit nach 2038 reichen, weil viele Geräte nie ein Update bekommen.

Quellen

• RFC 3339 - Date and Time on the Internet ↗
• PHP time() und DateTime-Klasse ↗
• Wikipedia - Year 2038 Problem ↗

Verwandte Anleitungen

• Aktuelle Kalenderwoche - Tool mit Antwort + Jahresübersicht
• Schaltjahr - wann ist das nächste?