Conversor de timestamp Unix

Converta timestamp Unix (s, ms, µs, ns) em data e data em timestamp, em qualquer fuso, com ISO 8601, RFC 2822 e conversão em lote. Grátis, no navegador.

Agora · timestamp Unix (s)

—

Tudo roda no seu navegador: nada do que você digita é enviado ou guardado.

O tempo Unix conta segundos desde 1º de janeiro de 1970 em UTC e ignora os segundos bissextos. Os fusos e o histórico de horário de verão vêm da base IANA do seu navegador.

Como usar

Timestamp → data: cole um número (1700000000, 1700000000000…) ou uma data em texto. A unidade é detectada pela quantidade de dígitos, mas você pode forçar segundos, milissegundos, microssegundos ou nanossegundos. Números copiados de planilha também valem (1,7E+12, 1.700.000.000). Aparecem juntos: ISO 8601 em UTC e no fuso escolhido, RFC 2822, data por extenso, tempo relativo ("há 3 horas"), dia da semana, semana ISO, dia do ano e offset. Cada linha tem botão de copiar.
Data → timestamp: escolha data, hora e segundos. Eles são lidos no fuso horário selecionado e viram timestamp Unix em segundos e milissegundos.
Em lote: cole uma coluna inteira (de um log, planilha ou consulta SQL), uma entrada por linha. Linhas inválidas ficam marcadas e o resultado sai em CSV ou direto para a planilha (TSV).
A faixa Agora mostra o timestamp atual, atualizado a cada segundo. Dá para pausar, copiar em segundos ou milissegundos e mandar para o conversor.

Tudo é calculado no seu navegador: nada do que você digita sai do aparelho.

O que é o tempo Unix

O tempo Unix (também chamado de epoch ou POSIX time) conta os segundos que se passaram desde 1º de janeiro de 1970, 00:00:00 UTC. É um número só, sem fuso horário, por isso é o jeito mais comum de guardar "quando algo aconteceu" em bancos de dados, logs, APIs e arquivos.

Datas antes de 1970 são números negativos: -86400 é 31 de dezembro de 1969, 00:00 UTC.

O tempo Unix ignora os segundos bissextos: todo dia tem exatamente 86.400 segundos. Por isso a conversão é simples e previsível, mas não serve para medir intervalos com precisão de segundo ao longo de décadas.

Segundos, milissegundos, microssegundos ou nanossegundos?

Cada sistema usa uma unidade, e confundir é o erro mais comum. A detecção automática usa a quantidade de dígitos (para datas de hoje):

até 10 dígitos = segundos (ex.: 1700000000): Unix/Linux, PHP time(), Python int(time.time()), JWT (exp, iat).
11 a 13 dígitos = milissegundos (ex.: 1700000000000): JavaScript Date.now(), Java System.currentTimeMillis().
14 a 16 dígitos = microssegundos (ex.: 1700000000000000): Python time.time_ns() // 1000, ClickHouse DateTime64(6).
17 a 19 dígitos = nanossegundos (ex.: 1700000000000000000): Go UnixNano(), InfluxDB, OpenTelemetry.

Se uma data caiu em janeiro de 1970, quase sempre um valor em segundos foi lido como milissegundos (por exemplo, new Date(1700000000) no JavaScript). Se caiu num ano absurdo como 55.000, aconteceu o contrário.

UTC, fuso horário e offset não são a mesma coisa

UTC é a referência mundial. O timestamp Unix é sempre UTC.
Offset é a diferença para o UTC num instante: -03:00, +05:30.
Fuso horário (como America/Sao_Paulo) é a regra que diz qual offset vale em cada data, incluindo horário de verão e mudanças históricas. Por isso o conversor usa nomes IANA, e não apenas offsets.

O mesmo instante 1700000000 é 22:13 em UTC, 19:13 em São Paulo e 03:43 do dia seguinte em Nova Délhi.

Horário de verão: o horário que não existe e o que acontece duas vezes

Quando o relógio é adiantado, uma faixa de horário simplesmente não existe naquele dia. Em Nova York, em 10 de março de 2024, o relógio pulou de 01:59:59 para 03:00:00: não houve 02:30. Quando é atrasado, uma faixa se repete: em 3 de novembro de 2024, 01:30 aconteceu duas vezes (primeiro com offset −04:00, depois com −05:00).

O conversor avisa nos dois casos. No horário inexistente, ele usa a regra mais comum entre as linguagens (JavaScript, Python zoneinfo, Java java.time): empurra a hora para frente pelo tamanho do salto (02:30 vira 03:30). No horário repetido, você escolhe a primeira ou a segunda ocorrência.

E no Brasil? O horário de verão foi extinto pelo Decreto nº 9.772, de 2019, e desde então o horário de Brasília é UTC−3 o ano todo. Mas datas antigas continuam valendo com as regras da época: em 4 de novembro de 2018 o relógio pulou de 00:00 para 01:00 (00:30 não existiu em São Paulo), e na noite de 16 de fevereiro de 2019 o horário de 23:00 a 23:59 aconteceu duas vezes. Converter datas antigas pelo offset "de hoje" dá uma hora de diferença.

O problema do ano 2038

Sistemas que guardam o timestamp em um inteiro de 32 bits com sinal só vão até 2147483647, que é 19 de janeiro de 2038, 03:14:07 UTC. Um segundo depois, o número "dá a volta" e vira 13 de dezembro de 1901. Linux, bancos de dados e linguagens modernas já usam 64 bits, mas firmware, sistemas embarcados e colunas INT antigas ainda correm risco. Teste digitando 2147483647 e 2147483648 no conversor.

ISO 8601 ou RFC 2822?

ISO 8601 (2023-11-14T19:13:20.000-03:00) é o padrão para APIs, JSON e bancos de dados: ordena alfabeticamente na ordem certa e não depende de idioma. O Z no fim significa UTC ("Zulu"). A RFC 3339 é um perfil mais estrito dele, usado na internet.
RFC 2822 (Tue, 14 Nov 2023 19:13:20 -0300) é o formato de cabeçalhos de e-mail e de feeds RSS. Os nomes de dia e mês são sempre em inglês.

Datas escritas como 31/12/2024 ou 12/31/2024 não são aceitas de propósito: dependem do país e geram erro silencioso. Prefira 2024-12-31.

Como obter e converter o timestamp em cada linguagem

```text
JavaScript Math.floor(Date.now() / 1000) new Date(1700000000 * 1000).toISOString()
Python int(time.time()) datetime.fromtimestamp(1700000000, tz=timezone.utc)
Java Instant.now().getEpochSecond() Instant.ofEpochSecond(1700000000)
Go time.Now().Unix() time.Unix(1700000000, 0).UTC()
PHP time() date(DATE_ATOM, 1700000000)
PostgreSQL SELECT floor(extract(epoch FROM now())); SELECT to_timestamp(1700000000);
MySQL SELECT UNIX_TIMESTAMP(); SELECT FROM_UNIXTIME(1700000000);
Shell (GNU) date +%s date -u -d @1700000000
Shell (mac) date +%s date -u -r 1700000000
```

Limitações

O alcance é o do Date do JavaScript: cerca de 270 mil anos antes e depois de 1970. Micro e nanossegundos são preservados no texto (ISO com 6 ou 9 casas), mas o calendário trabalha com milissegundos.
Os fusos e o histórico de horário de verão vêm da base IANA embutida no seu navegador. Navegadores desatualizados podem não ter mudanças recentes de algum país.
Uma data ISO só com o dia (2024-03-10) é lida como meia-noite no fuso escolhido. Atenção: o Date do JavaScript interpreta esse mesmo texto como meia-noite em UTC.

Perguntas frequentes

Timestamp Unix tem fuso horário? Não. Ele é sempre contado em UTC. O fuso só importa para mostrar a data ou para interpretar uma data/hora digitada.

Por que o mesmo timestamp mostra horas diferentes em computadores diferentes? Porque cada um exibe no seu fuso local. O instante é o mesmo.

O que acontece com os segundos bissextos? São ignorados: o tempo Unix finge que eles não existiram, como fazem praticamente todos os sistemas.

Meus dados são enviados para algum lugar? Não. A conversão roda inteira no navegador, sem login e sem guardar nada.