Unix Timestamp Converter

Um timestamp Unix é a forma mais limpa de um computador guardar um instante: um inteiro, sem fuso, sem formatação, sem discussão sobre se 03/02 é março ou fevereiro. É exatamente por isso que é ilegível para uma pessoa. Convertê-lo de volta é o momento em que uma linha de registro, uma coluna de banco de dados ou uma resposta de API deixa de ser um número e passa a ser um acontecimento sobre o qual se pode raciocinar.

Converta timestamps Unix em datas legíveis e datas de volta em tempo epoch com precisão ao segundo.

Este conversor lê um valor epoch em qualquer das quatro unidades Unix, em série do Excel, em ticks .NET, em FILETIME do Windows e nos microssegundos internos do Chrome, e escreve uma data de volta no mesmo leque de formas. Cada conversão acontece no seu dispositivo enquanto você digita, e qualquer valor na tela é copiado com um toque.

Vantagens de converter timestamps

• Legibilidade: um inteiro de dez dígitos passa a data, dia da semana, semana ISO e dia do ano.
• Bancos de dados: leia uma coluna armazenada sem escrever uma consulta só para formatá-la.
• Desenvolvimento de APIs: confirme o que um campo significa antes de confiar no cliente que o desenha.
• Depuração: compare dois timestamps de dois sistemas nas mesmas unidades e no mesmo fuso.
• Mudança de formato: passe entre epoch, ISO 8601, RFC 3339, RFC 2822 e SQL sem escrever um script.

O tempo Unix conta os segundos decorridos desde 1 de janeiro de 1970 às 00:00 UTC, uma origem chamada epoch Unix. Não conta segundos bissextos: por definição, todos os dias têm exatamente 86.400 segundos, o que torna a aritmética simples e faz do número uma aproximação do tempo realmente decorrido, e não uma medição dele.

Características do timestamp

• Conta desde 1 de janeiro de 1970 às 00:00 UTC e fica negativo para instantes anteriores.
• Não transporta fuso horário, por isso o mesmo valor significa o mesmo instante em toda a Terra.
• Ordena-se e compara-se como um inteiro simples, e é por isso que os bancos de dados o guardam.
• Ignora segundos bissextos — um dia Unix tem sempre exatamente 86.400 segundos.
• Aparece em quatro unidades comuns: segundos, milissegundos, microssegundos e nanossegundos.

Características do formato de data

• Legível por uma pessoa sem consultar nada, o que um inteiro nunca é.
• Transporta um fuso ou um desvio, por isso nomeia uma hora de relógio além de um instante.
• Existe em normas concorrentes — ISO 8601, RFC 3339, RFC 2822 e SQL diferem nos detalhes.
• É ambígua escrita só com números: 03/02/2026 são dois dias diferentes.
• Precisa de um calendário para ser comparada, quando um timestamp só precisa de uma subtração.

O mesmo instante se escreve de quatro maneiras conforme a unidade que cada sistema escolheu, e as quatro só diferem em zeros no fim — daí que colar a errada produza uma data em 1970 ou no ano 56000 em vez de um erro.

Como a unidade é detectada

Pela quantidade de dígitos da parte inteira, não pela grandeza do valor: até 11 dígitos lê-se como segundos, 12 a 14 como milissegundos, 15 a 17 como microssegundos e 18 ou mais como nanossegundos. Estes intervalos foram escolhidos para que qualquer instante entre 1973 e o ano 5138 se resolva da mesma maneira em qualquer unidade. Antes de 1973 a ambiguidade é real — 1000000 é 12 de janeiro de 1970 em segundos e 1 de janeiro de 1970 em milissegundos — por isso o painel nomeia a unidade escolhida e a barra lateral permite impô-la.

Porque os nanossegundos exigem aritmética exata

Um valor epoch em nanossegundos de qualquer data posterior a setembro de 2001 é maior do que 9.007.199.254.740.991, o maior inteiro que um número de ponto flutuante guarda de forma exata. Um conversor que leia nanossegundos para um número e os volte a imprimir perde por isso até 256 nanossegundos, em silêncio, e a saída continua parecendo um timestamp plausível. Esta ferramenta guarda o valor como inteiro exato desde que é lido até que é impresso, por isso a saída em nanossegundos são os dígitos que colou.

O tempo Unix não é a única origem em uso. Outras quatro aparecem com frequência suficiente para que um conversor que não as leia o obrigue a procurar uma segunda ferramenta, por isso as quatro são suportadas aqui e nomeadas no painel quando uma é detectada.

Datas de série do Excel

O Excel conta dias desde 31-12-1899, com a fração do dia depois da vírgula — e trata 1900 como ano bissexto, o que não foi. A série 60 é por isso 29 de fevereiro de 1900, uma data que nunca aconteceu, mantida por compatibilidade com o Lotus 1-2-3. Todas as séries a partir de 61 estão um dia à frente de uma contagem ingénua e as abaixo de 60 não estão, por isso a correção habitual de subtrair um em todo o lado falha para 125 anos de datas. Este conversor trata bem a separação e assinala a série 60 em vez de lhe inventar uma data.

Ticks, FILETIME e o tempo do Chrome

Os ticks .NET são intervalos de 100 nanossegundos desde 01-01-0001. O FILETIME do Windows usa o mesmo tick de 100 nanossegundos mas conta desde 01-01-1601. O Chrome e o WebKit guardam microssegundos a partir dessa mesma origem de 1601. Os três são inteiros grandes que não se parecem com nada em especial, e é por isso que vale a pena nomeá-los: escolha o formato na barra lateral e a conversão é exata, com a precisão ao nanossegundo preservada de ponta a ponta.

Um timestamp não tem fuso horário. Uma data tem. Todos os erros de um conversor de timestamps vivem no espaço entre essas duas frases, e é por isso que esta ferramenta põe um fuso nomeado ao lado da entrada em vez de usar em silêncio aquele em que o navegador se encontra.

Porque uma data local precisa de um fuso nomeado

Se você digitar 3 de fevereiro de 2026 às 14:05 sem desvio, isso é uma hora de relógio, não um instante: é um momento diferente em Calcutá e em Londres. Um conversor que a leia no fuso do próprio navegador dá respostas diferentes a duas pessoas olhando para o mesmo compartilhamento de tela, e a nenhuma delas é dito que fuso foi usado. Aqui o fuso é um controle explícito, o resultado indica que fuso usou e qual era o desvio nesse instante, e a faixa em baixo mostra o mesmo momento em todos os lugares que acrescentou.

Saltos e sobreposições

Duas vezes por ano um fuso com horário de verão salta uma hora e repete outra. Uma hora de relógio dentro da hora saltada nunca acontece, e uma dentro da repetida acontece duas vezes. A maioria dos conversores escolhe uma em silêncio. Este informa em que caso está e deixa você decidir se uma hora ambígua significa o instante anterior, o posterior, ou deve ser recusada.

A fronteira mais famosa do tempo Unix não é a epoch, é o teto. Já está perto o suficiente para que dispositivos embebidos, formatos de arquivo e bancos de dados de longa vida estejam sendo testados de verdade contra ele.

O que transborda

Um time_t de 32 bits com sinal vai até 2.147.483.647, ou seja 03:14:07 UTC de 19 de janeiro de 2038. Um segundo depois o valor passa a negativo e o mesmo sistema lê-o como 13 de dezembro de 1901. Afeta tudo o que armazene um timestamp em quatro bytes com sinal: código C antigo, alguns cabeçalhos binários, uns quantos protocolos de rede e imenso firmware embebido.

O que fazer

Armazene valores de 64 bits e teste a fronteira em vez de presumi-la. A barra lateral oferece 2038 e o teto sem sinal de 2106 como saltos diretos, para que possa colar o valor exato que deveria fazer um sistema tropeçar e comparar o que ele reporta com a data verdadeira. Este conversor não tem limite de 32 bits próprio: lê todo o intervalo representável, cerca de 275.760 anos para cada lado de 1970, e recusa o que passa disso com uma mensagem em vez de uma resposta errada.

Três modos cobrem as três perguntas com que as pessoas chegam, e um quarto trata de uma lista inteira. Não é preciso carregar nada nem criar conta.

1. 1. Converter timestamp para data

   Escolha Timestamp para data e cole o número, por exemplo 1704067200. A unidade é detectada pela contagem de dígitos e o resultado aparece em todos os formatos ao mesmo tempo.

2. 2. Converter data para timestamp

   Escolha Data para timestamp e escreva a data, por exemplo 2026-02-03T14:05:06Z. Indique o fuso em que deve ser lida e o valor epoch aparece nas quatro unidades.

3. 3. Usar a hora atual

   Epoch ao vivo mostra o timestamp atual a correr. Ponha em pausa para copiar um valor exato, ou envie esse instante diretamente para o conversor.

Converta quando o número tiver de ser lido por uma pessoa, comparado com um relógio, ou alinhado com um acontecimento registrado noutro sistema.

Casos de uso ideais

• Ler uma coluna de registro: cole a coluna inteira em Lista em massa e obtenha uma tabela que se percorre de relance.
• Bancos de dados: transforme um inteiro armazenado numa data no fuso onde os seus usuários realmente estão.
• Respostas de API: confirme se um campo vem em segundos ou milissegundos antes de escrever o cliente.
• Testar fronteiras: dê a um sistema o valor de 2038 ou de 2106 e veja o que ele reporta.
• Comparar sistemas: ponha uma contagem de ticks .NET e um valor Unix em milissegundos nas mesmas unidades.

Um punhado de números que explicam quase todas as surpresas do tempo epoch.

Números-chave

• Os segundos Unix precisaram de um décimo dígito em 9 de setembro de 2001, exatamente em 1000000000.
• O teto de 32 bits com sinal são 2147483647 segundos: 19 de janeiro de 2038 às 03:14:07 UTC.
• O teto de 32 bits sem sinal são 4294967295 segundos: 7 de fevereiro de 2106 às 06:28:15 UTC.
• Os valores epoch em nanossegundos passaram o limite de inteiro exato de um número em 2001.
• Um dia Unix tem sempre 86.400 segundos — os segundos bissextos não são contados.
• A série 60 do Excel é 29 de fevereiro de 1900, uma data que nunca existiu.

Alguns hábitos que evitam que um timestamp esteja errado sem ninguém dar por isso.

Pontos a levar em conta

• Conte os dígitos antes de presumir que um valor está em segundos — dez e treze parecem-se de relance.
• Indique o fuso quando escrever uma data; um desvio na string vale mais do que uma convenção na sua cabeça.
• Armazene e transporte timestamps como inteiros, e formate-os só na fronteira do sistema.
• Use armazenamento de 64 bits para tudo o que vá sobreviver a 2038.
• Quando um valor atravessa uma mudança de hora, confirme que instante significava uma hora ambígua.

Quando não usar

• Não use um timestamp para registrar um aniversário ou um feriado — são datas de calendário, não instantes.
• Não compare timestamps de sistemas com relógios não sincronizados esperando precisão ao milissegundo.
• Não use segundos epoch onde precisa de precisão de segundo bissexto; o tempo Unix não os conta.
• Não converta uma hora de relógio sem nomear o fuso a que pertence.

Tudo roda no seu dispositivo, por isso o teto é o seu equipamento e não uma quota de servidor. Os limites gratuitos estão onde uma pessoa para e um script começa.

• Linhas em massa: a versão gratuita converte 100 linhas numa passagem. A Pro só é limitada pelo que o seu dispositivo aguentar.
• Lugares comparados: a gratuita mostra um instante em 4 lugares ao mesmo tempo. A Pro acrescenta tantos quantos o dispositivo desenhar.
• Tamanho da colagem: até 10 MB de texto na gratuita, sem teto na Pro.
• Exportação CSV e links: Pro. Copiar qualquer valor na tela é sempre gratuito.
• Segundos bissextos: não são representáveis em tempo Unix nem no relógio que um dispositivo mantém, por isso 23:59:60 é recusado em vez de arredondado.

Nenhum timestamp, data ou lista colada sai alguma vez da página. Não há passo de carregamento, nem fila, nem servidor em que confiar, e é por isso que o conversor continua funcionando com a rede desligada e que uma lista tirada de um registro de produção pode ser colada aqui sem risco.

• Conversores de hora e data
• Conversor de fusos tudo-em-um
• Calculadora de idade
• Calculadora de datas
• UTC para Mumbai