Open Calculators
Blog
Tempo epoch para desenvolvedores, logs e bancos de dados

Conversor de timestamp Unix (epoch para data)

Cole qualquer timestamp — em segundos, milissegundos, microssegundos ou nanossegundos, com ou sem separadores, ou uma data em texto — e a unidade é detectada automaticamente. Converta em datas legíveis em qualquer fuso horário e vice-versa, com saída em ISO 8601 e RFC 2822.

Conversor de timestamp Unix

Timestamp → data legível

Detectado automaticamente como Segundos (10 dígitos).

Tratar número como
Legível
quinta-feira, 1 de jan de 2026 às 00:00:00 (UTC+00:00)
ISO 8601 (UTC)
2026-01-01T00:00:00.000Z
ISO 8601 com deslocamento (UTC)
2026-01-01T00:00:00+00:00
RFC 2822
Thu, 01 Jan 2026 00:00:00 +0000
Data HTTP (UTC)
Thu, 01 Jan 2026 00:00:00 GMT
Segundos Unix
1767225600
Milissegundos Unix
1767225600000
Microssegundos Unix
1767225600000000
Nanossegundos Unix
1767225600000000000
Calendário
quinta-feira · dia 1 · semana ISO 1
Relativo
—
Timestamps notáveis

Data legível → timestamp

Segundos Unix
1767225600
Milissegundos Unix
1767225600000
ISO 8601 (UTC)
2026-01-01T00:00:00.000Z

Segundos em durações comuns

1 minuto60
1 hora3,600
1 dia86,400
1 semana604,800
1 mês (30,44 dias)2,629,746
1 ano (365,2425 dias)31,556,952

O tempo Unix ignora segundos intercalares: todo dia tem exatamente 86.400 segundos.

Resposta rápida e principais fórmulas de epoch

Resposta direta: Um timestamp Unix conta os segundos desde 1970-01-01 00:00:00 UTC. Para obter a data, some essa quantidade de segundos ao epoch: days = ⌊t ÷ 86,400⌋. Para obter um timestamp no código, use Math.floor(Date.now() / 1000) em JavaScript ou date +%s no shell. Valores com 10 dígitos estão em segundos; com 13 dígitos, em milissegundos.

Entendendo o tempo Unix e a matemática da conversão

O tempo Unix (tempo POSIX) é um único número inteiro que conta os segundos decorridos desde o epoch Unix, a meia-noite UTC de 1º de janeiro de 1970. Como não tem fuso horário nem regras de horário de verão, é a forma padrão de armazenar e comparar instantes em bancos de dados, logs, APIs e sistemas de arquivos.

1. Timestamp para data (epoch → UTC)

Divida o timestamp em dias inteiros e segundos restantes e, em seguida, conte os dias a partir de 1º de janeiro de 1970:

dias = ⌊t ÷ 86.400⌋ · segundos do dia = t mod 86.400

Exemplo: 1.700.000.000 ÷ 86.400 = 19.675 dias + 80.000 s (22:13:20) → 2023-11-14 22:13:20 UTC.

2. Data para timestamp (UTC → epoch)

Conte os dias desde 1970-01-01, converta em segundos, some a hora do dia e subtraia a diferença do fuso horário em relação ao UTC:

t = dias × 86.400 + h × 3.600 + m × 60 + s − diferença UTC

Exemplo: 2026-01-01 00:00 UTC equivale a 20.454 dias × 86.400 = 1.767.225.600.

Segundos ou milissegundos? Conte os dígitos

Para datas atuais, 10 dígitos indicam segundos e 13 dígitos indicam milissegundos (16 = microssegundos, 19 = nanossegundos). JavaScript e Java usam milissegundos; shells Unix, PHP e o time.time() do Python usam segundos:

ms = s × 1.000 · µs = s × 10⁶ · ns = s × 10⁹

1767225600 (10 dígitos) e 1767225600000 (13 dígitos) são o mesmo instante: 2026-01-01 00:00 UTC.

Timestamps Unix notáveis

TimestampData e hora UTCSignificado
−2.208.988.8001900-01-01 00:00:00Epoch do NTP — um tempo Unix negativo
01970-01-01 00:00:00O epoch Unix
1.000.000.0002001-09-09 01:46:40O "billennium" do Unix
1.234.567.8902009-02-13 23:31:30Dígitos em sequência celebrados por desenvolvedores
1.700.000.0002023-11-14 22:13:201,7 bilhão de segundos
2.000.000.0002033-05-18 03:33:20Dois bilhões de segundos
2.147.483.6472038-01-19 03:14:07Máximo de 32 bits com sinal (problema do ano 2038)

Perguntas frequentes

O que é um timestamp Unix?

Um timestamp Unix é o número de segundos decorridos desde 00:00:00 UTC de 1º de janeiro de 1970, sem contar os segundos intercalares. Ele independe do fuso horário, então o mesmo instante tem o mesmo timestamp em qualquer lugar.

O tempo Unix conta os segundos intercalares?

Não. O tempo Unix trata todo dia como tendo exatamente 86.400 segundos. Quando ocorre um segundo intercalar, o relógio repete ou dilui um segundo, e assim o tempo Unix continua alinhado com as datas UTC.

O que é o problema do ano 2038?

Sistemas que armazenam o tempo em um inteiro de 32 bits com sinal só conseguem contar até 2.147.483.647, que corresponde a 03:14:07 UTC de 19 de janeiro de 2038. Um segundo depois, o valor estoura e volta para uma data em 1901. Sistemas modernos de 64 bits não são afetados.

Como obtenho o timestamp Unix atual no código?

JavaScript: Math.floor(Date.now() / 1000). Python: int(time.time()). PHP: time(). Bash: date +%s. SQL (PostgreSQL): EXTRACT(EPOCH FROM NOW()).

Como o conversor sabe se um timestamp está em segundos ou milissegundos?

Ele analisa a magnitude: para datas entre 1973 e 5138, segundos têm de 9 a 11 dígitos, milissegundos de 12 a 14, microssegundos de 15 a 17 e nanossegundos 18 ou mais. Separadores como em 1,767,225,600, um sufixo de unidade como ms ou uma data em texto como 2026-01-01T00:00:00Z também são reconhecidos, e você pode definir a unidade manualmente.