Como saber se o timestamp está em segundos ou milissegundos?

Conte os dígitos. Para datas atuais, 10 dígitos são segundos, 13 são milissegundos, 16 são microssegundos e 19 são nanossegundos. O conversor faz essa contagem sozinho e mostra a unidade que usou. Se a leitura não fizer sentido, escolha a unidade manualmente.

Por que minha data aparece em 1970?

O valor está em segundos e foi lido como milissegundos. Em JavaScript, new Date(1790254800) dá 21 de janeiro de 1970, e new Date(1790254800 * 1000) dá a data certa. O inverso também acontece: milissegundos lidos como segundos viram uma data muito no futuro.

O timestamp depende do fuso horário?

Não. O epoch é sempre contado a partir de 1970 em UTC e é o mesmo em qualquer país. O fuso só muda a data e a hora exibidas. Aqui você escolhe o fuso da exibição e vê UTC e ISO 8601 ao mesmo tempo.

Por que uma data antiga em São Paulo aparece com UTC−2?

Porque naquela data vigorava o horário de verão, que o Brasil usou até fevereiro de 2019. O conversor usa a base de fusos IANA, que tem as regras de cada ano, e marca o resultado com o aviso de horário de verão.

O que acontece com timestamps depois de 2038?

Nada, se o sistema usa 64 bits. O limite de 2147483647 (19/01/2038 03:14:07 UTC) só afeta quem guarda o epoch em inteiro de 32 bits com sinal, como o tipo TIMESTAMP do MySQL. Cole 2147483648 aqui para ver o segundo seguinte.

Timestamp pode ser negativo?

Pode. Números negativos são datas antes de 1º de janeiro de 1970. O conversor aceita valores negativos em qualquer unidade e também converte datas antigas para epoch negativo.

Como pegar o timestamp atual no código?

Em JavaScript, Math.floor(Date.now() / 1000) dá segundos e Date.now() dá milissegundos. Em Python, int(time.time()). Em Java, Instant.now().getEpochSecond(). No shell, date +Unix Timestamp Converter: Epoch para Data e Data para Epoch - Código ao Ponto. A seção de código desta página tem também SQL e a conversão nos dois sentidos.

As linhas de log que eu colo são enviadas para algum servidor?

Não. A conversão acontece no navegador, e os valores colados não são enviados nem gravados. As métricas de uso registram só a unidade detectada e o tipo de conversão, nunca o conteúdo.

Conversor de Timestamp Unix

Cole um epoch em segundos, milissegundos, microssegundos ou nanossegundos e veja a data no seu fuso, em UTC e em ISO 8601. A unidade é detectada pelo número de dígitos. Também dá para colar uma data e ver o epoch dela.

Timestamp atual

Timestamp ou data

Nenhum valor ainda

Cole um timestamp ou uma data no campo. Todos os formatos aparecem aqui na hora, cada um com botão de copiar.

Unidade

Fuso horário da data

Data para timestamp

Escolha data e hora. O epoch é calculado no fuso UTC, o mesmo selecionado acima.

Data Hora

Somar ou subtrair tempo, útil para montar massa de teste com datas no passado ou no futuro

Converter linhas de log

Cole linhas de log, JSON ou CSV. Cada número de 10, 13, 16 ou 19 dígitos vira data ISO 8601 no fuso UTC. As linhas ficam no seu navegador.

O timestamp veio do exp, iat ou nbf de um JWT? O decodificador mostra o token inteiro e diz se ele já expirou.

Decodificar JWT

Precisa só formatar uma data em ISO String ou UTC String? O conversor de formato de data faz isso em um clique.

Formatar data

Timestamp em código

Como pegar o timestamp atual e converter nos dois sentidos nas linguagens mais comuns.

// Now, in seconds and in milliseconds
Math.floor(Date.now() / 1000); // 1790254800
Date.now();                    // 1790254800123

// Epoch to date (Date expects milliseconds)
new Date(1790254800 * 1000).toISOString();

// Date to epoch in seconds
Math.floor(new Date("2026-09-24T10:00:00-03:00").getTime() / 1000);

O que é Unix timestamp

Unix timestamp, ou epoch, é a quantidade de segundos desde 1º de janeiro de 1970 às 00:00:00 UTC, sem contar segundos bissextos. O mesmo número representa o mesmo instante em qualquer lugar do mundo, e por isso ele aparece em coluna de banco, log, fila de mensagens, resposta de API e nas claims exp, iat e nbf do JWT. O fuso horário só entra na hora de mostrar a data para uma pessoa.

Segundos, milissegundos, microssegundos ou nanossegundos

A unidade não vem escrita no número. Para datas entre 2001 e 2286, a contagem de dígitos resolve: cada unidade mais fina acrescenta 3 dígitos. É assim que este conversor detecta a unidade.

Dígitos	Unidade	Exemplo	Onde costuma aparecer
10	Segundos	1790254800	time() do PHP, int(time.time()) do Python, exp do JWT, EXTRACT(EPOCH) do PostgreSQL, propriedade timestamp do RabbitMQ
13	Milissegundos	1790254800000	Date.now() do JavaScript, System.currentTimeMillis() do Java, timestamp de registro do Kafka, SentTimestamp do SQS
16	Microssegundos	1790254800000000	UNIX_MICROS do BigQuery, time.time_ns() // 1000 do Python, tracing
19	Nanossegundos	1790254800000000000	UnixNano() do Go, time.time_ns() do Python, InfluxDB e métricas

UTC e fuso local

O timestamp não tem fuso. Quem aplica o fuso é quem exibe: new Date(ms).toISOString() mostra UTC, e toLocaleString() usa o fuso do navegador. Por isso dois computadores em fusos diferentes mostram horas diferentes para o mesmo valor. Quando a data aparece com 3 horas de diferença em relação ao esperado, quase sempre é UTC sendo lido como horário de Brasília, ou o contrário.

Data em 1970 ou milhares de anos no futuro

Os dois sintomas vêm da mesma troca de unidade. Um valor em segundos passado para new Date() do JavaScript, que espera milissegundos, vira janeiro de 1970. Um Date.now() gravado num campo que o backend lê em segundos vira uma data dezenas de milhares de anos no futuro. Converter o número aqui mostra na hora qual dos dois aconteceu.

Horário de verão no Brasil e datas antigas

O Brasil teve horário de verão até fevereiro de 2019. Nesses períodos, São Paulo ficava em UTC−2, e não em UTC−3. Um sistema que converte datas antigas somando um offset fixo de −3 horas erra em uma hora tudo o que caiu no verão, como janeiro de 2018. O fuso America/Sao_Paulo da base IANA, usado aqui e pelos navegadores, guarda essas regras. Quando a data cai num horário de verão, o resultado mostra o aviso ao lado do fuso.

O problema do ano 2038

O maior valor de um inteiro de 32 bits com sinal é 2147483647, que corresponde a 19/01/2038 às 03:14:07 UTC. Um segundo depois, sistemas que guardam o epoch em 32 bits voltam para 1901. O tipo TIMESTAMP do MySQL tem esse limite. Colunas BIGINT e linguagens com inteiro de 64 bits não têm o problema, e este conversor aceita datas bem depois de 2038.

Timestamp negativo

Valores negativos são datas antes de 1970: −86400 é 31/12/1969 em UTC. Data de nascimento e registro histórico podem gerar esses valores, e alguns bancos e bibliotecas antigas não aceitam. Vale incluir um caso assim na massa de teste.

Início e fim do dia em outro fuso

O dia 24/09 em São Paulo começa às 03:00 UTC, não à meia-noite UTC. Um filtro BETWEEN montado com o início do dia em UTC traz registros do dia errado. A tabela de início e fim deste conversor usa o fuso escolhido, e o fim do período é o último milissegundo antes do período seguinte.

Perguntas frequentes sobre Unix timestamp

Unidade, fuso horário e os erros de data que mais aparecem em log e API.