Conversor de timestamp Unix

segundos de época = dias desde 1970-01-01 × 86.400 + segundos desde a meia-noite UTC; data e horário = a mesma aritmética na direção contrária; milissegundos = segundos × 1.000

Direção

Qual conta fazer: um timestamp digitado e uma data devolvida, ou uma data e um horário digitados e um timestamp devolvido

Timestamp

A contagem em si, em segundos ou em milissegundos conforme o campo de unidade. Só é usada na direção timestamp para data

Unidade

Se o número digitado conta segundos (10 dígitos para datas deste século) ou milissegundos (13 dígitos). Só é usada na direção timestamp para data

Data

O dia de calendário em UTC, escrito como AAAA-MM-DD. Só é usada na direção data para timestamp

Tempo

O relógio de parede em UTC, como HH:MM ou HH:MM:SS. Só é usado na direção data para timestamp

Data (UTC)

A data de calendário em que o timestamp cai, em UTC. É o resultado principal da página

Hora (UTC)

O horário em UTC, sempre com os segundos. Qualquer fração de segundo da entrada é descartada em vez de arredondada

Dia da semana (UTC)

O dia da semana daquela data, impresso por extenso como quinta-feira — um nome, não um número

ISO 8601

A forma completa ISO 8601, como 2026-01-15T12:00:00Z, pronta para copiar para um código ou para um log

Timestamp (segundos)

O mesmo instante em segundos inteiros desde 1970-01-01T00:00:00Z, truncado em vez de arredondado para nunca discordar do horário logo acima dele

Timestamp (milissegundos)

O mesmo instante em milissegundos — o valor em segundos vezes 1.000, preservando qualquer fração de segundo que a entrada trazia

Use quando um número e uma data precisarem ser amarrados um ao outro: ler um timestamp de um log de servidor, de uma resposta de API ou de uma linha de banco de dados; conferir se um valor que lhe mandaram está em segundos ou em milissegundos; ou gerar um timestamp para guardar. A página para de propósito em UTC. Ela não converte para o seu horário local e não pergunta em que fuso você está — um timestamp Unix não tem fuso, então a resposta honesta é uma resposta em UTC, e transformar isso em uma leitura de relógio local é tarefa da calculadora de fuso horário. Ela também não faz aritmética sobre timestamps: para saber quanto é este valor mais trinta dias, converta primeiro e use uma calculadora de datas.

1. 1.768.478.400 — o instante de referência

   1. O número está em segundos, então já é o valor de época — nenhuma conversão é necessária antes de lê-lo
   2. Dividir por 86.400 dá o número de dias inteiros desde 1º de janeiro de 1970, e o resto é a hora do dia: o resultado cai em 15 de janeiro de 2026 às 12:00:00 UTC
   3. 15 de janeiro de 2026 é uma quinta-feira, e é isso que a linha do dia da semana imprime: quinta-feira, por extenso, e não o número 4
   4. Escrito por inteiro fica 2026-01-15T12:00:00Z, a forma que um log ou uma API espera
   5. A linha dos milissegundos é o mesmo instante multiplicado por 1.000, que é como esse valor aparece quando um sistema o informa em milissegundos: 1.768.478.400.000

   É o valor com que a página abre, e vale a pena guardá-lo como âncora: 1.768.478.400 é meio-dia UTC de 15 de janeiro de 2026. Qualquer outra conversão desta página fica mais fácil de conferir depois que um timestamp é familiar, porque uma resposta errada costuma errar por dias inteiros ou por um fator de 1.000, e os dois casos saltam à vista contra uma âncora conhecida.

2. 2.147.483.647 — o último segundo da era de 32 bits

   1. 2.147.483.647 é 2 elevado a 31 menos 1: o maior número que um inteiro de 32 bits com sinal consegue guardar
   2. Lido como contagem de época, é 19 de janeiro de 2038 às 03:14:07 UTC, que é o que o problema do ano 2038 significa — um sistema que guarde timestamps nesse tipo fica sem espaço um segundo depois e volta para uma data de 1901
   3. 19 de janeiro de 2038 é uma terça-feira, e a linha do dia da semana imprime terça-feira; o número 2 é o valor interno dessa linha, não o que ela mostra
   4. A linha dos segundos devolve o número sem mudança, 2.147.483.647, que é a prova de que o valor entrou e saiu pela mesma aritmética

   É a linha da tabela de referência abaixo passada pela calculadora. O problema do ano 2038 não é a data ser inalcançável — esta página lida com ela sem reclamar —, mas o fato de um programa que use um contador de 32 bits com sinal não conseguir representar o segundo seguinte. Contadores de 64 bits não têm essa borda em nenhum horizonte que importe, e é por isso que o mesmo valor em milissegundos é 2.147.483.647.000.

3. Um valor em milissegundos com fração: 1.768.478.400.500

   1. O número tem 13 dígitos e a unidade diz milissegundos, então é o mesmo instante do primeiro exemplo mais meio segundo
   2. O horário descarta a fração em vez de arredondá-la, então sai 12:00:00 e não 12:00:01
   3. A linha dos segundos é truncada para acompanhar: 1.768.478.400, e não 1.768.478.401
   4. A linha dos milissegundos mantém a fração, 1.768.478.400.500, porque é o único lugar do resultado em que ela existe

   É o único caso em que arredondar e truncar discordam, e a razão de a linha dos segundos truncar. Arredondar meio segundo para cima imprimiria um valor de segundos um acima do horário logo acima dele, e quem comparasse as duas linhas concluiria que uma delas está quebrada. Manter todas as linhas coerentes com o horário exibido importa mais do que manter o inteiro mais próximo.

4. A outra direção: 15 de janeiro de 2026, 12:00:30 UTC

   1. A data vira uma contagem de dias desde 1º de janeiro de 1970 e é multiplicada por 86.400 para dar os segundos até a meia-noite
   2. Os trinta segundos passados da meia-noite entram na soma: o total é 1.768.478.430, que é o valor do primeiro exemplo mais 30
   3. O campo de tempo aceita segundos, então 12:00:30 é lido exatamente em vez de ser arredondado para baixo até o minuto
   4. As linhas de data e de dia da semana voltam iguais, porque converter para fora e de volta é a operação identidade

   Rodar a direção contrária sobre um valor que você já converteu é a maneira mais barata de conferir um timestamp: se a ida e a volta não devolverem o número de partida, provavelmente a unidade estava errada. Digitar um número de 10 dígitos com a unidade em milissegundos erra por um fator de mil, e isso aparece aqui como uma data de janeiro de 1970 em vez de como um erro.

Tudo o que a página informa está em UTC, e ela nunca converte para um fuso local — um timestamp Unix é definido sem fuso, então a página que transforma isso em uma leitura de relógio local é a calculadora de fuso horário. A janela vai de 1970-01-01T00:00:00Z a 2100-12-31T23:59:59Z, e valores fora dela são recusados em vez de calculados em silêncio: timestamps negativos são Unix timestamps legais para datas anteriores à época, mas a página avisa e para, em vez de devolver uma resposta de 1969 que contradiria o intervalo que ela mesma declara. Frações de segundo são truncadas, não arredondadas, então um valor em milissegundos não perde a precisão, mas também não influencia os segundos exibidos. A página não interpreta datas em outros formatos, não lê o relógio da máquina em que você está e não faz aritmética — para a data trinta dias depois de um valor convertido, use uma calculadora de datas. As duas linhas de texto — Hora (UTC) e ISO 8601 — saem exatamente como um sistema as escreve, 12:00:00 e 2026-01-15T12:00:00Z: não há separador nem tradução a aplicar nelas. As duas linhas de contagem, por outro lado, são números e seguem a grafia brasileira, como em 1.768.478.400 e 1.768.478.400.000.

O que é tempo de época?

Tempo de época, também chamado de tempo Unix ou epoch time, é o número de segundos passados desde 1970-01-01T00:00:00 UTC, o ponto zero a partir do qual os sistemas Unix contam. Nada nele depende de onde você está: o tempo de época é definido em UTC, então o mesmo instante tem o mesmo valor no mundo inteiro, e duas máquinas em fusos diferentes que discordem do relógio local continuam concordando sobre o timestamp.

Como converter um timestamp em data?

Digite o valor, diga se ele conta segundos ou milissegundos e leia a data e o horário que voltam. A primeira coisa a conferir é o número de dígitos: uma contagem em segundos para uma data deste século tem 10 dígitos e uma contagem em milissegundos tem 13. Um valor de 13 dígitos lido como segundos cai dezenas de milhares de anos no futuro e é recusado; um valor de 10 dígitos lido como milissegundos cai em janeiro de 1970, que é o engano que não se anuncia. Converter de volta pela outra direção é a confirmação mais rápida.

O que é o problema do ano 2038?

O problema do ano 2038 é o que acontece quando um sistema guarda um timestamp em um inteiro de 32 bits com sinal: o maior valor que esse tipo comporta é 2.147.483.647, que é 2038-01-19T03:14:07 UTC, e um segundo depois o contador estoura para uma data de 1901. É um limite de armazenamento, e não do timestamp em si, e contadores de 64 bits não o têm. Esta página converte esse valor e os que vêm depois dele sem dificuldade, porque trabalha em precisão dupla em vez de em inteiros de 32 bits.

Devo guardar segundos ou milissegundos?

Os dois são muito usados e nenhum está errado, mas um valor sozinho não diz qual dos dois é, então a unidade precisa viajar junto com o número ou ser combinada antes. Milissegundos preservam frações de segundo e são o que o objeto Date do JavaScript e muitos sistemas de log usam; segundos são o que a POSIX define e o que a maior parte das APIs e dos bancos de dados devolve. Converter entre os dois é uma multiplicação por 1.000, e esta página imprime as duas linhas para que o par fique visível de imediato.

O formato ISO 8601 é a mesma coisa que um timestamp?

Não, e é fácil confundir os dois porque ambos descrevem o mesmo instante. O formato ISO 8601 é a escrita — 2026-01-15T12:00:00Z — e é legível por pessoas, ordenável e inequívoco quanto ao deslocamento UTC por causa do Z no fim. Um timestamp Unix é uma contagem única, sem formatação nenhuma. A string ISO 8601 é o que você cola em um documento ou em uma URL; a contagem é o que você guarda ou compara. Esta página imprime as duas a partir da mesma conversão, para que possam ser conferidas uma contra a outra.

• The Open Group Base Specifications — Seconds Since the Epoch — The Open Group — a definição normativa da época e do tratamento de segundos intercalares
• RFC 3339 — Date and Time on the Internet: Timestamps — IETF — o formato da string terminada em Z que esta página imprime
• MDN — Date — MDN Web Docs — a contagem em milissegundos e o intervalo que ela cobre em JavaScript