Conversor de timestamp (UNIX ↔ Data)

Converta segundos/milissegundos epoch em datas legiveis e vice-versa. Privado por design (100 % no cliente).

Entradas e acoes

A interpretacao segue o padrao do navegador; isto afeta apenas os resultados exibidos.
Epoch atual: s · ms

Resultado

Resultado:

Conversao em lote (um valor por linha)

5 curiosidades sobre timestamps UNIX

Zero e uma data de nascimento

Um timestamp de 0 e o inicio exato do epoch Unix: 1970-01-01T00:00:00Z (UTC).

Inicio do epoch

Conte os digitos

10 digitos = segundos; 13 digitos = milissegundos. Adicione ou remova tres zeros para alternar entre eles.

Segundos vs ms

Mesmo instante, relogios diferentes

Timestamps sao independentes de fuso horario. Londres, Nova Iorque ou Toquio mostram horas locais diferentes, mas e o mesmo momento.

Independente do fuso

O problema de 2038

Em 2038-01-19 03:14:07 UTC, contadores de segundos de 32 bits entram em overflow. Sistemas modernos de 64 bits evitam isso.

Limite de 32 bits

"Z" significa Zulu (UTC)

Em ISO-8601, o Z final (ex.: 2025-03-01T10:30:00Z) significa UTC, a mesma hora em qualquer lugar.

ISO-8601

Sobre UNIX / tempo epoch

Um timestamp UNIX (muitas vezes chamado de tempo epoch) e um unico numero que conta quanto tempo passou desde o epoch Unix: 1970-01-01T00:00:00Z (UTC). E muito usado em logs, bases de dados e APIs porque e compacto, ordenavel e independente de fuso horario.

Factos rapidos

  • Segundos vs milissegundos vs nanossegundos:
    • 10 digitos → segundos (ex.: 1700000000)
    • 13 digitos → milissegundos (ex.: 1700000000000)
    • 16 digitos → microssegundos (ex.: 1700000000000000)
    • 19 digitos → nanossegundos (comum em sistemas de alta precisao)
  • Independente de fuso: o numero representa um momento absoluto; apenas a exibicao muda com fuso/horario de verao.
  • Valores negativos representam datas antes de 1970-01-01 (ex.: -31536000 → 1969-01-01T00:00:00Z).
  • Limite Y2038 (segundos em 32 bits): 2147483647 → 2038-01-19T03:14:07Z. Sistemas modernos usam 64 bits e nao sofrem este limite.

Exemplos comuns

SignificadoSegundosMilissegundosUTC (ISO-8601)
Inicio do epoch 0 0 1970-01-01T00:00:00Z
Mil milhoes de segundos 1000000000 1000000000000 2001-09-09T01:46:40Z
Limite de 2038 (32 bits) 2147483647 2147483647000 2038-01-19T03:14:07Z
Exemplo de epoca atual 1600000000 1600000000000 2020-09-13T12:26:40Z

Fusos horarios e horario de verao

  • Um timestamp e armazenado em UTC. Ao visualiza-lo em “Europe/London” ou “America/New_York”, apenas a string exibida muda.
  • Mudancas de horario de verao nao alteram o timestamp base; alteram apenas como a hora local e apresentada.
  • Para evitar ambiguidades, prefira ISO-8601 como 2025-03-01T10:30:00Z ou com offset (ex.: +01:00).

Dicas de interpretacao

  • Navegadores interpretam uma data sem fuso no fuso local do utilizador:
    • 2025-03-01 10:30:00 → hora local
    • 2025-03-01T10:30:00Z → UTC (o Z no fim significa Zulu/UTC)
    • 2025-03-01T10:30:00+05:30 → UTC+5:30
  • Se colar um numero de 10 digitos (segundos) mas esperar milissegundos, multiplique por 1000.
  • Se colar um valor de 19 digitos (nanossegundos), divida por 1,000,000 para obter milissegundos.

Quando usar cada unidade?

  • Segundos: muitas APIs de back-end, bases de dados e ferramentas de shell.
  • Milissegundos: JavaScript Date, navegadores e a maior parte do codigo front-end.
  • Nanossegundos: logs/telemetria de alta precisao; converta para ms no Date do JS.

Tempo epoch por linguagem (receitas rapidas)

Snippets prontos para copiar e colar: obter o epoch atual, converter uma data legivel → epoch e converter epoch → data.

JavaScript (Browser & 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);

Dica: prefira strings ISO-8601 (ex.: 2025-03-01T10:30:00Z) para UTC sem ambiguidade. Se uma API espera segundos e voce tem milissegundos, divida por 1000 (e multiplique para o inverso).

Perguntas frequentes

Um timestamp UNIX e afetado por fusos horarios?

Nao. O timestamp codifica um instante absoluto; apenas a sua apresentacao muda com fuso horario ou horario de verao.

Segundos vs milissegundos: o que devo usar?

Sistemas de back-end e APIs usam frequentemente segundos; navegadores e JavaScript usam normalmente milissegundos. Esta ferramenta suporta ambos.

Posso copiar resultados em ISO-8601?

Sim. Use a saida UTC para cadeias ISO-8601 como YYYY-MM-DDTHH:mm:ssZ.

E privado?

Sim. Tudo e calculado no seu navegador, sem pedidos de rede para conversoes.

Explore mais ferramentas