Convertitore di timestamp Unix

secondi dall'epoch = giorni dal 1970-01-01 × 86400 + secondi dalla mezzanotte UTC; data e ora = la stessa aritmetica percorsa all'indietro

direzione

In che verso andare: un timestamp inserito e una data restituita, oppure una data e un'ora inserite e un timestamp restituito

timestamp

Il conteggio stesso, in secondi o in millisecondi a seconda del campo unità. Si usa solo nella direzione da timestamp a data

unità

Se il numero che hai inserito conta secondi (10 cifre per le date di questo secolo) o millisecondi (13 cifre). Si usa solo nella direzione da timestamp a data

data

Il giorno di calendario in UTC, scritto come AAAA-MM-GG. Si usa solo nella direzione da data a timestamp

tempo

L'orologio locale in UTC, come HH:MM o HH:MM:SS. Si usa solo nella direzione da data a timestamp

data (UTC)

La data di calendario su cui cade il timestamp, in UTC. È il risultato in evidenza

ora (UTC)

L'ora in UTC, sempre con i secondi. Qualunque frazione di secondo presente nell'input viene scartata invece che arrotondata

giorno della settimana (UTC)

Il giorno della settimana in cui cade quella data, come numero da 0 (domenica) a 6 (sabato)

ISO 8601

La forma ISO 8601 completa, come 2026-01-15T12:00:00Z, pronta da copiare in un programma o in un log

timestamp (secondi)

Lo stesso istante come secondi interi dal 1970-01-01T00:00:00Z, troncati invece che arrotondati, così non contraddice mai l'ora stampata sopra

timestamp (millisecondi)

Lo stesso istante in millisecondi — il valore in secondi moltiplicato per 1000, conservando l'eventuale parte sotto il secondo che l'input portava

Usalo quando un numero e una data vanno messi in corrispondenza: leggere un timestamp da un log di server, da una risposta di API o da una riga di database; controllare se un valore che ti è arrivato è in secondi o in millisecondi; o generare un timestamp da memorizzare. La pagina si ferma di proposito all'UTC. Non converte nella tua ora locale e non chiede in che fuso sei — un timestamp Unix non ha fuso, quindi la risposta onesta è una risposta in UTC, e trasformarla in una lettura da orologio locale è compito della calcolatrice dei fusi orari. Non fa nemmeno aritmetica sui timestamp: per «quanto fa questo più trenta giorni», converti prima e usa una calcolatrice delle date.

1. 1768478400 — l'istante di riferimento

   1. Il numero è in secondi, quindi è già il valore epoch — non serve nessuna conversione prima di leggerlo
   2. Dividere per 86400 dà il numero di giorni interi dal 1 gennaio 1970, e il resto è l'ora del giorno: il risultato cade il 15 gennaio 2026 alle 12:00:00 UTC
   3. Il 15 gennaio 2026 è un giovedì, quindi il numero del giorno della settimana è 4
   4. Scritto per esteso è 2026-01-15T12:00:00Z, la forma che un log o un'API si aspetta
   5. La riga dei millisecondi è lo stesso istante per 1000, cioè come appare lo stesso valore quando un sistema lo riporta in millisecondi

   È il valore su cui la pagina si apre, e vale la pena memorizzarlo come ancora: 1768478400 è mezzogiorno UTC del 15 gennaio 2026. Ogni altra conversione su questa pagina si controlla più facilmente una volta che un timestamp ti è familiare, perché una risposta sbagliata è di solito sbagliata di giorni interi o di un fattore 1000, e tutte e due le cose saltano subito all'occhio contro un'ancora che conosci.

2. 2147483647 — l'ultimo secondo dell'era a 32 bit

   1. 2147483647 è 2³¹ − 1: il numero più grande che un intero con segno a 32 bit può contenere
   2. Letto come conteggio epoch è il 19 gennaio 2038 alle 03:14:07 UTC, ed è di questo che si tratta nel problema del 2038 — i sistemi che memorizzano i timestamp in quel tipo esauriscono lo spazio un secondo dopo e tornano a una data del 1901
   3. Il 19 gennaio 2038 è un martedì, giorno della settimana 2
   4. La riga dei secondi restituisce il numero invariato, ed è il controllo che il valore è entrato e uscito attraverso la stessa aritmetica

   Questa è la riga della tabella di riferimento qui sotto, fatta passare per la calcolatrice. Il problema del 2038 non è che la data sia irraggiungibile — questa pagina la gestisce senza protestare — ma che un programma con un contatore a 32 bit con segno non può rappresentare il secondo successivo. I contatori a 64 bit non hanno quel bordo entro nessun orizzonte che conti, ed è per questo che lo stesso valore in millisecondi è 2147483647000.

3. Un valore in millisecondi con una frazione: 1768478400500

   1. Il numero ha 13 cifre e l'unità dice millisecondi, quindi è lo stesso istante del primo esempio più mezzo secondo
   2. L'ora scarta la frazione invece di arrotondarla, quindi legge 12:00:00 e non 12:00:01
   3. La riga dei secondi viene troncata di conseguenza: 1768478400, non 1768478401
   4. La riga dei millisecondi conserva la frazione, perché è l'unico posto del risultato in cui esiste

   L'unico caso in cui arrotondare e troncare non concordano, e la ragione per cui la riga dei secondi tronca. Arrotondare mezzo secondo per eccesso stamperebbe un valore in secondi maggiore di uno rispetto all'ora stampata direttamente sopra, e chi confrontasse le due righe concluderebbe che una delle due è rotta. Tenere ogni riga coerente con l'ora mostrata conta più che tenere l'intero più vicino.

4. L'altro verso: 15 gennaio 2026, 12:00:30 UTC

   1. La data viene trasformata in un numero di giorni dal 1 gennaio 1970 e moltiplicata per 86400 per ottenere i secondi fino a mezzanotte
   2. Si aggiungono i trenta secondi dopo mezzanotte: il totale è 1768478430, cioè il valore del primo esempio più 30
   3. Il campo dell'ora accetta i secondi, quindi 12:00:30 viene letto esattamente invece di essere arrotondato al minuto
   4. Le righe della data e del giorno della settimana tornano invariate, perché convertire fuori e dentro di nuovo è l'operazione identica

   Far girare la direzione inversa su un valore che hai già convertito è il modo più economico di controllare un timestamp: se il giro di andata e ritorno non riporta al numero da cui eri partito, probabilmente l'unità era sbagliata. Inserire un numero di 10 cifre con l'unità impostata su millisecondi sbaglia di un fattore mille, e qui si vede come una data del gennaio 1970 invece che come un errore.

Tutto quello che la pagina riporta è in UTC e non converte mai in un fuso locale — un timestamp Unix è definito senza, quindi la pagina che lo trasforma in una lettura da orologio locale è la calcolatrice dei fusi orari. La finestra va dal 1970-01-01T00:00:00Z al 2100-12-31T23:59:59Z, e i valori fuori da lì vengono rifiutati invece di essere calcolati in silenzio: i timestamp negativi sono timestamp Unix legittimi per le date prima dell'epoch, ma la pagina lo dice e si ferma invece di restituire una risposta del 1969 che contraddirebbe l'intervallo che dichiara. Le frazioni di secondo vengono troncate e non arrotondate, quindi un valore in millisecondi non perde la sua precisione ma non influenza nemmeno i secondi mostrati. La pagina non interpreta stringhe di data in altri formati, non legge il timestamp della macchina su cui ti trovi e non fa aritmetica — per la data trenta giorni dopo un valore convertito, usa una calcolatrice delle date.

Che cos'è l'epoch time?

L'epoch time è il numero di secondi trascorsi dal 1970-01-01T00:00:00 UTC, che è il punto zero da cui contano i sistemi Unix. Si chiama anche Unix time o POSIX time. Niente di tutto questo dipende da dove ti trovi: l'epoch time è definito in UTC, quindi lo stesso istante ha lo stesso valore in tutto il mondo, e due macchine in fusi diversi che non concordano sull'orologio locale concordano comunque sul timestamp.

Come si converte un timestamp in una data?

Inserisci il valore, indica se conta secondi o millisecondi e leggi la data e l'ora che tornano. La prima cosa da controllare è il numero di cifre: un conteggio in secondi per una data di questo secolo ha 10 cifre e uno in millisecondi ne ha 13. Un valore di 13 cifre letto come secondi finisce decine di migliaia di anni nel futuro e viene rifiutato; un valore di 10 cifre letto come millisecondi finisce nel gennaio 1970, ed è l'errore che non si annuncia da solo. Convertire di nuovo con l'altra direzione è la conferma più rapida.

Che cos'è il problema del 2038?

Il problema del 2038 è quello che succede quando un sistema memorizza un timestamp in un intero con segno a 32 bit: il valore più grande che quel tipo contiene è 2147483647, cioè il 2038-01-19T03:14:07 UTC, e un secondo dopo il contatore va in overflow verso una data del 1901. È un limite di memorizzazione e non del timestamp in sé, e i contatori a 64 bit non ce l'hanno. Questa pagina converte quel valore e quelli oltre senza problemi, perché lavora in doppia precisione invece che in interi a 32 bit.

Conviene memorizzare i secondi o i millisecondi?

Sono entrambi molto usati e nessuno dei due è sbagliato, ma un valore da solo non dice quale dei due sia, quindi l'unità deve viaggiare insieme al numero o essere concordata in anticipo. I millisecondi conservano le frazioni di secondo e sono quelli che usano l'oggetto Date di JavaScript e molti sistemi di log; i secondi sono quelli che POSIX definisce e quelli che restituiscono la maggior parte delle API e dei database. Passare dall'uno all'altro è una moltiplicazione per 1000, e questa pagina stampa entrambe le righe così la coppia è visibile a colpo d'occhio.

Il formato ISO 8601 è la stessa cosa di un timestamp?

No, e si confondono facilmente perché descrivono lo stesso istante. L'ISO 8601 è la forma scritta — 2026-01-15T12:00:00Z — ed è leggibile da una persona, ordinabile e non ambigua riguardo all'offset UTC grazie alla Z finale. Un timestamp Unix è un solo conteggio, senza nessuna formattazione. La stringa ISO 8601 è quella che incolli in un documento o in un URL; il conteggio è quello che memorizzi o confronti. Questa pagina stampa entrambi dalla stessa conversione, così si possono controllare l'uno con l'altro.

• The Open Group Base Specifications — Seconds Since the Epoch — The Open Group — the normative definition of the epoch and of leap-second handling
• RFC 3339 — Date and Time on the Internet: Timestamps — IETF — the format of the Z-suffixed string this page prints
• MDN — Date — MDN Web Docs — the millisecond count and its range in JavaScript