Conversor de Timestamp Unix

Conversor de Timestamp Unix

Converta instantaneamente entre timestamps do epoch Unix e datas e horários legíveis por humanos. Esta ferramenta é usada diariamente por desenvolvedores de software depurando arquivos de log, administradores de banco de dados lendo timestamps armazenados, analistas de dados trabalhando com dados de respostas de API e qualquer pessoa que precise saber exatamente qual momento um número de 10 dígitos como 1746057600 representa.

Como Funciona a Conversão de Timestamp Unix

Um timestamp Unix é uma contagem de segundos decorridos desde o epoch Unix -- 1º de janeiro de 1970, 00:00:00 UTC. A cada segundo que passa, o timestamp é incrementado em 1.

Timestamp para data -- o total de segundos é convertido dividindo primeiro os anos (considerando anos bissextos de 365 e 366 dias), depois os meses (de durações variáveis), depois os dias, horas, minutos e segundos restantes. O resultado é sempre em UTC; exibir o horário local exige somar ou subtrair o deslocamento do fuso horário em segundos.

Data para timestamp -- soma-se todos os componentes desde o epoch: anos x 31.536.000 (ajustado para anos bissextos) + dias do mês x 86.400 + horas x 3.600 + minutos x 60 + segundos. Exemplo: 1º de janeiro de 2025, 00:00:00 UTC = 1.735.689.600.

Segundos vs. milissegundos -- o Date.now() do JavaScript e muitas APIs REST retornam milissegundos desde o epoch (um número de 13 dígitos como 1.735.689.600.000). O tempo Unix padrão usa segundos (10 dígitos). Divida os milissegundos por 1.000 para obter segundos; multiplique os segundos por 1.000 para obter milissegundos.

Exemplos Práticos

Exemplo 1 -- Lendo um log de servidor. Um log de acesso do nginx mostra uma requisição no timestamp 1700000000. Convertendo: 1.700.000.000 segundos / 86.400 = 19.675,9 dias após 1º de janeiro de 1970 = 14 de novembro de 2023, 22:13:20 UTC. No horário do leste dos EUA (UTC-5), isso é 14 de novembro de 2023, às 17:13:20.

Exemplo 2 -- Cabeçalho de limite de taxa de API. Uma resposta da API do GitHub inclui X-RateLimit-Reset: 1746057600. Convertendo: isso é 30 de abril de 2025, 16:00:00 UTC. Se o horário atual for 15:45 UTC, o limite de taxa é redefinido em 15 minutos.

Exemplo 3 -- Aritmética de timestamp em banco de dados. Uma sessão de usuário armazenada no PostgreSQL começou em created_at = 1735689600 e expirou em 1735693200. A diferença é de 3.600 segundos = exatamente 1 hora. A aritmética com timestamps é uma simples subtração, sem necessidade de biblioteca de datas.

Tabela de Referência

Quando Usar

• Decodificar timestamps em logs de servidor, relatórios de falha ou painéis de monitoramento onde os eventos são armazenados como inteiros.
• Converter campos de resposta de API (expiração de JWT, expiração de token OAuth, timestamps de webhook) em datas legíveis para depuração.
• Gerar um timestamp Unix futuro ou passado para usar em uma consulta de banco de dados, chamada de API ou tarefa agendada.
• Calcular a diferença de tempo entre dois eventos armazenados como timestamps Unix subtraindo um do outro.
• Verificar se um timestamp de um sistema terceiro representa a data esperada antes de usá-lo em código de produção.

Erros Comuns

1. Confundir segundos com milissegundos. Um timestamp de 10 dígitos como 1700000000 está em segundos; um timestamp de 13 dígitos como 1700000000000 está em milissegundos. Tratar um timestamp em milissegundos como se fosse segundos gera uma data 1.000 vezes mais distante no futuro -- o número 1700000000000 como segundos corresponderia ao ano 55.000. Sempre verifique a quantidade de dígitos: 10 dígitos = segundos, 13 dígitos = milissegundos.
2. Exibir timestamps UTC como horário local sem converter. Um timestamp 1700000000 corresponde a 14 de novembro de 2023, às 22:13:20 UTC. Em Nova York (UTC-5 em novembro), são 17:13. Mostrar o horário UTC para um usuário de Nova York sem indicar que é UTC causa discrepâncias confusas de 5 horas.
3. Assumir que todos os sistemas usam a mesma precisão de timestamp. O time.time() do Python retorna segundos com casas decimais fracionárias (por exemplo, 1700000000.123456). O Date.now() do JavaScript retorna milissegundos inteiros. O UNIX_TIMESTAMP() do MySQL retorna segundos inteiros. Misturar esses formatos sem normalizá-los causa bugs de comparação com erro de 1 ou de 1.000.
4. Ignorar timestamps negativos. Timestamps Unix anteriores a 1º de janeiro de 1970 são negativos. O timestamp -86400 corresponde a 31 de dezembro de 1969, às 00:00:00 UTC. Alguns sistemas e bibliotecas de linguagens mais antigos não tratam corretamente timestamps negativos e podem retornar erros ou datas incorretas para qualquer data anterior a 1970.

Referências Rápidas

Constantes úteis para cálculos rápidos de timestamp:

Dicas

1. Um timestamp Unix de 10 dígitos começando com 17 é uma data entre o final de 2023 e aproximadamente meados de 2027. Um timestamp começando com 16 está entre 2020 e 2023. Use os primeiros dígitos como uma verificação rápida de sanidade.
2. Para obter o timestamp Unix atual: JavaScript -- Math.floor(Date.now() / 1000), Python -- int(time.time()), Bash -- date +%s, SQL (MySQL) -- UNIX_TIMESTAMP(), SQL (PostgreSQL) -- EXTRACT(EPOCH FROM NOW()).
3. Para encontrar o timestamp da meia-noite UTC em qualquer data, digite a data às 00:00:00 UTC. Timestamps de meia-noite são sempre divisíveis por 86.400.
4. Armazene todos os timestamps do seu banco de dados em UTC. Converta para o fuso horário local do usuário apenas na camada de exibição. Isso evita bugs quando os usuários mudam de fuso horário ou quando ocorrem transições de horário de verão.
5. O problema do Ano 2038 afeta timestamps de inteiro de 32 bits com sinal, que atingem seu limite em 2.147.483.647 (19 de janeiro de 2038, 03:14:07 UTC). Se o seu sistema ainda armazena timestamps como inteiros de 32 bits, planeje a migração para inteiros de 64 bits antes de 2038.
6. Ao comparar dois timestamps de sistemas diferentes, verifique se eles usam o mesmo epoch. A maioria dos sistemas usa 1º de janeiro de 1970, mas o FILETIME do Windows usa 1º de janeiro de 1601, e o NTP usa 1º de janeiro de 1900. Converter entre epochs exige somar ou subtrair a diferença em segundos entre as duas datas de referência.