Unix timestamp omrekenen — online converter

Wat is een Unix timestamp (epoch time)?

// Get the current Unix timestamp in JavaScript
const timestampSeconds = Math.floor(Date.now() / 1000);
console.log(timestampSeconds); // → 1741965432

// Milliseconds (native JavaScript)
const timestampMs = Date.now();
console.log(timestampMs); // → 1741965432000

// Convert timestamp back to a Date object
const date = new Date(timestampSeconds * 1000);
console.log(date.toISOString()); // → '2025-03-14T15:37:12.000Z'

// Python equivalent
// import time
// timestamp = int(time.time())  # → 1741965432

Belangrijkste functies

Unix timestamp versus andere datumformaten

Omrekenvoorbeelden

1741965432

2025-03-14T15:37:12Z

946684800

2000-01-01T00:00:00Z

-86400

1969-12-31T00:00:00Z

1741965432000

2025-03-14T15:37:12.000Z

Zo gebruik je het

1. 1

   Kies de omrekenrichting

   Kies "Timestamp → Date" om een Unix timestamp te decoderen naar een mensvriendelijke datum, of "Date → Timestamp" om een kalenderdatum en -tijd om te rekenen naar een Unix timestamp.

2. 2

   Voer je waarde in

   Plak of typ een Unix timestamp (bijv. 1741965432 of 1741965432000) in het invoerveld. De tool herkent automatisch of het seconden, milliseconden of microseconden zijn. Voor Date → Timestamp selecteer je het jaar, de maand, dag, uur, minuut en seconde via de datumkiezer.

3. 3

   Kopieer het omgezette resultaat

   Zie direct het resultaat in UTC, lokale tijd, ISO 8601 en relatieve tijd. Klik op de knop Kopiëren naast elk formaat om het direct naar je klembord te kopiëren.

Veelvoorkomende toepassingen

API-ontwikkeling en debugging

Decodeer ondoorzichtige timestamps in API-responses, JWT-tokenpayloads (iat-, exp- en nbf-claims), webhook-eventdata en logvermeldingen. Controleer direct of een authenticatietoken verlopen is of wanneer een event heeft plaatsgevonden.

Databasetimestampopslag en -queries

Reken om tussen Unix timestamps en mensvriendelijke datums bij het schrijven van databasequeries, het inspecteren van opgeslagen records of het valideren dat datumbereikfilters correct zijn opgegeven in je WHERE-clausules.

Logbestandanalyse en correlatie

Veel systeem- en applicatielogboeken registreren events als Unix timestamps. Reken verdachte logvermeldingen om naar mensvriendelijke tijden om events over meerdere services te correleren, aanvalsvensters te identificeren of het exacte moment van een fout te lokaliseren.

JWT-tokenvervaldatumverificatie

JSON Web Tokens encoderen iat (issued at), exp (expires at) en nbf (not before) als Unix timestamps in hun payload. Plak deze waarden direct om tokengeldigheidsvensters te verifiëren zonder de epoch-berekening handmatig te doen.

Cron-taakplanning

Verifieer dat cron-taakschema's, geplande taken en tijdgestuurde triggers overeenkomen met de bedoelde uitvoeringsvensters door voorgestelde uitvoertijden om te rekenen naar timestamps en terug.

Tijdzone-neutrale datumcoördinatie

Unix timestamps zijn van nature tijdzone-neutraal. Gebruik deze converter om een gedeeld referentiepunt vast te stellen bij het coördineren van datums en deadlines over teams in verschillende tijdzones, waarbij je het UTC-equivalent van een lokale tijd bevestigt.

Technische referentie

Definitie van een Unix timestamp

Een Unix timestamp is het gehele getal van seconden dat verstreken is sindsde Unix epoch: 1 januari 1970, 00:00:00 UTC (Coordinated Universal Time). De waarde is onafhankelijk van de lokale tijdzone van de waarnemer, waardoor het een ideale tijdzone-neutrale representatie is voor het opslaan en vergelijken van tijden.

Maximale waarde van een 32-bit signed integer

De maximale waarde van een getekend 32-bit integer is 2.147.483.647. Als Unix timestamp komt dit overeen met 19 januari 2038 om 03:14:07 UTC. Systemen die timestamps opslaan in 32-bit signed integers lopen op dit moment over — een probleem bekend als het Jaar 2038-probleem. 64-bit systemen kunnen datums miljarden jaren in de toekomst weergeven.

JavaScript gebruikt milliseconden

JavaScript's Date.now() en new Date().getTime() retourneren het aantal milliseconden sindsthe epoch — niet seconden. Dit levert 13-cijferige getallen op. Om om te rekenen naar de standaard Unix timestamp in seconden, deel je door 1000 en rond je naar beneden af: Math.floor(Date.now() / 1000). Veel API's en tools verwachten seconden, dus deze omrekeningsstap is cruciaal.

Negatieve timestamps staan voor datums vóór de epoch

Unix timestamps kunnen negatief zijn om datums vóór 1 januari 1970 te vertegenwoordigen. Zo staat -86400 voor 31 december 1969 om 00:00:00 UTC. Het bereik van een getekende 64-bit timestamp strekt zich uit van ongeveer 292 miljard jaar vóór de epoch tot 292 miljard jaar erna — ruim genoeg voor elke praktische toepassing.

Unix time houdt geen rekening met schrikkelseconden

Unix time gaat uit van precies 86.400 seconden per dag (24 uur × 60 minuten × 60 seconden). In werkelijkheid worden schrikkelseconden soms ingevoegd door IERS om UTC gesynchroniseerd te houden met de rotatie van de aarde. Daardoor is Unix time niet perfect lineair ten opzichte van TAI (International Atomic Time), en het verschil groeit in de loop van de tijd. Voor de meeste toepassingen is dit verschil niet relevant, maar precisie-tijdmeetsystemen moeten er rekening mee houden.

Aanbevolen aanpak

Sla timestamps altijd op in UTC

Sla timestamps op in UTC (of als Unix timestamps) en zet ze alleen bij weergave om naar lokale tijd. Tijdzones mengen in je database is een veelvoorkomende oorzaak van bugs die moeilijk te reproduceren en te debuggen zijn, met name rondom overgangen van zomertijd.

Gebruik millisecondenprecisie voor moderne API's

De meeste moderne API's, JavaScript-omgevingen en databases gebruiken milliseconden (13-cijferige timestamps) in plaats van seconden (10-cijferige timestamps). Controleer bij integratie met externe systemen altijd de verwachte precisie — een millisecondentimestamp doorgeven waar seconden verwacht worden levert datums op van ongeveer 11.000 jaar in de toekomst.

Houd rekening met het Jaar 2038-probleem

Systemen die Unix timestamps opslaan in 32-bit signed integers lopen over op 19 januari 2038 om 03:14:07 UTC. Controleer legacy systemen op 32-bit timestampvelden en migreer naar 64-bit integers of ISO 8601-strings. De meeste moderne talen en databases gebruiken standaard 64-bit timestamps, maar embedded systemen, oudere databases en bestandssystemen kunnen nog kwetsbaar zijn.

Vertrouw nooit op client-side klokken voor beveiliging

Klokken van client-apparaten kunnen op elke waarde worden ingesteld, per ongeluk of met kwade bedoelingen. Gebruik een door de client aangeleverde timestamp nooit voor beveiligingsgevoelige logica zoals JWT-vervaldatumcontroles, sessietime-outs of rate limiting. Valideer timestamps altijd op de server via een betrouwbare tijdbron.

Gebruik ISO 8601 voor mensvriendelijke uitwisseling

Als je een timestampformaat nodig hebt dat zowel machine-leesbaar als mensvriendelijk is — bijvoorbeeld in logbestanden, configuratiebestanden of API-responses waar een ontwikkelaar de output kan lezen — is ISO 8601 (bijv. 2025-03-14T15:37:12Z) de beste keuze. Het is lexicografisch sorteerbaar, ondubbelzinnig en wordt ondersteund door vrijwel alle moderne parsers.

Veelgestelde vragen