ForHosting KIT · Conversores de unidades

Conversor de tempo Unix

O tempo Unix 0 é a meia-noite UTC de 1 de janeiro de 1970. Converta qualquer timestamp em segundos inteiros, inclusive negativo, em ano, mês, dia, hora, minuto e segundo em UTC, com uma data e hora prontas para um log ou um chamado. Grátis no seu navegador.

Grátis
Funciona no seu navegador
Sem cadastro
Seus dados não saem do seu aparelho

Executar grátis Ver a API

Use pelo WebAPIE-mailTelegramApp em breve

Exemplo resolvido

Se você digitar

Carimbo de data/hora: 0

Você obtém

Ano: 1.970
Mês: 1
Dia: 1
Hora: 0

Um conversor de tempo Unix transforma esse inteiro em uma data de calendário e um horário de relógio que uma pessoa consegue ler: ano, mês, dia, hora, minuto e segundo, sempre em UTC. Esta ferramenta aceita um timestamp inteiro finito em segundos, parte-o em um índice de dia UTC e um horário do dia com divisão inteira para baixo, mapeia o índice no calendário gregoriano proléptico com a aritmética civil-from-days publicada e devolve uma string de data-hora UTC determinística no formato YYYY-MM-DDTHH:mm:ssZ. Inteiros negativos são de primeira classe: codificam instantes anteriores ao epoch, como 31 de dezembro de 1969.

O que o tempo Unix conta e como o calendário UTC é recuperado

O tempo Unix, também chamado tempo epoch ou tempo POSIX, é uma contagem com sinal de segundos completos decorridos desde 1970-01-01T00:00:00Z, ignorando segundos intercalares. Sistemas operacionais, claims JWT, colunas de banco e backends de observabilidade guardam instantes assim porque um inteiro não carrega ambiguidade de nome de mês, nem separador local, nem ramo de horário de verão. Pessoas ainda precisam de uma face de calendário: qual ano, mês e dia, e qual hora, minuto e segundo no relógio UTC.

Recuperar essa face é aritmética pura. Divida o inteiro por 86400 com divisão para baixo para obter um índice de dia relativo a 1º de janeiro de 1970 e um resto não negativo que é o segundo daquele dia UTC. Mapeie o índice pelo algoritmo gregoriano proléptico civil-from-days, com as mesmas constantes de era e dia da era publicadas para bibliotecas de tempo civil, até ano, mês e dia.

Parta o resto por 3600 e 60 para hora, minuto e segundo. Formate os seis campos civis como string de data-hora UTC YYYY-MM-DDTHH:mm:ssZ. Zero é a meia-noite do epoch.

Menos um é 1969-12-31T23:59:59Z. Um bilhão é o célebre bilionésimo segundo Unix em 9 de setembro de 2001 às 01:46:40 UTC. Esta página responde à busca por tempo Unix: dada uma contagem inteira de segundos, qual é a data e a hora de calendário em UTC, sem deslocamento local e sem chute de fração de segundo.

O mapeamento nunca consulta um relógio de parede, então o mesmo inteiro sempre produz a mesma string em testes e em produção.

Contrato de entrada, regra só-inteiro e forma da resposta

A regra só-inteiro é o contrato do produto: o tempo Unix POSIX é uma contagem de segundos, não de milissegundos nem um relógio flutuante. Se um fornecedor enviou milissegundos, divida por mil no chamador e envie o resultado em segundos completos. Em sucesso o corpo ecoa timestamp como o inteiro coercido; year, month, day, hour, minute e second como componentes civis UTC; datetime como a string de data-hora UTC com designador Z; timezone como a constante UTC; formula como a identidade fixa; e message como um resumo de uma linha.

Validação falha nunca é cobrada. Prefira afirmar a string datetime e os componentes ecoados em testes automatizados em vez de rederivar o calendário à mão em cada cliente. Os anos civis após a conversão devem cair entre 0001 e 9999; valores fora dessa janela são rejeitados em vez de formatados com overflow.

Onde um conversor de tempo Unix se paga, e o que ele não é

Quem responde a um incidente cola uma contagem bruta de segundos de um stack trace ou linha de log e precisa de um instante de calendário UTC para a linha do tempo do postmortem, sem confiar no fuso do notebook. Pipelines de dados normalizam colunas epoch inteiras em strings de data-hora UTC antes de cargas no warehouse e exportações de auditoria. Equipes de engenharia fixam datetime para entradas conhecidas para que a formatação do cliente e do servidor não divirja entre runtimes.

Mantenha milissegundos fora deste contrato: divida-os antes, ou você cairá nos anos 50000. A saída é sempre UTC com sufixo Z—não há base de fusos nomeados nem ramo de horário de verão—, então painéis que precisem de horário de cidade aplicam o próprio deslocamento depois desta conversão. Prefira esta capacidade quando você já tiver uma contagem em segundos completos e só precisar da string de calendário UTC.

Casos de uso

Triagem de logs de incidente em UTC

Cole um valor bruto de segundos Unix de um stack trace ou linha de log e obtenha uma data-hora civil UTC determinística para a linha do tempo do postmortem.

ETL de colunas epoch inteiras

Pipelines de dados convertem colunas epoch de segundos completos em strings de data-hora UTC antes de cargas no warehouse, exportações de auditoria e joins posteriores.

Perguntas frequentes

Como converter tempo Unix em uma data e hora UTC?

Envie um timestamp inteiro finito (segundos completos desde 1970-01-01T00:00:00Z).

Por que timestamps fracionários são rejeitados?

O tempo Unix POSIX é uma contagem de segundos completos.

O conversor usa o fuso horário local?

Não. A saída é sempre UTC com designador Z. Aplique um deslocamento local depois da conversão se o relógio de parede de uma cidade for necessário.

E os timestamps anteriores a 1970 ou o bilionésimo segundo Unix?

Inteiros negativos são válidos: −1 é 1969-12-31T23:59:59Z. O inteiro 1000000000 é 2001-09-09T01:46:40Z. Zero é a meia-noite do epoch.

E se meu timestamp estiver em milissegundos?

Divida primeiro por 1000 e informe o resultado em segundos inteiros. Aqui o tempo Unix é uma contagem de segundos, não de milissegundos, e um número com casas decimais é recusado em vez de arredondado.

Ferramentas relacionadas

Para desenvolvedores — acesso via API

Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.

Endpoint

POSThttps://api.kit.forhosting.com/conv/unix-time

Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.

Chame do seu código

curl -X POST https://api.kit.forhosting.com/conv/unix-time \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"timestamp":1000000000}'

const res = await fetch("https://api.kit.forhosting.com/conv/unix-time", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "timestamp": 1000000000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/conv/unix-time",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "timestamp": 1000000000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/unix-time", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"timestamp":1000000000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"timestamp":1000000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/unix-time", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemplo de requisição

{
  "timestamp": 1000000000
}

Exemplo de resposta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "conv.unix_time",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.

Preço

por chamadaUS$ 0,002

Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.

Erros

HTTP	Código	O que significa
`401`	`unauthorized`	Token ausente ou inválido. Confira o header Authorization.
`402`	`insufficient_balance`	Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo.
`404`	`unknown_type`	Esse tipo de tarefa não existe. Confira o campo type no catálogo.
`429`	`rate_limited`	Muitas requisições em pouco tempo. Espere um instante e tente de novo.

Notas técnicas

O tempo Unix é a contagem inteira de segundos completos desde a meia-noite do Tempo Universal Coordenado em 1º de janeiro de 1970, o epoch usado por kernels tipo Unix, APIs JSON, bancos de dados e pipelines de log. Timestamps fracionários, infinitos e valores não numéricos são rejeitados com invalid_input em vez de arredondados em silêncio, porque um epoch de meio segundo não é uma contagem POSIX de segundos.

Contrato de entrada, regra só-inteiro e forma da resposta

Faça POST de um corpo JSON com o campo obrigatório timestamp definido como um inteiro finito (segundos completos desde o epoch Unix). Os aliases unix, epoch, ts, seconds e unix_time são aceitos e coercidos da mesma forma. Strings numéricas que batem com um sinal opcional mais dígitos são aceitas quando um formulário envia texto; notação científica em string, strings vazias, booleanos, objetos, infinitos, NaN e qualquer número não inteiro falham com invalid_input nomeando timestamp. O preço é um valor fixo de US$ 0,002 por requisição bem-sucedida com unidade item.

Onde um conversor de tempo Unix se paga, e o que ele não é

Esta página mira quem busca tempo Unix, conversor de tempo Unix ou timestamp epoch para data UTC. Não é um conversor de epoch bidirecional que também devolve inteiros a partir de datas, nem um conversor de timestamp NTP, nem um conversor de unidades de duração (segundos versus horas), nem um formatador ISO 8601 fracionário que aceite resíduo subsegundo. Tarefas falhas que retornam invalid_input não consomem saldo pré-pago, o que mantém baratos scripts exploratórios quando se enviam strings lixo de propósito. Como a implementação é parse pura de nível A, cada chamada bem-sucedida custa o US$ 0,002 publicado, sem tokens de modelo e sem rede de saída.

Casos de integração

Fixtures fixadas para APIs de tempo

Equipes de engenharia fixam datetime para entradas inteiras conhecidas para que a formatação de calendário do cliente e do servidor nunca divirja entre runtimes.

Perguntas técnicas

Quanto custa o conversor de tempo Unix?

A ferramenta do navegador é gratuita. Requisições à API usam saldo pré-pago a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.

Ver a documentação completa do KIT →

Executar grátis

Exemplo resolvido

O que o tempo Unix conta e como o calendário UTC é recuperado

Contrato de entrada, regra só-inteiro e forma da resposta

Onde um conversor de tempo Unix se paga, e o que ele não é

Casos de uso

Triagem de logs de incidente em UTC

ETL de colunas epoch inteiras

Perguntas frequentes

Ferramentas relacionadas

Para desenvolvedores — acesso via API

Endpoint

Chame do seu código

Exemplo de requisição

Exemplo de resposta

Preço

Erros

Notas técnicas

Contrato de entrada, regra só-inteiro e forma da resposta

Onde um conversor de tempo Unix se paga, e o que ele não é

Casos de integração

Fixtures fixadas para APIs de tempo

Perguntas técnicas

obrigado