Zeitstempel-Konverter (UNIX ↔ Datum)

Konvertiere Epoch-Sekunden/Millisekunden in lesbare Datumsangaben und zurück. Datenschutzfreundlich (100 % clientseitig).

Eingaben und Aktionen

Das Parsen bleibt browserstandardmäßig; dies beeinflusst nur die angezeigten Ergebnisse.
Aktuelle Epoch-Zeit: s · ms

Ergebnis

Ergebnis:

Batch-Konvertierung (ein Wert pro Zeile)

5 interessante Fakten uber UNIX-Zeitstempel

Null ist ein Geburtstag

Ein Zeitstempel von 0 ist der exakte Start der Unix-Epoch: 1970-01-01T00:00:00Z (UTC).

Epoch-Start

Zahle die Ziffern

10 Ziffern = Sekunden; 13 Ziffern = Millisekunden. Füge drei Nullen hinzu oder entferne sie, um zwischen beiden zu wechseln.

Sekunden vs ms

Gleicher Zeitpunkt, unterschiedliche Uhren

Zeitstempel sind zeitzonenunabhängig. London, New York oder Tokio zeigen unterschiedliche Ortszeiten, aber es ist derselbe Zeitpunkt.

Zeitzonen-unabhangig

Das 2038-Problem

Am 19.01.2038 um 03:14:07 UTC laufen 32-Bit-Sekundenzähler über. Moderne 64-Bit-Systeme vermeiden dieses Problem.

32-Bit-Limit

"Z" bedeutet Zulu (UTC)

In ISO-8601 bedeutet ein nachgestelltes Z (z. B. 2025-03-01T10:30:00Z) UTC – dieselbe Zeit überall.

ISO-8601

Uber UNIX / Epoch-Zeit

Ein UNIX-Zeitstempel (oft auch Epoch-Zeit) ist eine einzelne Zahl, die angibt, wie viel Zeit seit der Unix-Epoch vergangen ist: 1970-01-01T00:00:00Z (UTC). Er wird häufig in Logs, Datenbanken und APIs verwendet, weil er kompakt, sortierbar und zeitzonenunabhängig ist.

Kurzfakten

  • Sekunden vs. Millisekunden vs. Nanosekunden:
    • 10 Ziffern → Sekunden (z. B. 1700000000)
    • 13 Ziffern → Millisekunden (z. B. 1700000000000)
    • 16 Ziffern → Mikrosekunden (z. B. 1700000000000000)
    • 19 Ziffern → Nanosekunden (häufig aus hochpräzisen Systemen)
  • Zeitzonenunabhängig: die Zahl steht für einen absoluten Zeitpunkt; nur die Anzeige ändert sich durch Zeitzone/Sommerzeit.
  • Negative Werte stehen für Daten vor 1970-01-01 (z. B. -31536000 → 1969-01-01T00:00:00Z).
  • Y2038-Grenze (32-Bit-Sekunden): 2147483647 → 2038-01-19T03:14:07Z. Moderne Systeme nutzen 64 Bit und haben diese Begrenzung nicht.

Haufige Beispiele

BedeutungSekundenMillisekundenUTC (ISO-8601)
Epoch-Start 0 0 1970-01-01T00:00:00Z
Eine Milliarde Sekunden 1000000000 1000000000000 2001-09-09T01:46:40Z
2038-Grenze (32 Bit) 2147483647 2147483647000 2038-01-19T03:14:07Z
Beispiel aus der Gegenwart 1600000000 1600000000000 2020-09-13T12:26:40Z

Zeitzonen und Sommerzeit

  • Ein Zeitstempel wird in UTC gespeichert. Wenn du ihn in „Europe/London“ oder „America/New_York“ ansiehst, ändert sich nur die dargestellte Zeichenfolge.
  • Sprünge durch Sommerzeit ändern nicht den zugrunde liegenden Zeitstempel, sondern nur die Anzeige der Ortszeit.
  • Für eindeutige Angaben nutze bevorzugt ISO-8601 wie 2025-03-01T10:30:00Z oder mit Offset (z. B. +01:00).

Parsing-Tipps

  • Browser interpretieren einen Datumsstring ohne Zeitzone in der lokalen Zeitzone des Nutzers:
    • 2025-03-01 10:30:00 → Ortszeit
    • 2025-03-01T10:30:00Z → UTC (das nachgestellte Z bedeutet Zulu/UTC)
    • 2025-03-01T10:30:00+05:30 → UTC+5:30
  • Wenn du eine 10-stellige Zahl (Sekunden) einfügst, aber Millisekunden erwartest, multipliziere mit 1000.
  • Wenn du einen 19-stelligen Wert (Nanosekunden) einfügst, teile durch 1,000,000, um Millisekunden zu erhalten.

Wann verwende ich welche Einheit?

  • Sekunden: viele Backend-APIs, Datenbanken, Shell-Tools.
  • Millisekunden: JavaScript-Date, Browser, die meisten Frontend-Anwendungen.
  • Nanosekunden: hochpräzise Logs/Telemetrie; für JS-Date in ms umrechnen.

Epoch-Zeit nach Sprache (Schnellrezepte)

Kopierfreundliche Codebeispiele für häufige Aufgaben: aktuelle Epoch-Zeit holen, ein lesbares Datum → Epoch konvertieren und Epoch → Datum konvertieren.

JavaScript (Browser & Node) 
// current epoch
const s  = Math.floor(Date.now() / 1000); // seconds
const ms = Date.now();                     // milliseconds

// date → epoch
const dt = new Date("2025-03-01T10:30:00Z");
const epochSeconds = Math.floor(dt.getTime() / 1000);

// epoch → date
const d1 = new Date(1700000000 * 1000); // seconds → ms
const d2 = new Date(1700000000000);     // ms
Python 
import time, datetime, calendar

# current epoch
sec = time.time()          # float seconds
ms  = round(time.time()*1000)

# date → epoch (UTC)
dt = datetime.datetime(2025, 3, 1, 10, 30, tzinfo=datetime.timezone.utc)
epoch_seconds = int(dt.timestamp())

# epoch → date (UTC)
dt2 = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
Java 
import java.time.*;

long sec = Instant.now().getEpochSecond();      // current epoch (s)
long ms  = Instant.now().toEpochMilli();        // current epoch (ms)

// date → epoch
Instant ins = Instant.parse("2025-03-01T10:30:00Z");
long epochSeconds = ins.getEpochSecond();

// epoch → date
Instant ins2 = Instant.ofEpochSecond(1700000000);
ZonedDateTime zdt = ins2.atZone(ZoneId.of("UTC"));
C# (.NET) 
using System;

long sec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long ms  = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

// date → epoch
var dto = new DateTimeOffset(2025, 3, 1, 10, 30, 0, TimeSpan.Zero);
long epochSeconds = dto.ToUnixTimeSeconds();

// epoch → date
var dto2 = DateTimeOffset.FromUnixTimeSeconds(1700000000); // UTC
Go 
package main
import ("fmt"; "time")

func main() {
  sec := time.Now().Unix()        // seconds
  ms  := time.Now().UnixMilli()   // milliseconds

  // date → epoch (UTC)
  t, _ := time.Parse(time.RFC3339, "2025-03-01T10:30:00Z")
  fmt.Println(t.Unix())

  // epoch → date
  t2 := time.Unix(1700000000, 0).UTC()
  fmt.Println(t2.Format(time.RFC3339))
}
PHP 
// current epoch
$sec = time();                   // seconds
$ms  = round(microtime(true)*1000);

// date → epoch (UTC recommended)
$dt = new DateTime("2025-03-01T10:30:00Z");
$epoch = $dt->getTimestamp();

// epoch → date
$dt2 = (new DateTime())->setTimestamp(1700000000)->setTimezone(new DateTimeZone("UTC"));
echo $dt2->format(DATE_RFC3339);
Ruby 
# current epoch
s  = Time.now.to_i       # seconds
ms = (Time.now.to_f*1000).to_i

# date → epoch (UTC)
t  = Time.utc(2025,3,1,10,30,0)
s2 = t.to_i

# epoch → date
t2 = Time.at(1700000000).utc
Rust 
use std::time::{SystemTime, UNIX_EPOCH, Duration};

// current epoch
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let sec = now.as_secs();
let ms  = now.as_millis();

// epoch → date (example with chrono)
use chrono::{DateTime, Utc, TimeZone};
let d: DateTime<Utc> = Utc.timestamp_opt(1_700_000_000, 0).unwrap();
Kotlin 
import java.time.Instant
import java.time.ZoneId

val sec = Instant.now().epochSecond
val ms  = Instant.now().toEpochMilli()

// date → epoch
val ins = Instant.parse("2025-03-01T10:30:00Z")
val epochSeconds = ins.epochSecond

// epoch → date
val zdt = Instant.ofEpochSecond(1700000000).atZone(ZoneId.of("UTC"))
Swift 
import Foundation

let sec = Int(Date().timeIntervalSince1970)       // seconds
let ms  = Int(Date().timeIntervalSince1970 * 1000)

// date → epoch (ISO8601)
let iso = ISO8601DateFormatter().date(from: "2025-03-01T10:30:00Z")!
let epoch = Int(iso.timeIntervalSince1970)

// epoch → date
let d = Date(timeIntervalSince1970: 1700000000)
C++ (C++11+) 
#include <chrono>
using namespace std::chrono;

// current epoch
auto now  = system_clock::now();
auto sec  = duration_cast<seconds>(now.time_since_epoch()).count();
auto ms   = duration_cast<milliseconds>(now.time_since_epoch()).count();

// epoch → time_point
auto tp = system_clock::time_point{seconds{1700000000}};
Bash / Unix-Shell 
# current epoch
date +%s                # seconds
python3 - <<'PY'\nimport time; print(round(time.time()*1000))\nPY  # ms fallback

# date → epoch (UTC)
date -u -d "2025-03-01 10:30:00" +%s

# epoch → date (local or -u for UTC)
date -d @1700000000
PowerShell 
# current epoch
$sec = [int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))
$ms  = [int]([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds())

# epoch → date
[DateTimeOffset]::FromUnixTimeSeconds(1700000000).UtcDateTime
PostgreSQL 
-- current epoch (seconds)
SELECT EXTRACT(EPOCH FROM NOW());

-- date → epoch (UTC)
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-03-01 10:30:00+00');

-- epoch → timestamp
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';
MySQL / MariaDB 
-- current epoch
SELECT UNIX_TIMESTAMP();

-- date → epoch (assumes UTC string if suffixed with 'Z')
SELECT UNIX_TIMESTAMP('2025-03-01 10:30:00');

-- epoch → datetime
SELECT FROM_UNIXTIME(1700000000);

Tipp: Bevorzuge ISO-8601-Zeichenfolgen (z. B. 2025-03-01T10:30:00Z) für eindeutige UTC-Werte. Wenn eine API Sekunden erwartet, du aber Millisekunden hast, teile durch 1000 (bzw. multipliziere für die Gegenrichtung).

FAQ

Wird ein UNIX-Zeitstempel von Zeitzonen beeinflusst?

Nein. Der Zeitstempel kodiert einen absoluten Zeitpunkt; nur die Anzeige andert sich durch Zeitzone oder Sommerzeit.

Sekunden oder Millisekunden: Was soll ich verwenden?

Backends und APIs nutzen oft Sekunden; Browser und JavaScript verwenden meist Millisekunden. Dieses Tool unterstutzt beides.

Kann ich Ergebnisse in ISO-8601 kopieren?

Ja. Nutze die UTC-Ausgabe fur ISO-8601-Zeichenfolgen wie YYYY-MM-DDTHH:mm:ssZ.

Ist es privat?

Ja. Alles wird im Browser berechnet, ohne Netzwerkanfragen fur Konvertierungen.

Mehr Tools entdecken