Conversor de Timestamp Unix

Introdução

Um timestamp Unix (ou tempo epoch) é a forma padrão como os computadores representam o tempo: um único inteiro que conta os segundos desde 1º de janeiro de 1970 à meia-noite UTC, excluindo segundos bissextos. Aparece em registros de banco de dados, respostas de API, tokens JWT, arquivos de log, agendamentos cron e cabeçalhos de cache. Enquanto as máquinas leem esses inteiros instantaneamente, os humanos precisam que eles sejam traduzidos em datas e horários de calendário — frequentemente em vários formatos simultaneamente.

O Conversor de Timestamp Unix atende desenvolvedores, administradores de sistemas e analistas de segurança que precisam decodificar timestamps de logs, verificar a expiração de tokens, agendar jobs cron entre fusos horários ou consultar rapidamente um valor epoch histórico ou futuro. A ferramenta é dividida em dois blocos independentes:

• Bloco A (Timestamp Unix → Data e Hora): insira um timestamp numérico e veja-o renderizado em 21 formatos de data e hora, organizados por família padrão.
• Bloco B (Data e Hora → Timestamp Unix): escolha uma data de calendário, hora e offset de fuso horário, e obtenha o timestamp equivalente em segundos, milissegundos e microssegundos.

Ambos os blocos têm seu próprio seletor de fuso horário, para que você possa trabalhar em UTC para uma direção e com um offset personalizado para a outra sem contaminação cruzada.

Como funciona

O tempo Unix conta segundos a partir da epoch (1º de janeiro de 1970, 00:00:00 UTC). Cada tick adiciona exatamente um segundo. Por estar ancorado ao UTC, um timestamp Unix representa o mesmo instante em qualquer lugar da Terra — o fuso horário só importa quando você o renderiza como uma string legível.

A ferramenta usa o objeto JavaScript Date nativo do navegador para todas as conversões. Cada Date armazena internamente o tempo como um único número: milissegundos desde a epoch Unix. Quando você insere um timestamp, a ferramenta constrói um Date e lê suas propriedades UTC ou locais dependendo do seletor de fuso horário ativo. Quando você insere uma data e hora de calendário, a ferramenta calcula a diferença da epoch ajustada para o offset de fuso horário especificado.

Unidades de timestamp entre ecossistemas

Plataformas e linguagens diferentes usam unidades de epoch distintas. O seletor de unidades da ferramenta permite que você corresponda à precisão da sua fonte:

A ferramenta converte sua entrada para segundos internamente. Se você colar um valor de 13 dígitos de Date.now() do JavaScript, defina a unidade para milissegundos e a ferramenta lidará com a divisão.

Fuso horário e horário de verão

Um timestamp Unix sempre representa o mesmo instante físico. O seletor de fuso horário em cada bloco apenas muda como esse instante é exibido ou interpretado.

• Modo UTC: renderiza toda a saída com base no Tempo Universal Coordenado. O formato RFC 3339 usa um sufixo Z literal em vez de +00:00.
• Modo local: usa o fuso horário do sistema do navegador, incluindo ajustes automáticos de horário de verão.
• Modo personalizado: um offset UTC numérico entre -12:00 e +14:00. A ferramenta aplica este offset diretamente sem qualquer correção de horário de verão — ela trata seu offset como um relógio de parede fixo.

Quando o horário de verão está em vigor, o offset do fuso horário local muda. O mesmo timestamp exibido no modo Local pode mostrar uma hora diferente do que mostrava no mês anterior. Isso é esperado: o timestamp é o mesmo, mas a convenção do relógio local mudou.

Para as linhas formatadas como local (Locale, Locale Date, Locale Time), a ferramenta respeita tanto o fuso horário selecionado quanto as configurações de idioma do navegador. Se você escolher o modo UTC, toLocaleString recebe { timeZone: 'UTC' }, garantindo que o formato local use o fuso horário correto.

Uso

Bloco A — Timestamp para Data e Hora

1. Insira um timestamp Unix no campo de entrada (apenas dígitos, sinal de menos opcional para datas anteriores a 1970).
2. Selecione a precisão da entrada: Segundos, Milissegundos ou Microssegundos.
3. Escolha um fuso horário: UTC, Local (fuso horário do sistema), ou Personalizado (insira um offset entre -12 e +14 em passos de meia hora).
4. Leia os resultados — 21 linhas de formatos de data e hora são atualizadas em tempo real.

Bloco B — Data e Hora para Timestamp

1. Insira o ano diretamente. Use os menus suspensos para mês, dia, hora, minuto e segundo.
2. Escolha um fuso horário no seletor UTC/GMT: Local corresponde ao fuso horário do sistema; entradas numéricas como UTC+8 tratam a entrada como horário de parede naquele fuso.
3. Os resultados do timestamp aparecem imediatamente em segundos, milissegundos, microssegundos, hexadecimal e tempo relativo.

Os dois blocos operam independentemente. Alterar o Bloco A não afeta o Bloco B e vice-versa. Isso permite que você compare timestamps lado a lado ou bloqueie um valor de referência enquanto explora diferentes formatos.

Tutorial

Cenário 1: Decodificar um timestamp de um log do servidor

O log da sua aplicação mostra o timestamp 1742345678 — uma chamada de API que falhou. Você precisa saber exatamente quando aconteceu e também verificar o formato HTTP-date para correlacionar com cabeçalhos de resposta HTTP.

1. Abra o Conversor de Timestamp Unix.
2. Digite 1742345678 no campo de entrada do Bloco A.
3. Os resultados exibem 21 linhas de formato, incluindo:
   • @ Format: 3/19/2025 @ 2:14:38 PM +0000 (formato humano de varredura rápida)
   • RFC 1123Z: Wed, 19 Mar 2025 14:14:38 +0000 (padrão HTTP-date, corresponde aos cabeçalhos Date e Last-Modified)
   • Relative: 124d (há quanto tempo a solicitação ocorreu)
4. Mude o fuso horário para Local para ver que horas eram no seu próprio fuso horário.

Cenário 2: Agendar um job cron em um horário específico

Você precisa que um job cron seja executado às 3:30 AM Eastern Time em 15 de junho de 2026. O Eastern Daylight Time é UTC-4 em junho.

1. No Bloco B, defina a data para 15 de junho de 2026 e a hora para 03:30:00.
2. Defina o seletor UTC/GMT para UTC+4 (EDT é UTC-4, então insira -4).
3. Leia o valor em Segundos — este é o seu timestamp cron. As linhas Hex e Relative também são atualizadas, dando a você uma referência tanto legível por máquina quanto por humano simultaneamente.

Dicas úteis

Casos de uso dos formatos

Cada formato de saída serve a um propósito específico. Veja quando usar cada um:

Implementações em linguagens

Obtenha o timestamp Unix atual em sua linguagem preferida:

// Go
time.Now().Unix()      // segundos
time.Now().UnixMilli() // milissegundos (Go 1.17+)

// JavaScript
Math.floor(Date.now() / 1000) // segundos
Date.now()                     // milissegundos

// PHP
time();              // segundos
intval(microtime(true) * 1000); // milissegundos

# Python
import time; int(time.time())         # segundos
import time; int(time.time() * 1000)  # milissegundos

Dicas gerais

• Timestamps pré-1970: Insira valores negativos. 1º de dezembro de 1960 às 00:00:00 UTC é -286329600.
• Entrada hexadecimal: Valores hexadecimais (com ou sem prefixo 0x) são analisados automaticamente — insira 0x6618E1FE e veja o equivalente decimal.
• Comparar fusos horários: Defina o fuso horário do Bloco A para UTC e o fuso horário do Bloco A para Local simultaneamente para ver como o mesmo instante é renderizado em ambos.

Alternativas

Solução de problemas

Especificações técnicas

• Motor de conversão: Objeto JavaScript Date (padrão ECMAScript)
• Intervalo de timestamp: Intervalo numérico completo do JavaScript (±9 quadrilhões de segundos, cobrindo bilhões de anos)
• Entrada suportada: Inteiros decimais, valores negativos (pré-1970)
• Precisão da entrada: Segundos, milissegundos ou microssegundos (configurável)
• Suporte a fusos horários: UTC, local (sistema do navegador), offset GMT personalizado (-12 a +14 em passos de 0,5 hora); independente para cada bloco

As 21 famílias de formatos

Árvore genealógica dos formatos

Os formatos de data e hora nesta ferramenta derivam de quatro linhagens:

• RFC 822 (1982) definiu o formato original de data de email com ano de 2 dígitos. RFC 1123 (1989) o substituiu com ano de 4 dígitos. RFC 1123Z é o mesmo formato usando um offset numérico de fuso horário (+0000) em vez de uma abreviação alfabética (UTC). Juntos, eles cobrem cabeçalhos HTTP (1123Z) e formatos de email (822).
• ISO 8601 (1988) estabeleceu o padrão internacional para representação de data e hora. RFC 3339 (2002) perfila a ISO 8601 para uso na Internet, adicionando requisitos como o Z obrigatório para UTC. A maioria das APIs modernas escolhe um destes dois.
• Constantes Go time (ANSIC, UnixDate, RubyDate, etc.) são layouts de convenência incorporados à biblioteca padrão do Go. Eles espelham convenções POSIX (ctime output), padrões RFC e formas de conveniência específicas do Go (DateOnly, Kitchen, Stamp).
• Formatos Locale usam a API Intl.DateTimeFormat do navegador, que segue o Unicode Common Locale Data Repository (CLDR). A saída exata depende da configuração de idioma do navegador do usuário.

Compatibilidade

• Navegadores: Chrome 90+, Firefox 90+, Safari 15+, Edge 90+
• Dependências: Nenhuma — JavaScript puro, zero bibliotecas de terceiros
• Processamento de dados: 100% lado do cliente — zero requisições de rede

Recursos

• Conversão bidirecional entre timestamps Unix e datas legíveis
• Exibição em tempo real do timestamp Unix atual com atualizações automáticas
• Múltiplos formatos de saída: UTC, horário local, ISO 8601, hex e tempo relativo
• Suporte a offset de fuso horário personalizado para conversão precisa de data para timestamp
• Processamento no lado do cliente — nenhum dado enviado ao servidor

Perguntas frequentes