Ferramenta de Conversão de Timestamp Unix

Uma ferramenta profissional de conversão de timestamp Unix que suporta conversão bidirecional entre timestamps e data e hora, reconhecendo automaticamente timestamps de segundo (9-10 dígitos), milissegundo (13), microssegundo (16) e nanossegundo (19) conforme a quantidade de dígitos. Oferece três visualizações: horário local, horário UTC e horário de fuso horário selecionado, suporta múltiplos cartões de conversor para comparação em lote e inclui intervalos de tempo recentes integrados e intervalos de tempo comuns para depuração de desenvolvimento e conversões diárias. Interface responsiva, conversão instantânea no momento da entrada, resultados atualizados automaticamente ao alternar fusos horários, e todas as operações são executadas localmente no seu navegador, garantindo privacidade e segurança.

Horário Atual

Timestamp Atual (Segundos)

—

Horário Atual

—

Fuso Horário Global

Timestamp para Data

Suporta timestamps de segundo, milissegundo, microssegundo e nanossegundo, detectados automaticamente pela quantidade de dígitos (9-10 dígitos para segundos, 13 dígitos para ms, 16 dígitos para μs, 19 dígitos para ns)

Resultado da Conversão(Automático)

Horário Local

Horário UTC

Horário do Fuso Horário Selecionado

Data para Timestamp

Resultado da Conversão(Automático)

Timestamp (Segundos)

Timestamp (Milissegundos)

Conversor de Data e Hora com Múltiplos Timestamps

Conversor de Timestamp com Múltiplas Datas

Instruções de Uso

Esta ferramenta serve para concluir rapidamente a conversão bidirecional entre carimbos de data/hora Unix e datas e horários em diferentes cenários. Suporta precisão de segundos e milissegundos e permite que você selecione o fuso horário alvo para exibição comparativa. Disponibiliza conversores de cartão único e múltiplos cartões. A conversão ocorre enquanto você digita, e os resultados são atualizados automaticamente ao alternar o fuso horário. Também inclui intervalos de tempo recentes e períodos comuns para atender às necessidades de depuração no desenvolvimento e conversões diárias.

Detecção automática: A ferramenta detecta automaticamente a precisão pela quantidade de dígitos: segundos (9-10 dígitos), milissegundos (13), microssegundos (16) e nanossegundos (19) — sem necessidade de selecionar a unidade manualmente.

Fuso horário: Exibe o horário local e o horário UTC, o que facilita o uso em diferentes fusos horários.

Características da Ferramenta

Converta enquanto digita, com reconhecimento automático de carimbos de data/hora em segundos/milisegundos/microssegundos/nanossegundos.
Suporta seleção e exibição global de fusos horários: três visualizações de horário local, UTC e fusos horários selecionados.
Vários cartões de conversão para comparar facilmente em lote.
Interface responsiva e compatível com teclado, com boa acessibilidade.
Intervalos de tempo recentes e períodos comuns integrados, para copiar e usar.

O que é um Timestamp?

Um carimbo de data/hora Unix é o número total de segundos ou milissegundos decorridos desde 01/01/1970 00:00:00 UTC (Época Unix).

Um carimbo de data/hora é um número que representa o tempo, geralmente em segundos ou milissegundos.

O ponto de início de um carimbo de data/hora é 01/01/1970 00:00:00 UTC, que é chamado de Época Unix.

Carimbos de data/hora foram originalmente usados em sistemas operacionais Unix, por isso são frequentemente chamados de carimbos de data/hora Unix.

Carimbos de data/hora são amplamente usados em programação e comunicação em rede, especialmente em desenvolvimento web.

Precisões comuns: segundos (ex.: 1735689600) e milissegundos (ex.: 1735689600000). Ao representar datas e horários relacionados a fusos horários, eles precisam ser formatados e exibidos em conjunto com o fuso horário.

Timestamps Recentes (Baseado no Fuso Horário Global)

Timestamps Comuns (Durações)

1 Minuto

60 Segundos

1 Hora

3600 Segundos

1 Dia

86400 Segundos

1 Semana

604800 Segundos

1 Mês (30 dias)

2592000 Segundos

1 Ano (365 dias)

31536000 Segundos

O Problema do Ano 2038 dos Timestamps

O problema do ano de 2038 refere-se à questão em que um inteiro com sinal de 32 bits que armazena um carimbo de data/hora Unix (em segundos desde 01/01/1970 00:00:00 UTC) terá overflow após 19/01/2038 03:14:07 UTC.

Como o intervalo de um inteiro com sinal de 32 bits é de -2.147.483.648 a 2.147.483.647, e o carimbo de data/hora de 19/01/2038 03:14:07 UTC é 2.147.483.647, um inteiro com sinal de 32 bits não será capaz de representar os carimbos de data/hora subsequentes a partir desse ponto.

São afetados principalmente sistemas antigos ou softwares que usam time_t de 32 bits. Sistemas modernos geralmente usam 64 bits (como um inteiro de 64 bits em milissegundos) e não têm esse problema.

Recomenda-se usar carimbos de data/hora de 64 bits ou uma biblioteca de tempo que suporte um grande intervalo de datas.

Como Obter/Converter Timestamps Usando Linguagens de Programação

JavaScript

Obter Timestamp Atual

Math.floor(Date.now() / 1000); // seconds
Date.now(); // milliseconds

Timestamp → Data

new Date(1735689600 * 1000).toISOString();

Data → Timestamp

new Date('2025-01-01T00:00:00Z').getTime();

PHP

Obter Timestamp Atual

time();                // seconds
intval(microtime(true) * 1000); // milliseconds

Timestamp → Data

date('Y-m-d H:i:s', 1735689600);

Data → Timestamp

strtotime('2025-01-01 00:00:00');

Python

Obter Timestamp Atual

import time

int(time.time())        # seconds
int(time.time() * 1000) # milliseconds

Timestamp → Data

import datetime

datetime.datetime.utcfromtimestamp(1735689600).isoformat()

Data → Timestamp

import datetime

int(datetime.datetime(2025,1,1,0,0,0,tzinfo=datetime.timezone.utc).timestamp())

Obter Timestamp Atual

import "time"

time.Now().Unix()      // seconds
time.Now().UnixMilli() // milliseconds

Timestamp → Data

import "time"

time.Unix(1735689600, 0).UTC().Format(time.RFC3339)

Data → Timestamp

import "time"

ts := time.Date(2025,1,1,0,0,0,0,time.UTC).Unix()

Rust

Obter Timestamp Atual

use chrono::Utc;

let now = Utc::now();
let sec = now.timestamp();        // seconds i64
let ms  = now.timestamp_millis(); // milliseconds i128

Timestamp → Data

use chrono::{DateTime, NaiveDateTime, Utc};

let dt: DateTime = NaiveDateTime::from_timestamp_opt(1735689600, 0)
    .unwrap()
    .and_utc();
let iso = dt.to_rfc3339();

Data → Timestamp

use chrono::DateTime;

let ts = DateTime::parse_from_rfc3339("2025-01-01T00:00:00Z")
    .unwrap()
    .timestamp();

SQL

Obter Timestamp Atual

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP();

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM NOW())::bigint;

-- SQLite
SELECT strftime('%s', 'now');

Timestamp → Data

-- MySQL / MariaDB
SELECT FROM_UNIXTIME(1735689600);

-- PostgreSQL
SELECT to_timestamp(1735689600) AT TIME ZONE 'UTC';

-- SQLite
SELECT datetime(1735689600, 'unixepoch');

Data → Timestamp

-- MySQL / MariaDB
SELECT UNIX_TIMESTAMP('2025-01-01 00:00:00');

-- PostgreSQL
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-01-01 00:00:00+00')::bigint;

-- SQLite
SELECT strftime('%s', '2025-01-01 00:00:00');