Epoch Converter: timestamp Unix para data

Cole qualquer epoch, timestamp ou data e veja por extenso, no seu fuso horário e em UTC, com tudo o mais que o número pode ser.

s · ms · µs · ns · FILETIME · .NET · Excel · NTP · GPS · roda no seu navegador

Exemplo · 817876800

sábado

2 de dezembro de 1995

04:00:00 UTC

UTC
sáb., 2 de dez. de 1995 · 04:00:00
sáb., 2 de dez. de 1995 · 04:00:00UTC · UTC+00:00
Relativo
há 31 anos
Escrito como
ISO 8601 · UTC
1995-12-02T04:00:00Z
ISO 8601 · UTC
1995-12-02T04:00:00Z
RFC 5322 · e-mailo formato que a RFC 2822 definiu
Sat, 02 Dec 1995 04:00:00 +0000
Data HTTPRFC 9110
Sat, 02 Dec 1995 04:00:00 GMT
SQL DATETIMEUTC
1995-12-02 04:00:00
Segundos
817876800
Milissegundos
817876800000
Microssegundos
817876800000000
Nanossegundos
817876800000000000

Um número · todos os epochs

7 leituras caem numa data real

Lido como Segun­dos Unix pelo comprimento: 9 dígitos. Como Segun­dos GPS, seria 6 de dezembro de 2005: também uma data real, então fica a um clique.

LeituraCai em
1900–2100: uma data realHoje2038: o limite de 32 bitsNão cai em nenhuma data realEscolha uma leitura para usá-la
Agora

Milissegundos
Microssegundos
Nanossegundos
ISO 8601

O relógio do seu navegador conta milissegundos inteiros: os zeros depois deles são preenchimento, não precisão.

Data e hora → timestamp
Fuso horário

UTC · UTC+00:00 nesta data

1793813880
Milissegundos
1793813880000
ISO 8601
2026-11-04T17:38:00Z
Início e fim em UTC
InícioFim
Dia17937504001793836799
Mês17934912001796083199
Ano17672256001798761599

Tudo acontece nesta aba: nada do que você cola é enviado.

Como converter timestamp para data e hora

Cole no campo o timestamp que você tem, na unidade em que ele estiver, e a data aparece no seu fuso horário e em UTC. Você também pode digitar uma data, o cabeçalho Date de um e-mail ou a palavra “agora” (ou now) para obter o tempo epoch correspondente.

A página lê um número em segundos, milissegundos, microssegundos e nanossegundos ao mesmo tempo, escolhe a leitura que cai numa data real, diz por quê e deixa as outras leituras a um clique. Abaixo da resposta, os mesmos dígitos são lidos como timestamp do Windows, do .NET, do Mac, do Excel, do NTP e do GPS, e todos os formatos podem ser copiados.

Epoch converter lendo 133756272000000000 como Windows FILETIME: 9 de novembro de 2024, e todos os epochs numa linha do tempoEpoch converter lendo 133756272000000000 como Windows FILETIME: 9 de novembro de 2024, e todos os epochs numa linha do tempoCole qualquer coisaUm número em qualquer unidade, uma data ISO, o cabeçalho Date de um e-mail, uma data e hora SQL ou a palavra “agora” (ou “now”). O indicador diz como foi lido.Os dígitos, contadosA régua sob o número agrupa os dígitos de três em três, então 18 dígitos viram seis grupos: a primeira pista do que ele é.A resposta primeiroO dia da semana e a data por extenso, depois a hora em UTC e no seu próprio fuso horário, e todos os formatos para copiar.Qual leitura, e por quêA página diz em palavras qual leitura escolheu e por quê, e cita a outra leitura que também cai numa data real.Todos os outros epochsOs mesmos dígitos lidos em cada unidade e em cada epoch, cada um como uma barra a partir do próprio início. Escolha uma linha para usar essa leitura.
A ferramenta lendo um Windows FILETIME. Selecione um número para ver o que cada parte faz.

O que é o tempo epoch e por que ele começa em 1970?

O tempo epoch, ou tempo Unix, é o número de segundos desde 1970-01-01 00:00:00 UTC, o momento que o POSIX chama de Epoch. O timestamp 0 é esse momento, e a data epoch 817876800 é 1995-12-02 04:00 UTC.

Nenhuma fonte primária registra por que 1970 foi escolhido. O primeiro manual do Unix, de novembro de 1971, contava sexagésimos de segundo a partir de 1º de janeiro de 1971 e observava que o relógio se esgotaria em cerca de dois anos e meio; na Sétima Edição, em 1979, a contagem já era de segundos desde 1º de janeiro de 1970, uma data redonda próxima da época em que o Unix estava sendo escrito. O próprio UTC só começou em 1972, então timestamps anteriores são UTC por convenção.

Primeira Edição do Unix, 1971sexagésimos de segundo desde 1 de janeiro de 1971, em 32 bits

cheio em 8 de abril de 1973 · 2,27 anos

Sétima Edição do Unix, 1979segundos desde 1 de janeiro de 1970, num número de 32 bits com sinal

1901-12-13 → 2038-01-1968 anos para cada lado

contagens negativas: antes de 1970

O usuário de mentalidade--cronológica notará que 2**32 sexagésimos de segundo são apenas cerca de 2,5 anos.

UNIX Programmer's Manual, primeira edição, time (II), 3 de novembro de 1971

Todos os epochs que esta página lê, numa só linha

  1. .NET0001-01-01 · ticks de 100 ns
  2. Windows FILETIME1601-01-01 · ticks de 100 ns
  3. Excel1899-12-30 · dias
  4. NTP1900-01-01 · segundos
  5. Mac HFS+1904-01-01 · segundos
  6. Excel 19041904-01-01 · dias
  7. Unix1970-01-01 · segundos
  8. GPS1980-01-06 · segundos
As duas barras são calculadas a partir do tamanho do contador: 2³² sexagésimos de segundo enchem 2,27 anos, um pouco menos que a própria estimativa do manual. Cada um dos outros epochs que esta página lê começa em outro ponto da mesma linha, desenhada no próprio eixo de tempo do conversor. Fonte: time (II), 1971, time (2), 1979

Meu timestamp está em segundos, milissegundos, microssegundos ou nanossegundos?

Conte os dígitos: um timestamp atual tem 10 dígitos em segundos, 13 em milissegundos, 16 em microssegundos e 19 em nanossegundos. JavaScript e Java usam milissegundos; as ferramentas Unix e a maioria das APIs usam segundos.

A contagem de dígitos é uma pista forte, não uma prova. Timestamps NTP, GPS e do Mac também têm dez dígitos hoje, e um Windows FILETIME e uma contagem de ticks do .NET têm dezoito cada um; é por isso que esta página lê todas as escalas ao mesmo tempo e mostra a leitura escolhida ao lado das outras. Um FILETIME também é grande demais para o JavaScript guardar com exatidão, então a página mantém os dígitos como você os colou.

10 dígitos · 4 escalas · só os dígitos não dizem qual é qual

Segun­dos Unix1792972800
Segun­dos NTP4001961600
Segun­dos GPS1477008018
Mac HFS+3875817600
Milis­segundos Unix1792972800000
Micros­segundos Unix1792972800000000

18 dígitos · 2 escalas · só o primeiro dígito as diferencia

Windows FILETIME134374464000000000
Ticks do .NET639285696000000000
Nanos­segundos Unix1792972800000000000

Contagens de segundos com 10 dígitos vão de 2001-09-09T01:46:40Z a 2286-11-20T17:46:39Z. É um intervalo de 285 anos, não uma unidade.

Cada valor é o mesmo instante, 26 de outubro de 2026, 00:00 UTC, na própria escala. O comprimento separa as unidades Unix; não consegue separar os epochs. Fonte: ECMA-262 §21.4.1, [MS-DTYP] 2.3.3, DateTime.Ticks

Como converter um timestamp Unix para data no meu fuso horário?

Um timestamp Unix não tem fuso horário: ele indica um único instante no mundo inteiro. A data depende de onde você o lê, então a página mostra o seu fuso e o UTC lado a lado, além de qualquer outro fuso que você escolher.

O seletor de fuso usa o banco de dados de fusos horários da IANA, o mesmo que o seu sistema operacional usa, então as mudanças de horário de verão são aplicadas para a própria data, não para hoje. No sentido contrário, uma data digitada sem deslocamento é lida como UTC, e a página oferece lê-la no seu próprio fuso.

Um instante1793057400= 2026-10-26T23:30:00Z

  • Los Angeles16:30seg., 26 de out.UTC−07:00
  • Nova York19:30seg., 26 de out.UTC−04:00
  • UTC23:30seg., 26 de out.UTC+00:00
  • Berlim00:30ter., 27 de out.UTC+01:00
  • Calcutá05:00ter., 27 de out.UTC+05:30
  • Tóquio08:30ter., 27 de out.UTC+09:00
  • Lord Howe10:30ter., 27 de out.UTC+11:00

Berlim, 29 de março de 202623 horas · os relógios pularam de 02:00 para 03:00

Berlim, 25 de outubro de 202625 horas · os relógios voltaram de 03:00 para 02:00

Horário Padrão da Europa Central · UTC+01:00Horário de Verão da Europa Central · UTC+02:00a hora que aconteceu duas vezesa hora que nunca aconteceu

Um timestamp, 7 relógios de parede: onde a data local não é a do UTC, ela está marcada. Nos dois dias de troca de horário de Berlim em 2026, um horário de relógio não correspondeu a nenhum instante e outro correspondeu a dois. Fonte: ECMA-262 §21.4.1.19, IANA tz

O que acontece com o tempo Unix em 2038?

Um tempo Unix guardado como inteiro de 32 bits com sinal se esgota em 2147483647, que é 2038-01-19 03:14:07 UTC; um segundo depois, ele dá a volta para uma data em dezembro de 1901. Sistemas que contam em 64 bits, como o POSIX agora exige, não são afetados.

Em 2026, o risco está no armazenamento, não nos relógios: uma coluna TIMESTAMP do MySQL ainda termina em 2038-01-19 03:14:07 UTC, assim como qualquer formato de arquivo ou dispositivo embarcado que manteve um campo de 32 bits. O NTP tem uma virada própria, anterior: os segundos de 32 bits dele dão a volta em 2036. A página marca qualquer timestamp perto ou além do limite de 2038.

2.147.483.647o maior número de 32 bits com sinal

01111111 11111111 11111111 11111111

ter., 19 de jan. de 203803:14:07 UTC

+ 1 segundo

-2.147.483.648os mesmos 32 bits, lidos como número com sinal

10000000 00000000 00000000 00000000

sex., 13 de dez. de 190120:45:52 UTC

Último segundo, UTC

time_t de 32 bits com sinal2038-01-19 03:14:07
Segundos de 32 bits sem sinal2106-02-07 06:28:15
Coluna TIMESTAMP do MySQL2038-01-19 03:14:07
Era 0 do NTP2036-02-07 06:28:15
Datas do Mac HFS+2040-02-06 06:28:15

hoje2038-01-19

Cada fim é calculado a partir do tamanho do próprio campo: o último segundo inteiro que ele consegue guardar. Um time_t de 64 bits, que o POSIX.1-2024 exige, alcança cerca de 292 bilhões de anos para cada lado de 1970. Fonte: POSIX.1-2024 A.4.19, MySQL 8.4, RFC 5905 §6, TN1150

Um timestamp Unix pode ser negativo?

Sim: um timestamp negativo é uma data antes de 1970. -1 é 1969-12-31 23:59:59 UTC, e -86400 é 1969-12-31 00:00:00 UTC.

O próprio POSIX deixa os valores negativos indefinidos, mas o GNU e a maioria dos sistemas os tratam como datas antes de 1970 por extensão documentada, assim como JavaScript, Python e PostgreSQL. O MySQL é a exceção: a coluna TIMESTAMP dele começa em 1970, e FROM_UNIXTIME(-1) retorna NULL. Datas de nascimento e registros históricos são timestamps negativos comuns, então a página os lê como datas em vez de tratá-los como erro.

SegundosQuão longe no passado (escala log)Data, UTC

0qui., 1 de jan. de 197000:00:00 UTC
-1qua., 31 de dez. de 196923:59:59 UTC
-86.400qua., 31 de dez. de 196900:00:00 UTC
-31.536.000qua., 1 de jan. de 196900:00:00 UTC
-1.000.000.000dom., 24 de abr. de 193822:13:20 UTC
-2.147.483.648sex., 13 de dez. de 190120:45:52 UTC
  • POSIXSe o ano for <1970 ou o valor for negativo, a relação é indefinida.
  • GNU date@-1 é 1969-12-31 23:59:59 UTC: contagens negativas, como extensão do POSIX
  • JavaScriptqualquer data até cerca de 273.790 anos antes ou depois de 1970
  • MySQL TIMESTAMPcomeça em 1970-01-01 00:00:01 UTC: não aceita valor negativo
Cada valor lido como segundos Unix. As barras estão em escala logarítmica, para que os valores pequenos continuem visíveis. A última linha é o menor número que um campo de 32 bits com sinal guarda: a outra ponta do problema de 2038. Fonte: POSIX.1-2024 §4.19, GNU Coreutils, ECMA-262 §21.4.1, MySQL 8.4

Windows, .NET, Mac, Excel, NTP e GPS: os outros epochs

Muitos sistemas contam a partir do próprio zero: o Windows desde 1601, o .NET desde o ano 1, o Mac e o HFS+ desde 1904, o Excel desde 1900, o NTP desde 1900 e o GPS desde 6 de janeiro de 1980. Um número que não faz sentido como timestamp Unix muitas vezes é um destes.

O FILETIME 133756272000000000, por exemplo, conta intervalos de 100 nanossegundos desde 1601 e é 2024-11-09 12:00:00 UTC. O Excel conta dias e trata 1900 como ano bissexto de propósito, então os seriais abaixo de 61 ficam um dia fora, e a página os sinaliza. O tempo GPS ignora os segundos bissextos e está 18 segundos à frente do UTC desde 2017.

EpochUnidadeDesdeEm 26 de out. de 2026DígitosFuso horárioOnde você o encontra
Segun­dos Unixsegundos1970-01-01179297280010UTC (POSIX)date +%s, time.time() do Python
Milis­segundos Unixmilissegundos1970-01-01179297280000013UTCDate.now() do JavaScript, Java
Nanos­segundos Unixnanossegundos1970-01-01179297280000000000019UTCUnixNano() do Go
Windows FILETIMEticks de 100 ns1601-01-0113437446400000000018UTC (hora local em FAT)NTFS, lastLogon do Active Directory, Win32
Ticks do .NETticks de 100 ns0001-01-0163928569600000000018UTC ou local, conforme o KindDateTime.Ticks do .NET
Serial do Exceldias1899-12-30463215nenhum: relógio de paredeExcel, Google Sheets, LibreOffice
Excel 1904dias1904-01-01448595nenhum: relógio de paredeExcel antigo para Mac
Mac HFS+segundos1904-01-01387581760010GMT (HFS clássico: local)datas de arquivos HFS+
Segun­dos NTPsegundos1900-01-01400196160010UTCpacotes NTP
Segun­dos GPSsegundos1980-01-06147700801810sem segundos bissextos: UTC + 18 sreceptores GPS, arquivos RINEX
Cada valor é o mesmo instante, 26 de outubro de 2026, 00:00 UTC, na própria escala, calculado pelo motor que esta página roda. O Google Sheets e o LibreOffice também contam os dias a partir de 1899-12-30, então os seriais deles coincidem com os do Excel a partir de 1 de março de 1900. Fonte: [MS-DTYP] 2.3.3, DateTime.Ticks, Excel, Google Sheets, LibreOffice, TN1150, RFC 5905, RINEX 3.05

O tempo Unix conta os segundos bissextos?

Não. O tempo Unix dá a todo dia exatamente 86.400 segundos, então um segundo bissexto não tem número próprio, e o POSIX diz isso: o tempo POSIX decomposto não é necessariamente UTC, apesar da aparência.

Desde 1972, 27 segundos bissextos foram acrescentados ao UTC; o tempo Unix não tem número para o segundo extra, então um timestamp vale por dois segundos. O último foi em 2016-12-31, e em 2022 a Conferência Geral de Pesos e Medidas decidiu que, até 2035, o limite que os torna necessários será ampliado, o que na prática acaba com eles. O tempo GPS, que nunca os teve, mostra a diferença: está 18 segundos à frente.

Os últimos segundos de 31 de dezembro de 1998

UTC23:59:5823:59:5923:59:6000:00:0000:00:01
Tempo Unix915148798915148799915148800915148800915148801
Tempo GPS599184010599184011599184012599184013599184014

O tempo Unix dá 915148800 duas vezes; o tempo GPS, que não tem segundos bissextos, continua contando.

27 segundos bissextosnenhum depois de 31 de dezembro de 2016 · nenhum anunciado antes de 28 de junho de 2027

antes do início do tempo GPSdesde o início do tempo GPS: cada um o deixou um segundo mais à frente

O Tempo Universal Coordenado (UTC) inclui segundos bissextos. No entanto, no tempo POSIX (segundos desde o Epoch), os segundos bissextos são ignorados (não aplicados) para oferecer um método fácil e compatível de calcular diferenças de tempo. Portanto, o tempo POSIX decomposto não é necessariamente UTC, apesar da aparência.

POSIX.1-2024, Rationale A.4.19
Logo depois deste segundo bissexto, o tempo GPS estava 13 segundos à frente do UTC. Fonte: POSIX.1-2024 A.4.19, leap-seconds.list, RINEX 3.05

Timestamps Unix em Python, JavaScript, Java, C#, Go, SQL e no shell

Toda linguagem converte nos dois sentidos em uma ou duas linhas. As armadilhas são a unidade (JavaScript e Java contam milissegundos) e o fuso horário (um banco de dados pode ler o valor no fuso da sessão).

Cada exemplo abaixo transforma 817876800 numa data e uma data de volta em segundos, e cada um foi executado para conferir a saída. No shell, o macOS e os BSDs usam date -r 817876800, enquanto o GNU/Linux usa date -d @817876800: os dois não são intercambiáveis.

from datetime import datetime, timezone

t = datetime.fromtimestamp(817876800, tz=timezone.utc)
print(t.isoformat())  # 1995-12-02T04:00:00+00:00

back = datetime(1995, 12, 2, 4, 0, tzinfo=timezone.utc)
print(int(back.timestamp()))  # 817876800

Executado com Python 3.14.4 em 26 de outubro de 2026: imprime o que os comentários mostram.

Cada aba é um programa ou uma sessão completa que roda do jeito que foi colada; na aba do shell, rode a metade do seu sistema. Fonte: docs.python.org, ECMA-262, Instant, DateTimeOffset, pkg.go.dev/time, PostgreSQL, MySQL, date(1), GNU Coreutils

Tempo epoch: perguntas e respostas

O que é o tempo epoch?

O tempo epoch, também chamado de tempo Unix ou timestamp Unix, é o número de segundos que se passaram desde 1970-01-01 00:00:00 UTC, sem contar os segundos bissextos. Os computadores guardam datas assim porque um único número é fácil de comparar, ordenar e enviar. O timestamp 1000000000 foi 2001-09-09 01:46:40 UTC, e o campo no topo converte qualquer valor em data.

Como converter epoch para data?

Cole o número no campo no topo. A página o lê em segundos, milissegundos, microssegundos e nanossegundos, escolhe a leitura que cai numa data real e mostra essa data no seu fuso horário e em UTC. À mão, multiplique os segundos por 1.000 e passe o resultado para uma função de data, como new Date(817876800 * 1000) em JavaScript.

Qual é o tempo epoch atual?

O relógio desta página mostra o tempo Unix atual ao vivo, em segundos, milissegundos, microssegundos e nanossegundos, e cada valor pode ser copiado. Ele vem do relógio do seu próprio dispositivo, então só é tão preciso quanto esse relógio; um computador que sincroniza pela internet costuma ficar a uma fração de segundo da hora certa. Na linha de comando, date +%s o mostra em segundos.

Um timestamp Unix está em segundos ou em milissegundos?

Os timestamps Unix clássicos estão em segundos, mas JavaScript, Java e muitas APIs web usam milissegundos, e alguns bancos de dados e logs usam microssegundos ou nanossegundos. Um timestamp atual tem 10 dígitos em segundos e 13 em milissegundos. Se a data sai em 1970 ou daqui a milhares de anos, a unidade está errada; esta página testa todas as unidades e mostra qual faz sentido.

Por que o tempo Unix começa em 1970?

Nenhuma fonte primária registra o motivo. O primeiro manual do Unix, de 1971, contava sexagésimos de segundo a partir de 1º de janeiro de 1971 e previa se esgotar em poucos anos. Quando a contagem passou a ser de segundos inteiros, 1º de janeiro de 1970 virou o início: uma data redonda próxima da época em que o Unix estava sendo escrito, a partir da qual uma contagem de segundos em 32 bits chega até 2038.

O tempo Unix é o mesmo que o UTC?

Quase, mas não exatamente. O tempo Unix segue o calendário e o relógio do UTC, mas dá a todo dia exatamente 86.400 segundos e ignora os segundos bissextos, então um segundo bissexto não tem timestamp próprio. O próprio POSIX diz que um tempo Unix decomposto não é necessariamente UTC. Nas datas e horas que as pessoas leem, a diferença nunca aparece; em intervalos precisos que atravessam um segundo bissexto, aparece.

O que é o problema do ano 2038?

Um tempo Unix guardado como número de 32 bits com sinal só chega a 2147483647, que é 2038-01-19 03:14:07 UTC. Um segundo depois, ele estoura e passa a ser lido como dezembro de 1901. Os sistemas operacionais modernos usam tempo de 64 bits e estão seguros, mas campos de 32 bits continuam em alguns bancos de dados, formatos de arquivo e dispositivos embarcados: a coluna TIMESTAMP do MySQL, por exemplo, ainda termina nesse segundo.

Dá para converter uma data antes de 1970?

Sim. Datas antes de 1970 são timestamps negativos: -1 é 1969-12-31 23:59:59 UTC, e uma data em 1950 fica em torno de -631 milhões. Cole um número negativo e a página mostra a data dele; digite uma data mais antiga e ela dá o valor negativo. O POSIX estrito deixa os valores negativos indefinidos e o TIMESTAMP do MySQL não os aceita, mas a maioria das linguagens e dos bancos de dados os lê como datas antes de 1970.

Como converter um Windows FILETIME para data?

Um FILETIME conta intervalos de 100 nanossegundos desde 1601-01-01 UTC, então hoje tem 18 dígitos. Cole-o no campo e a página o lê como FILETIME ao lado das unidades Unix: 133756272000000000 é 2024-11-09 12:00:00 UTC. À mão, subtraia 116444736000000000 e divida por 10.000.000 para obter segundos Unix.

Como converter o serial de uma data do Excel em timestamp?

Um serial do Excel conta dias, com frações para a hora: no sistema padrão de 1900, 45658 é 2025-01-01. Cole o serial e a página o lê como data do Excel nos dois sistemas, o de 1900 e o de 1904. O Excel trata 1900 como ano bissexto de propósito, então os seriais abaixo de 61 ficam um dia fora, e a página os sinaliza em vez de adivinhar.

O conversor lida com fusos horários e horário de verão?

Sim. A página mostra cada data no seu fuso horário e em UTC, e você pode escolher qualquer fuso IANA, como America/New_York ou Asia/Kolkata. O horário de verão é aplicado conforme a data convertida, não conforme hoje, então um timestamp de verão mostra o horário de verão mesmo no inverno. Uma data digitada sem deslocamento é lida como UTC, e um clique a lê no seu próprio fuso.

Meu timestamp é enviado para algum lugar?

Não. A conversão roda no seu navegador, então o que você cola nunca sai do seu dispositivo e nenhum servidor o vê. Um link criado com “Copiar link” leva o timestamp no próprio endereço, para que a página que ele abre já mostre a data; nada mais é guardado ou enviado.

Sentiu falta de algo?Sugira um recurso ou uma nova ferramenta