Um bug curioso apareceu em um sistema de autenticação: todos os tokens estavam expirando “no futuro”.
O backend registrava as datas como 2089, enquanto o front-end jurava que o tempo estava certo. Depois de horas de análise, o problema era simples — uma confusão entre Unix Time em segundos e Epoch em milissegundos.
Três termos diferentes, um caos universal.

Apesar de parecerem sinônimos, Unix Time, Epoch e Timestamp não são a mesma coisa. Essa confusão gera erros sutis, principalmente em APIs e bancos de dados. Entender a diferença entre eles é o tipo de conhecimento que separa quem “faz funcionar” de quem entende o que está fazendo.

Por que entender o tempo importa

Em sistemas digitais, o tempo não é uma abstração filosófica — é um dado técnico. Ele define a validade de um token, a ordem de um log, o comportamento de um cache e até o resultado de uma requisição.
Quando o tempo está errado, nada mais faz sentido.

Timestamps estão por toda parte: em logs de auditoria, respostas de APIs, arquivos, sistemas financeiros, redes sociais, e até no blockchain. E cada um desses contextos pode usar o tempo de forma ligeiramente diferente.

É por isso que entender o que é Epoch, o que é Unix Time, e como ambos se relacionam com o Timestamp é essencial para qualquer desenvolvedor.

O que é Epoch: o marco zero do tempo digital

Tudo começa em 1º de janeiro de 1970, 00:00:00 UTC.
Essa data é chamada de Unix Epoch — o ponto zero da linha do tempo dos sistemas baseados em Unix (e praticamente de toda a internet moderna).

Por que 1970?
Porque foi o início da era Unix, quando os sistemas operacionais começaram a usar uma contagem simples: quantos segundos se passaram desde esse marco.

Assim, o Epoch não é um número, mas um referencial.
Quando dizemos “timestamp 0”, estamos dizendo: “exatamente o início do Epoch”.
Quando dizemos “timestamp 1.000.000”, estamos falando de um segundo exato, um milhão de segundos após 1970-01-01 00:00:00 UTC.

O Epoch é o “ponto de partida” universal para calcular tempo.

O que é Unix Time: a contagem de segundos desde o Epoch

O Unix Time é a forma numérica dessa contagem.
É o número de segundos (ou, em alguns casos, milissegundos) que se passaram desde o Epoch.

Por exemplo:

• 0

  = 1970-01-01T00:00:00Z

• 1733246400

  = 2025-12-03T00:00:00Z

• 1733246400000

  = 2025-12-03T00:00:00Z (em milissegundos)

Note a diferença: um tem 10 dígitos (segundos), o outro tem 13 (milissegundos).
Essa pequena diferença é a causa de inúmeros bugs, porque JavaScript usa milissegundos e a maioria das APIs usa segundos.

O Unix Time é prático, mas não é legível. É por isso que, em muitos contextos, ele é convertido para formatos mais humanos — os timestamps legíveis.

O que é Timestamp: o conceito genérico

Enquanto o Unix Time é um tipo específico de timestamp, o termo “timestamp” em si é mais amplo.
Ele significa qualquer marcação de tempo associada a um evento digital.

Pode ser:

• 1733246400

  (Unix em segundos)

• 1733246400000

  (Unix em milissegundos)

• 2025-12-03T00:00:00Z

  (ISO 8601)

• Wed Dec 03 2025 00:00:00 GMT+0000 (UTC)

  (formato legível)

Ou seja: todo Unix Time é um timestamp, mas nem todo timestamp é Unix Time.

O timestamp é a representação do tempo; o Unix Time é apenas um dos formatos possíveis — e o Epoch é o ponto de referência.

Comparativo prático

1733246400

2025-12-03T00:00:00Z

// Timestamp atual em milissegundos
const tsMilli = Date.now();

// Converter para segundos
const tsSeconds = Math.floor(tsMilli / 1000);

// Converter de Unix Time para data legível
const readable = new Date(tsSeconds * 1000).toISOString();

import datetime

# Timestamp atual em segundos
ts_seconds = int(datetime.datetime.now().timestamp())

# Converter para milissegundos
ts_milli = ts_seconds * 1000

# Converter de Unix Time para ISO
print(datetime.datetime.utcfromtimestamp(ts_seconds).isoformat() + "Z")

$timestamp = time(); // segundos desde o Epoch
echo date("Y-m-d H:i:s", $timestamp); // formato legível