Unix Timestamp in seconden vs milliseconden: waarom de datum 1970 toont

Je zette een timestamp om en belandt in januari 1970. Dat is zelden een kapotte klok. Het getal is als milliseconden gelezen terwijl het in seconden stond—of andersom.

Wat is een Unix timestamp?

Een Unix timestamp meet de tijd sinds het Unix-epoch: 1970-01-01 00:00:00 UTC. Meestal in hele seconden. Hetzelfde moment kan ook in milliseconden staan (seconden × 1.000). Het getal zelf noemt de eenheid niet.

Seconden vs milliseconden: het 1.000-voudige verschil

Eén seconde is 1.000 milliseconden. Vergelijk 1720000000 met 1720000000000. Is de eerste seconden en de tweede milliseconden, dan is het hetzelfde moment. Lees je de eerste als milliseconden, dan springt de datum richting 1970.

Deze UTC-resultaten zijn berekend uit de getallen hierboven, niet geschat.

Waarde	Waarschijnlijke eenheid	Interpretatie (UTC)
1720000000	Seconden	Moderne datum als seconden: 2024-07-03 09:46:40 UTC
1720000000000	Milliseconden	Hetzelfde moment als milliseconden: 2024-07-03 09:46:40 UTC
1720000000 als milliseconden	Verkeerde eenheid	Datum rond 1970: 1970-01-20 21:46:40 UTC

Waarom toont mijn timestamp 1970?

Wordt een secondenwaarde als milliseconden behandeld, dan is het getal 1.000 keer te klein. JavaScript telt dan maar een kort stuk na het Unix-epoch, en de datum blijft in 1970:

const seconds = 1720000000;

new Date(seconds);
// 1970-01-20 21:46:40 UTC

new Date(seconds * 1000);
// 2024-07-03 09:46:40 UTC

Die datum in 1970 is het epoch plus een paar weken. Vermenigvuldig seconden met 1.000 voordat je ze aan Date doorgeeft.

• SECONDEN
• 1720000000
• × 1000
• ↓
• MILLISECONDEN
• 1720000000000

• Secondenwaarde
• ↓
• Per ongeluk als milliseconden gelezen
• ↓
• Datum rond 1970

Zijn 10 cijfers seconden en 13 cijfers milliseconden?

Bij huidige data zijn 10 cijfers vaak seconden en 13 vaak milliseconden. Dat is een snelle aanwijzing, geen validatieregel. Het cijferaantal verandert met het tijdsbereik, en sommige API’s slaan micro- of nanoseconden op. Bevestig de eenheid met documentatie of een datum die klopt.

Waarom dit zo vaak in JavaScript gebeurt

In JavaScript is een numerieke Date-waarde milliseconden sinds het epoch. Veel backends, databases en Unix-tools slaan nog seconden op. Een secondenwaarde rechtstreeks aan Date geven is een veelgemaakte fout:

const unixSeconds = 1720000000;

const wrong = new Date(unixSeconds);
const correct = new Date(unixSeconds * 1000);

wrong ligt rond 1970 (1970-01-20 21:46:40 UTC). correct is het moderne moment (2024-07-03 09:46:40 UTC).

Andere systemen gebruiken andere eenheden

Andere talen, API’s en databases kunnen seconden of milliseconden gebruiken. Sommige slaan micro- of nanoseconden op. Ga er niet van uit dat een taal altijd één eenheid gebruikt: lees de documentatie. Staat het getal in JSON, dan maakt JSON opmaken en vergelijken het veld leesbaar; de eenheid zegt het nog steeds niet.

Hoe weet ik welke eenheid mijn timestamp gebruikt?

Loop deze checks in volgorde na. Alleen het cijferaantal is niet genoeg.

1. Controleer de API- of databasedocumentatie.
2. Kijk naar het geschatte aantal cijfers.
3. Vergelijk de waarde met een aannemelijke moderne timestamp.
4. Test de waarde als seconden en als milliseconden.
5. Kijk of de resulterende datum klopt.

Valt de ene interpretatie in 1970 en de andere op een datum die je herkent, dan is de eenheid de oorzaak.

Veelgemaakte Unix-timestampfouten

• Seconden gelezen als milliseconden. De datum klapt in naar 1970, zoals in het voorbeeld.
• Milliseconden gelezen als seconden. De datum springt ver in de toekomst, of de omzetting mislukt.
• Twee keer met 1.000 vermenigvuldigen. Een waarde die al milliseconden was wordt enorm en de datum schiet eeuwen vooruit.
• Twee keer door 1.000 delen. Een secondenwaarde krimpt opnieuw, weer rond 1970.
• De tijdzone de schuld geven. Een zone kan uren of de kalenderdag verschuiven. Ze maakt van een moderne timestamp geen 1970.
• Een geformatteerde datumstring als Unix timestamp behandelen. Een waarde als 2024-07-03T09:46:40Z is geen epoch-getal. Parseer hem als datum, niet als seconden.

Veroorzaakt de tijdzone het 1970-probleem?

Meestal niet. Een tijdzone kan de getoonde klok veranderen en rond middernacht de kalenderdatum. Ze maakt van een moderne Unix timestamp geen 1970. Is het resultaat 1970, kijk dan eerst naar seconden versus milliseconden.

Een Unix timestamp omzetten en controleren

NEXNARA Datum- & tijdconverter kan een Unix timestamp in de browser omzetten.

Plak Unix-seconden of -milliseconden, gebruik de huidige timestamp, bekijk UTC en lokale tijd, zet tijdzones om en formatteer een datum. Autodetectie behandelt 10 cijfers vaak als seconden en 13 als milliseconden; je kunt de eenheid nog steeds kiezen.

De omzetting zelf gebeurt in je browser. Deze tool stuurt geen datums of timestamps naar een NEXNARA-server. Advertenties en andere sitefuncties gebruiken nog steeds het netwerk; dat is los van de omzetting.

Unix timestamp controleren? Open Datum- & tijdconverter en vergelijk seconden met milliseconden.

FAQ

Waarom toont mijn Unix timestamp 1970?

Het zijn vaak seconden die als milliseconden zijn gelezen. JavaScript behandelt een veel kleiner getal, dus de datum valt kort na 1970-01-01 00:00:00 UTC. Vermenigvuldig seconden met 1.000 en zet opnieuw om.

Zijn Unix timestamps seconden of milliseconden?

Ze gebruiken meestal seconden. Veel web-API’s en JavaScript Date gebruiken milliseconden. Check de documentatie. Sommige systemen gebruiken micro- of nanoseconden.

Hoe zet ik seconden om naar milliseconden?

Vermenigvuldig met 1.000. 1720000000 seconden is 1720000000000 milliseconden. Andersom deel je door 1.000.

Waarom gebruikt JavaScript Date milliseconden?

De numerieke Date-timestamp in JavaScript is gedefinieerd als milliseconden sinds het Unix-epoch. Daarom is new Date(unixSeconds) fout als unixSeconds Unix-seconden zijn.

Is een timestamp van 10 cijfers altijd seconden?

Nee. Bij huidige data vaak wel, en 13 cijfers zijn vaak milliseconden. Het cijferaantal is een aanwijzing, geen regel. Bevestig met documentatie of een logische datum.

Bevat een Unix timestamp een tijdzone?

Nee. Een Unix timestamp is een moment geteld vanaf 1970-01-01 00:00:00 UTC. Tijdzones beïnvloeden hoe dat moment wordt getoond, niet het getal zelf.