Segundos Unix para ISO 8601
Cole uma marca de tempo Unix em segundos e receba a data e hora UTC exata em ISO 8601: 1800000000 corresponde a 2027-01-15T08:00:00Z. Valores negativos anteriores a 1970 e frações de segundo também funcionam. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Segundos
- 1.800.000.000
- Ano
- 2.027
- Mês
- 1
- Dia
- 15
- Hora
- 8
Um conversor de segundos Unix para ISO 8601 responde a uma pergunta diária de engenharia: dado um contador de epoch como um bilhão e oitocentos milhões, qual é a data-hora civil exata em UTC que logs, APIs e bancos de dados devem exibir? Informe um número finito de segundos desde 1970-01-01T00:00:00Z e esta ferramenta divide o valor em um dia UTC inteiro e um horário do dia, mapeia o deslocamento de dias para ano-mês-dia gregoriano proléptico com o algoritmo civil-from-days publicado e devolve uma string ISO 8601 determinística terminando em Z. Segundos fracionários são aceitos e escritos com dígitos fracionários aparados quando necessário.
O que significa uma contagem de segundos Unix e por que ISO 8601 é a forma segura de exibir
O tempo Unix conta segundos desde a meia-noite UTC de 1 de janeiro de 1970: uma linha do tempo simples inteira (ou real) que as máquinas trocam sem separadores locais, nomes de mês ou regras de horário de verão. Essa simplicidade explica por que linhas de log, claims JWT, colunas de banco e filas de mensagens armazenam momentos como segundos de epoch. Humanos ainda precisam de uma face de calendário: ano, mês, dia, hora, minuto e segundo em uma string em que os parsers concordam no mundo todo.
ISO 8601 com sufixo Z é essa face para UTC—YYYY-MM-DDTHH:mm:ssZ—inequívoca entre idiomas e planilhas. Converter corretamente não é detalhe opcional durante uma pane: ler mal um timestamp por doze horas pode enviar a janela errada de postmortem ou a purga de retenção incorreta. Esta capacidade calcula a data civil com aritmética gregoriana proléptica pura a partir do índice de dia floor(seconds dividido por 86400) e depois monta os campos do relógio a partir do resto não negativo.
Timestamps negativos são de primeira classe: um segundo antes do epoch é 1969-12-31T23:59:59Z, não um erro. O mapeamento nunca consulta o relógio do servidor, então o mesmo número sempre produz a mesma string em testes e em produção. Prefira esta página quando a intenção de busca for especificamente segundos Unix para ISO 8601 em UTC, não um conversor bidirecional multiunidade nem um relógio de parede de fuso local.
Dicas práticas, limites e como isso difere de ferramentas relacionadas
Mantenha um conjunto pequeno conhecido para ensino e CI: zero mapeia para 1970-01-01T00:00:00Z; um bilhão e oitocentos milhões para 2027-01-15T08:00:00Z; menos um para 1969-12-31T23:59:59Z; e uma falha deliberada não numérica. Quando um fornecedor envia epoch em milissegundos, divida por mil antes de chamar para que o campo second permaneça no contrato de segundos Unix.
Documente que a saída é sempre UTC com sufixo Z—não há deslocamento local, nem base de fusos nomeados, nem ramo de horário de verão—, então painéis que precisem de horário de cidade devem aplicar o próprio deslocamento depois desta conversão. Os limites de ano vão de um a nove mil novecentos e noventa e nove após a conversão; valores extremos fora dessa janela civil são rejeitados em vez de formatados com overflow.
Não é um conversor de epoch bidirecional que também devolve inteiros, nem um conversor de segundos NTP, nem uma ferramenta de humanizar duração, nem um mapeador de série de planilha. Prefira esta capacidade quando já tiver uma contagem em segundos e só precisar da string ISO UTC; se precisar dos dois sentidos ou de chaves de milissegundos no mesmo formulário, use um conversor de epoch geral.
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 string ISO 8601 UTC determinística para a linha do tempo do postmortem.
Normalização ETL de epochs de fornecedores
Pipelines de dados convertem colunas mistas de epoch em segundos em strings ISO 8601 antes de cargas no data warehouse e exportações de auditoria.
Perguntas frequentes
O resultado está em horário local ou em UTC?
Sempre UTC. A string iso termina em Z e timezone é a constante UTC. Nenhum deslocamento local ou fuso nomeado é aplicado.
Posso passar milissegundos em vez de segundos?
Não diretamente. Esta ferramenta espera segundos. Divida milissegundos por 1000 antes de chamar para que a unidade fique inequívoca.
O que acontece com um valor ausente ou não numérico?
Entrada ausente, vazia, não finita ou não numérica é rejeitada em vez de forçada a zero.
O conversor de segundos Unix para ISO 8601 é gratuito?
A ferramenta do navegador é gratuita e roda localmente.
Posso converter marcas de tempo negativas, anteriores a 1970?
Pode. Valores negativos são válidos e contam para trás a partir da meia-noite UTC de 1º de janeiro de 1970: um segundo antes dá 1969-12-31T23:59:59Z, não um erro.
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
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/date/unix-seconds-to-iso \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"seconds":1800000000}'const res = await fetch("https://api.kit.forhosting.com/date/unix-seconds-to-iso", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"seconds": 1800000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/unix-seconds-to-iso",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"seconds": 1800000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/unix-seconds-to-iso", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"seconds":1800000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"seconds":1800000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/unix-seconds-to-iso", 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
{
"seconds": 1800000000
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.unix_seconds_to_iso",
"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
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
Entrada ausente ou não finita é rejeitada com invalid_input em vez de ser forçada silenciosamente a zero, porque um epoch vazio é erro de dados, não a meia-noite do epoch Unix.
Como chamar a API e o que a resposta contém
Números em string que batem com um padrão numérico finito estrito são aceitos quando formulários ou query strings forçam texto. Em sucesso, a resposta ecoa seconds como o número coercido, year, month, day, hour, minute e second como componentes civis UTC, iso como a string ISO 8601 com designador Z, timezone como a constante UTC, formula como a descrição fixa de identidade e message como um resumo de uma linha. Prefira afirmar a string iso e os componentes ecoados em testes automatizados em vez de rederivar o calendário à mão em cada cliente. Milissegundos devem ser convertidos pelo chamador (dividir por mil) porque este contrato é só de segundos; isso mantém a intenção SEO estreita e evita erros silenciosos de unidade. Faça POST de um corpo JSON com o campo obrigatório seconds definido como um número finito (inteiro ou fracionário). Os aliases unix, epoch, ts, timestamp e unix_seconds são aceitos por ergonomia e convertidos da mesma forma que seconds. Validação falha—campo ausente, valores não finitos, strings não numéricas ou ano civil fora de 0001–9999—retorna invalid_input e nunca é cobrada. O preço é um valor fixo de US$ 0,002 por requisição bem-sucedida com unidade item.
Dicas práticas, limites e como isso difere de ferramentas relacionadas
Esta página mira quem busca segundos Unix para ISO 8601, epoch para data-hora ISO ou um conversor gratuito de timestamp Unix para string UTC. 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.
Casos de integração
Fixtures de testes unitários para APIs de tempo
Equipes de engenharia fixam iso para entradas de segundos conhecidas para que a formatação de data-hora do cliente e do servidor nunca divirja entre runtimes.
Perguntas técnicas
Como converter segundos Unix em uma data-hora ISO 8601?
Envie um valor finito de seconds (segundos de epoch Unix desde 1970-01-01T00:00:00Z). A API devolve iso como YYYY-MM-DDTHH:mm:ss[.frac]Z em UTC mais os componentes civis.