Which epoch converter should I use?

Use Epoch to Date when you already have a Unix timestamp and need readable time. Use Date to Epoch when you have a calendar date, time, or datetime and need Unix seconds or milliseconds.

How do I convert a Unix timestamp to a readable date?

Paste your timestamp in the Epoch → Date tab above and click Convert. The tool auto-detects whether your timestamp is in seconds (10 digits) or milliseconds (13 digits) and shows the result in ISO 8601, UTC, and a friendly format for any timezone.

How do I convert a date or time to Unix timestamp?

Open the Date → Epoch tab, enter the date, time, and timezone, then copy the Unix timestamp in seconds or milliseconds.

What is the difference between Unix time in seconds and milliseconds?

A 10-digit timestamp (e.g. 1700000000) is in seconds. A 13-digit timestamp (e.g. 1700000000000) is in milliseconds. JavaScript's Date.now() returns milliseconds; most server-side languages (Python, PHP, Go) return seconds. Multiply by 1000 to convert seconds to milliseconds.

How do I convert milliseconds to seconds?

Divide the millisecond timestamp by 1000. In JavaScript, use Math.floor(milliseconds / 1000) when you need whole Unix seconds. To convert seconds back to milliseconds, multiply by 1000.

What is a 16-digit Unix timestamp?

A 16-digit Unix timestamp usually represents microseconds since the Unix epoch. Divide it by 1,000,000 to get seconds, or by 1000 to get milliseconds for JavaScript Date.

What is the difference between Unix time and UTC?

Unix time is a count of seconds elapsed since a fixed reference point (1970-01-01 00:00:00 UTC). UTC is the time standard that defines that reference point. A Unix timestamp always represents the same moment in UTC regardless of your local timezone.

Can a Unix timestamp be negative?

Yes. Timestamps before January 1, 1970 00:00:00 UTC are negative. For example, -86400 corresponds to December 31, 1969 00:00:00 UTC.

What is the Year 2038 problem?

Legacy systems that store Unix timestamps as 32-bit signed integers will overflow on January 19, 2038 at 03:14:07 UTC (the maximum value is 2,147,483,647). Modern 64-bit systems are unaffected and can represent dates billions of years in the future.

Conversor

Conversor de timestamp Unix

Converta entre timestamps Unix e datas legíveis. Um relógio epoch ao vivo se atualiza a cada segundo. Cole qualquer timestamp de 10 dígitos (segundos) ou 13 dígitos (milissegundos) e converta-o para qualquer fuso.

Timestamp Unix atual · ao vivo

1783399218

Epoch → Data Data → Epoch

Timestamp Unix

Fuso horário

O que é uma marca de tempo Unix?

Uma marca de tempo Unix é o número de segundos desde 1º de janeiro de 1970 às 00:00:00 UTC. Também é chamada de tempo epoch ou tempo POSIX. A conversão de tempo Unix não inclui segundos bissextos. O valor é um único inteiro. Ele aponta para um único instante. O inteiro não depende de fuso horário nem de configuração regional. Quase todas as linguagens, bancos de dados e sistemas operacionais suportam marcas de tempo epoch. Elas são o padrão universal para armazenar e enviar tempo entre sistemas.

The Open Group — Segundos desde a época (POSIX)

Segundos vs. milissegundos: detecção automática do formato

A maioria das marcas de tempo Unix está em segundos — um número de 10 dígitos atualmente em torno de 1,7 bilhão. O Date.now() do JavaScript e muitas APIs de navegador e web retornam milissegundos, produzindo um número de 13 dígitos. Este conversor detecta automaticamente a unidade pela magnitude do valor informado.

Número de 10 dígitos (ex.: 1700000000) → segundos desde a época Unix
Número de 13 dígitos (ex.: 1700000000000) → milissegundos desde a época Unix
Para converter segundos em milissegundos: multiplique por 1000
Para converter milissegundos em segundos: divida por 1000 (use Math.floor para obter um inteiro)

Por que o tempo epoch começa em 1º de janeiro de 1970?

A data foi escolhida pelos desenvolvedores originais do Unix no início dos anos 1970 como um ponto de referência conveniente anterior à computação moderna. Como praticamente todas as marcas de tempo úteis são inteiros positivos, a aritmética e as comparações são simples. Embora a escolha tenha sido um tanto arbitrária, tornou-se universal — todo sistema operacional, linguagem de programação e protocolo modernos usam o mesmo ponto de referência.

Conversão de tempo Unix: como converter epoch em uma data legível

Use a aba Epoch → Data acima: cole qualquer marca de tempo Unix, escolha o seu fuso horário e clique em Converter. A ferramenta exibe o resultado em ISO 8601 (com deslocamento de fuso), string UTC, um formato longo amigável e um indicador de tempo relativo. Você também pode converter no sentido oposto usando a aba Data → Epoch.

ISO 8601 — formato padrão legível por máquina: 2023-11-15T06:13:20+00:00
String UTC — legível com dia da semana: Wed, 15 Nov 2023 06:13:20 GMT
Amigável — estilo regional: Wednesday, November 15, 2023 at 6:13:20 AM UTC
Relativo — contextual: há 1 ano

Precisão de subsegundo, tempo monotônico e APIs modernas

O código moderno usa mais do que segundos e milissegundos. Ele também lida com microssegundos e nanossegundos. O código distingue o tempo de relógio de parede do tempo monotônico. A mais recente API Temporal do JavaScript expõe instantes com precisão de nanossegundos diretamente. O POSIX time_t continua por baixo. Em time_t de 32 bits com sinal, o limite de estouro Y2038 ainda se aplica.

Segundos (10 dígitos) — o formato canônico POSIX time_t
Milissegundos (13 dígitos) — JavaScript Date e a maioria das APIs web
Microssegundos (16 dígitos) — logging de alta resolução, marcas de tempo Chrome/WebKit, precisão 6 de timestamp no Postgres
Nanossegundos (19 dígitos) — Temporal.Instant.epochNanoseconds (BigInt), Java Instant, Go time.UnixNano()
Tempo de relógio de parede vs. tempo monotônico: use Date.now() / time() para armazenar instantes; use performance.now() / clock_gettime(CLOCK_MONOTONIC) para medir durações
Abreviações de fuso horário (EST, PST, JST, IST, CST) são ambíguas — sempre use um nome IANA como America/New_York ou Asia/Tokyo no código
POSIX time_t em sistemas de 32 bits estoura em 19/01/2038; time_t de 64 bits é o padrão moderno

A marca de tempo Unix atual, ao vivo

O relógio no topo desta página é atualizado a cada segundo e mostra a época atual em segundos, a hora atual em milissegundos e a data. O mesmo instante aparece de cinco formas: segundos epoch de 10 dígitos, milissegundos de 13 dígitos, ISO 8601, string UTC e um formato local amigável. O mesmo conversor também funciona como calculadora de data e hora: use-o como mudador de hora e data entre fusos horários ou entre epoch e datas humanas.

Relógio ao vivo com segundos e data / tempo epoch atual / tempo Unix atual — exibido ao vivo no topo da página
Hora atual em ms (milissegundos) — o mesmo instante que Date.now() no JavaScript
Marca de tempo atual / marca de tempo Unix atual — o valor canônico de 10 dígitos em segundos Unix
Semana atual — para encontrar o início desta semana como epoch, use as marcas de tempo de ano/mês/semana da página de Referência
Calculadora de data e hora — para «data + N dias = epoch?» use a aba Data → Epoch com o valor de relógio de parede calculado
Mudador de hora e data — escolha um novo fuso no conversor e o mesmo instante muda a exibição
Unix para unix (entre sistemas): o inteiro é o mesmo; a exibição muda conforme o fuso horário
Timestamp unix time — o mesmo número sob três nomes: marca de tempo, tempo Unix, tempo epoch

Conversor de marca de tempo epoch Unix — valores de referência rápidos

Valores epoch redondos que surgem com frequência ao depurar ou escrever testes. Cada valor é emparelhado com a data-hora ISO 8601 correspondente para você conferir num relance. Todos os instantes estão em UTC.

0 → 1970-01-01T00:00:00Z (a origem da época)
86400 → 1970-01-02T00:00:00Z (um dia após a época)
1000000000 → 2001-09-09T01:46:40Z (marco de dez dígitos)
1500000000 → 2017-07-14T02:40:00Z (referência de meados de 2017)
1700000000 → 2023-11-14T22:13:20Z (referência recente)
2000000000 → 2033-05-18T03:33:20Z (referência futura)
2147483647 → 2038-01-19T03:14:07Z (máximo de um inteiro de 32 bits com sinal — limite Y2038)
253402300799 → 9999-12-31T23:59:59Z (limite do ano 9999 do PostgreSQL)

Converta entre marcas de tempo Unix, datas e UTC

Este conversor trata de todas as direções num só lugar. Cole qualquer valor de relógio de parede para converter uma data em marca de tempo Unix, ou cole um inteiro epoch para obter a data-hora UTC correspondente para a análise de logs. Um valor de 13 dígitos é detectado automaticamente como milissegundos e convertido em segundos. O tempo POSIX é apenas outro nome para o tempo Unix — a mesma operação nos dois casos. Funciona com segundos, milissegundos, microssegundos e strings ISO 8601.

Converter tempo em marca de tempo Unix — cole qualquer data de relógio de parede e obtenha segundos e milissegundos
Epoch para UTC — cole um inteiro epoch e veja a data-hora UTC correspondente
Millis para marca de tempo — valores de 13 dígitos são detectados automaticamente como milissegundos e convertidos em segundos
Conversor de tempo POSIX — o tempo POSIX é apenas outro nome para o tempo Unix; mesma ferramenta, mesma operação
Conversão de tempo Unix em qualquer direção — data ↔ epoch, seg ↔ ms, local ↔ UTC

Sistemas computacionais, hora local e o limite de 19 de janeiro de 2038

O tempo Unix é o padrão de medição de tempo usado por sistemas computacionais no mundo todo — de servidores e bancos de dados a dispositivos embarcados e sistemas operacionais. Internamente, esses sistemas armazenam o tempo como um inteiro Unix e depois o renderizam como hora local para quem visualiza. A convenção tem um limite famoso: em 19 de janeiro de 2038, às 03:14:07 UTC, as marcas de tempo Unix de 32 bits com sinal estouram. Sistemas modernos de 64 bits não são afetados. Implantações legadas de 32 bits ainda precisam de atenção antes dessa data.

Sistemas computacionais que contam o tempo como inteiros Unix: Linux, macOS, Windows, BSD, iOS, Android e todos os principais motores de banco de dados
Hora local vs. UTC: a marca de tempo em si está em UTC; a hora local é apenas uma das muitas renderizações possíveis
19 de janeiro de 2038 às 03:14:07 UTC — quando as marcas de tempo Unix de 32 bits com sinal atingem 2.147.483.647 e estouram
Sistemas de 64 bits estendem o intervalo seguro até cerca do ano 292 bilhões — muito além de qualquer preocupação prática
A hora local depende do deslocamento de fuso e das regras de horário de verão — aplique apenas na exibição, nunca no armazenamento

Como este conversor calcula

Cada conversão desta página é executada inteiramente no seu navegador usando a definição POSIX padrão do tempo Unix — segundos desde 1970-01-01 00:00:00 UTC, sem segundos bissextos. As marcas de tempo que você digita nunca são enviadas a um servidor; o cálculo acontece localmente em JavaScript. Os horários são calculados em UTC e exibidos no fuso que você escolher apenas na visualização.