Convertitore di timestamp Unix — Da epoch a data e da data a epoch

Converti secondi, millisecondi, microsecondi o nanosecondi epoch in date in qualsiasi fuso orario, e viceversa. Orologio in tempo reale, modalità batch, snippet di codice.

Ora Unix attuale
Secondi
—
Millisecondi
—

Da timestamp a data

Secondi, millisecondi, microsecondi o nanosecondi; i valori negativi sono precedenti al 1970.
Interpretato come
secondi
UTC
Thu 2025-10-16 00:00:00.000 (UTC+00:00)
Locale
UTC
ISO 8601 (UTC)
2025-10-16T00:00:00.000Z
ISO 8601 (UTC)
RFC 2822
Relativo
Secondi
1760572800
Millisecondi
1760572800000
Microsecondi
1760572800000000
Nanosecondi
1760572800000000000

Da data a timestamp

YYYY-MM-DD HH:mm:ss viene interpretato nel fuso orario a destra. ISO 8601 con Z o con uno scostamento e RFC 2822 hanno già il proprio fuso.
Secondi Unix
1767225600
Millisecondi
1767225600000
ISO 8601 (UTC)
2026-01-01T00:00:00.000Z
UTC

Inizio e fine di giorno, settimana, mese, anno

a UTC; le settimane iniziano il lunedì (ISO 8601)

Conversione in blocco

I timestamp diventano ISO 8601 a UTC; le date diventano secondi Unix. Fino a 5.000 righe.
1700000000s
1760572800000ms
-1s
2038-01-19 03:14:07data
0s

Ottieni il timestamp attuale nel codice

Math.floor(Date.now() / 1000)   // seconds
Date.now()                      // milliseconds

Funziona interamente nel tuo browser. Nulla di ciò che inserisci viene inviato a noi o salvato. Sfoglia tutti gli strumenti gratuiti.

Hai trovato un problema o qualcosa che potrebbe andare meglio? Leggiamo ogni messaggio e sistemiamo le cose in fretta.

Questo convertitore di timestamp Unix trasforma un valore epoch in una data leggibile e una data di nuovo in un valore epoch, in UTC, nel tuo fuso orario o in uno dei circa 400 fusi IANA che il browser conosce. Incolla 1760572800, 1760572800000 o un valore in nanosecondi di 19 cifre da una riga di log: l'unità viene rilevata dal numero di cifre e puoi cambiarla quando un valore è ambiguo.

I valori grandi e insoliti vengono gestiti con esattezza. Le cifre vengono analizzate come BigInt, quindi un timestamp in nanosecondi conserva le ultime cifre invece di essere arrotondato; i timestamp negativi precedenti al 1970 vengono arrotondati per difetto al millisecondo corretto; e qualsiasi valore fuori dall'intervallo delle date JavaScript (circa dal 271.821 a.C. al 275.760 d.C.) viene segnalato come fuori intervallo invece di essere mostrato come "Invalid Date". Le differenze di fuso orario, compresi i cambi dell'ora legale, vengono dai dati sui fusi orari del browser stesso. Nulla di ciò che inserisci lascia la pagina.

Come si usa

  1. Incolla un timestamp nel primo campo. La tabella lo mostra in UTC, nel tuo fuso, nel fuso selezionato, in ISO 8601, in RFC 2822 e come tempo relativo.
  2. Se l'unità è sbagliata (un valore di 12 cifre può essere in secondi dopo il 5138 d.C. o in millisecondi nel 1973), sceglila nel menu Unità.
  3. Per la conversione inversa, scrivi una data come YYYY-MM-DD HH:mm:ss e scegli il fuso in cui è espressa; le stringhe ISO con Z o con un offset vengono lette così come sono.
  4. Usa la tabella inizio/fine per query su intervalli come "tutto ciò che è di questo mese" e la casella batch per una colonna di valori da un CSV o da un log.
  5. Copia qualsiasi valore con il suo pulsante, oppure copia lo snippet per il tuo linguaggio per ottenere il timestamp attuale nel codice.

Domande frequenti

Che cos'è un timestamp Unix?

Un timestamp Unix (epoch time) è il numero di secondi trascorsi dalle 00:00:00 UTC del 1° gennaio 1970, senza contare i secondi intercalari. Non ha fuso orario: lo stesso istante ha lo stesso timestamp ovunque, ed è per questo che database e API lo usano. Molti sistemi memorizzano invece i millisecondi (Date.now() di JavaScript, currentTimeMillis di Java) e alcuni i microsecondi o i nanosecondi.

Come capisco se un timestamp è in secondi o in millisecondi?

Conta le cifre. Un timestamp attuale in secondi ha 10 cifre, in millisecondi 13, in microsecondi 16 e in nanosecondi 19. Questo strumento usa automaticamente queste soglie. L'unico intervallo ambiguo è tra 11 e 12 cifre, che possono essere secondi in un lontano futuro o millisecondi nei primi anni '70; lì scegli l'unità a mano.

Che cos'è il problema dell'anno 2038?

I sistemi che memorizzano lo Unix time come intero con segno a 32 bit possono contare solo fino a 2.147.483.647, cioè le 03:14:07 UTC del 19 gennaio 2038. Un secondo dopo il valore torna indietro a un numero negativo e viene letto come dicembre 1901. Sistemi operativi, linguaggi e database moderni usano il tempo a 64 bit, ma vecchi dispositivi embedded, formati di file e colonne di database dichiarate come INT a 32 bit hanno ancora il problema.

I timestamp Unix includono i secondi intercalari?

No. Lo Unix time considera ogni giorno lungo esattamente 86.400 secondi, quindi un secondo intercalare non viene contato e il timestamp si ripete o si ferma per un secondo quando se ne verifica uno. Questo rende semplici i calcoli con le date, al prezzo di uno scostamento dal tempo atomico (TAI) pari ai secondi intercalari accumulati, attualmente 37. Per quasi tutto il lavoro applicativo non ha importanza.

Un timestamp Unix può essere negativo?

Sì. I valori negativi contano all'indietro dal 1970: -1 corrisponde alle 23:59:59 UTC del 31 dicembre 1969 e -86400 all'inizio di quel giorno. La maggior parte dei linguaggi gestisce correttamente i timestamp negativi, ma alcune API più vecchie e funzioni dei fogli di calcolo li rifiutano, quindi verifica prima di memorizzare date di nascita o date storiche come valori epoch.

Perché l'ora convertita sembra sbagliata di qualche ora?

Quasi sempre è una confusione di fusi orari: il timestamp è corretto, ma è stato mostrato in UTC quando ti aspettavi l'ora locale, oppure una stringa di data locale è stata interpretata come UTC. Un timestamp di per sé non porta mai con sé un fuso. Controlla qui il selettore del fuso e, nel codice, assicurati che una stringa di data senza offset venga interpretata nel fuso che intendi.

Secondi, millisecondi, microsecondi, nanosecondi: chi usa cosa

• Secondi (10 cifre): time() di Unix e POSIX, time() di PHP, int(time.time()) di Python, EXTRACT(EPOCH) di PostgreSQL, claim exp/iat/nbf dei JWT, la maggior parte delle API HTTP.

• Millisecondi (13 cifre): Date.now() di JavaScript, System.currentTimeMillis() di Java, Elasticsearch e molte API JSON, timestamp dei record Kafka.

• Microsecondi (16 cifre): la memorizzazione interna dei timestamp di PostgreSQL, la precisione di datetime in Python, TIMESTAMP_MICROS di Google BigQuery.

• Nanosecondi (19 cifre): time.UnixNano() di Go, time.time_ns() di Python, InfluxDB e il remote-write di Prometheus, clock_gettime di Linux. Un numero JavaScript non può contenerli con esattezza, ed è per questo che questo strumento li analizza come BigInt.

Quando due sistemi differiscono di un fattore 1.000, uno lavora in secondi e l'altro in millisecondi. Questo solo errore spiega la maggior parte dei bug "la data mostra il 1970" e "la data mostra l'anno 50.000".

Fusi orari e ora legale: cosa può andare storto

Convertire un timestamp in ora locale non è mai ambiguo: un istante corrisponde a una sola ora sull'orologio in ogni fuso. Il contrario invece sì. Quando gli orologi vanno avanti, un'ora locale come le 02:30 del giorno del cambio non esiste; quando tornano indietro, le 01:30 si presentano due volte.

Questo convertitore segue le stesse regole predefinite dell'API Temporal di JavaScript: un'ora saltata viene letta con l'offset precedente al cambio (quindi le 02:30 diventano le 03:30 dell'ora legale) e un'ora ripetuta viene risolta con la prima occorrenza. Se il tuo codice usa una regola diversa, il risultato può differire di un'ora intorno a queste due date ogni anno.

La pratica più sicura è memorizzare e trasmettere gli istanti come timestamp UTC o stringhe ISO 8601 con un offset esplicito e convertirli in ora locale solo per la visualizzazione, usando un nome di fuso IANA come Europe/Rome invece di un offset fisso come +01:00, che è sbagliato per metà dell'anno.

ISO 8601, RFC 2822 e Unix time a confronto

ISO 8601 (2026-10-16T08:00:00Z o 2026-10-16T04:00:00-04:00) si ordina correttamente come testo, non è ambiguo ed è ciò che si aspettano le API JSON, gli attributi datetime dell'HTML e la maggior parte dei database. Usalo ogni volta che una persona potrebbe leggere il valore.

RFC 2822 (Fri, 16 Oct 2026 08:00:00 +0000) è il formato delle email e delle intestazioni HTTP. È leggibile ma non si ordina come testo ed è definito solo per gli anni dal 1900 in poi.

Un timestamp Unix è il formato più compatto e il più veloce da confrontare, ma è illeggibile senza un convertitore e non dà indizi sulla sua unità. Una regola ragionevole: Unix time all'interno di un sistema, ISO 8601 ai suoi confini.

Strumenti gratuiti correlati

  • Generatore di espressioni cron — Crea una pianificazione cron con i menu a tendina o incollane una, leggila in parole semplici e vedi le prossime 10 esecuzioni nel tuo fuso orario e in UTC. Gratis, nel browser.
  • Decoder JWT — Decodifica header e payload di un JWT, leggi la scadenza in parole semplici, verifica firme HS, RS, PS ed ES o firma un nuovo token. Nulla esce dal browser.
  • Generatore di UUID — Genera in blocco UUID v4 o v7 ordinati nel tempo, ULID e NanoID, oppure incolla un ID per vederne la versione e il timestamp incorporato.
  • Convertitore di basi numeriche — Converti interi di qualsiasi dimensione tra binario, ottale, decimale, esadecimale, base 32, base 36 e qualsiasi base da 2 a 36, con vista in complemento a due.