Convertitore Timestamp (UNIX ↔ Data)

Converti secondi/millisecondi epoch in date leggibili e viceversa. Privacy progettata per impostazione predefinita (100% lato client).

Input e azioni

Il parsing resta quello predefinito del browser; cambia solo la visualizzazione.
Epoch corrente: s · ms

Risultato

Risultato:

Conversione batch (un valore per riga)

5 curiosita sui timestamp UNIX

Lo zero e una data di nascita

Un timestamp pari a 0 indica l'inizio esatto della Unix Epoch: 1970-01-01T00:00:00Z (UTC).

Inizio Epoch

Conta le cifre

10 cifre = secondi; 13 cifre = millisecondi. Aggiungi o rimuovi tre zeri per passare da una unita all'altra.

Secondi vs ms

Stesso istante, orologi diversi

I timestamp sono indipendenti dal fuso orario. Londra, New York o Tokyo mostrano orari locali diversi, ma e lo stesso istante.

Indipendente dal fuso

Il problema del 2038

Il 2038-01-19 03:14:07 UTC, i contatori a 32 bit in secondi vanno in overflow. I moderni sistemi a 64 bit evitano questo problema.

Limite a 32 bit

La "Z" significa Zulu (UTC)

In ISO-8601, la Z finale (es.: 2025-03-01T10:30:00Z) indica UTC, cioe lo stesso orario ovunque.

ISO-8601

Informazioni su UNIX / Tempo Epoch

Un timestamp UNIX (spesso chiamato epoch time) e un numero singolo che indica quanto tempo e trascorso dalla Unix Epoch: 1970-01-01T00:00:00Z (UTC). E molto usato in log, database e API perche e compatto, ordinabile e indipendente dal fuso orario.

Fatti rapidi

  • Secondi vs millisecondi vs nanosecondi:
    • 10 cifre → secondi (es.: 1700000000)
    • 13 cifre → millisecondi (es.: 1700000000000)
    • 16 cifre → microsecondi (es.: 1700000000000000)
    • 19 cifre → nanosecondi (comuni nei sistemi ad alta precisione)
  • Indipendente dal fuso: il numero rappresenta un istante assoluto; cambia solo la visualizzazione con fuso/orario legale.
  • Valori negativi: rappresentano date precedenti al 1970-01-01 (es.: -31536000 → 1969-01-01T00:00:00Z).
  • Limite Y2038 (secondi a 32 bit): 2147483647 → 2038-01-19T03:14:07Z. I sistemi moderni usano 64 bit e non hanno questo limite.

Esempi comuni

SignificatoSecondiMillisecondiUTC (ISO-8601)
Inizio Epoch 0 0 1970-01-01T00:00:00Z
Un miliardo di secondi 1000000000 1000000000000 2001-09-09T01:46:40Z
Confine 2038 (32 bit) 2147483647 2147483647000 2038-01-19T03:14:07Z
Esempio era attuale 1600000000 1600000000000 2020-09-13T12:26:40Z

Fusi orari e ora legale

  • Un timestamp viene memorizzato in UTC. Se lo visualizzi in "Europe/London" o "America/New_York", cambia solo la stringa visualizzata.
  • I passaggi di ora legale non cambiano il timestamp sottostante; cambiano solo come viene mostrata l'ora locale.
  • Per stringhe non ambigue, preferisci il formato ISO-8601 come 2025-03-01T10:30:00Z o con offset (es.: +01:00).

Suggerimenti di parsing

  • I browser interpretano una stringa data senza fuso nel fuso orario locale dell'utente:
    • 2025-03-01 10:30:00 → local time
    • 2025-03-01T10:30:00Z → UTC (la Z finale indica Zulu/UTC)
    • 2025-03-01T10:30:00+05:30 → UTC+5:30
  • Se incolli un numero a 10 cifre (secondi) ma ti servono i millisecondi, moltiplica per 1000.
  • Se incolli un valore a 19 cifre (nanosecondi), dividi per 1,000,000 per ottenere i millisecondi.

Quando usare ogni unita?

  • Secondi: molte API back-end, database e strumenti da shell.
  • Millisecondi: JavaScript Date, browser e gran parte del codice front-end.
  • Nanosecondi: log/telemetria ad alta precisione; converti in ms per usare Date in JS.

Epoch time per linguaggio (ricette rapide)

Snippet copia-incolla per operazioni comuni: epoch corrente, data leggibile → epoch, epoch → data.

JavaScript (Browser e 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 / Shell Unix 
# 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);

Suggerimento: preferisci stringhe ISO-8601 (es.: 2025-03-01T10:30:00Z) per UTC senza ambiguita. Se un'API si aspetta secondi ma hai millisecondi, dividi per 1000 (e moltiplica per l'operazione inversa).

FAQ

Un timestamp UNIX e influenzato dai fusi orari?

No. Il timestamp codifica un istante assoluto; cambia solo la visualizzazione in base al fuso orario o all'ora legale.

Secondi o millisecondi: cosa devo usare?

I sistemi back-end e le API usano spesso i secondi; browser e JavaScript usano tipicamente i millisecondi. Questo strumento gestisce entrambi.

Posso copiare i risultati in ISO-8601?

Si. Usa l'output UTC per stringhe in stile ISO-8601 come YYYY-MM-DDTHH:mm:ssZ.

E privato?

Si. Tutto viene calcolato nel browser, senza richieste di rete per le conversioni.

Esplora altri strumenti