Conversor de tiempo Unix
El tiempo Unix 0 es la medianoche UTC del 1 de enero de 1970. Pase cualquier marca de tiempo en segundos enteros, también negativa, al año, mes, día, hora, minuto y segundo en UTC, con una fecha y hora lista para un registro o un ticket. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Marca de tiempo
- 0
- Año
- 1 970
- Mes
- 1
- Día
- 1
- Hora
- 0
Un conversor de tiempo Unix transforma ese entero en una fecha de calendario y una hora de reloj que una persona puede leer: año, mes, día, hora, minuto y segundo, siempre en UTC. Esta herramienta acepta un timestamp entero finito en segundos, lo parte en un índice de día UTC y una hora del día con división entera hacia abajo, proyecta el índice sobre el calendario gregoriano proléptico con la aritmética civil-from-days publicada y devuelve una cadena de fecha-hora UTC determinista de la forma YYYY-MM-DDTHH:mm:ssZ. Los enteros negativos son de primera clase: codifican instantes anteriores al epoch, como el 31 de diciembre de 1969.
Qué cuenta el tiempo Unix y cómo se recupera el calendario UTC
El tiempo Unix, también llamado tiempo epoch o tiempo POSIX, es un recuento con signo de segundos completos transcurridos desde 1970-01-01T00:00:00Z, ignorando los segundos intercalares. Los sistemas operativos, las claims JWT, las columnas de base de datos y los backends de observabilidad guardan instantes así porque un entero no arrastra ambigüedad de nombre de mes, ni separador local, ni rama de horario de verano. Las personas siguen necesitando una cara de calendario: qué año, mes y día, y qué hora, minuto y segundo en el reloj UTC.
Recuperar esa cara es aritmética pura. Divida el entero entre 86400 con división hacia abajo para obtener un índice de día relativo al 1 de enero de 1970 y un resto no negativo que es el segundo de ese día UTC. Proyecte el índice mediante el algoritmo gregoriano proléptico civil-from-days, con las mismas constantes de era y día de era publicadas para bibliotecas de tiempo civil, hasta año, mes y día.
Parta el resto entre 3600 y 60 para hora, minuto y segundo. Formatee los seis campos civiles como cadena de fecha-hora UTC YYYY-MM-DDTHH:mm:ssZ. El cero es la medianoche del epoch.
El menos uno es 1969-12-31T23:59:59Z. Mil millones es el célebre milmillonésimo segundo Unix del 9 de septiembre de 2001 a las 01:46:40 UTC. Esta página responde a la búsqueda de tiempo Unix: dado un recuento entero de segundos, cuál es la fecha y la hora de calendario en UTC, sin desplazamiento local y sin conjeturas de fracción de segundo.
El mapeo nunca consulta un reloj de pared, así que el mismo entero produce siempre la misma cadena en pruebas y en producción.
Contrato de entrada, regla solo-entero y forma de la respuesta
La regla solo-entero es el contrato del producto: el tiempo Unix POSIX es un recuento de segundos, no de milisegundos ni un reloj flotante. Si un proveedor envió milisegundos, divídalos entre mil en el llamador y envíe el resultado en segundos completos.
En éxito el cuerpo repite timestamp como el entero forzado; year, month, day, hour, minute y second como componentes civiles UTC; datetime como la cadena de fecha-hora UTC con designador Z; timezone como la constante UTC; formula como la identidad fija; y message como un resumen de una línea. La validación fallida nunca se cobra. Prefiera asertar la cadena datetime y los componentes repetidos en pruebas automatizadas en lugar de rederivar el calendario a mano en cada cliente.
Los años civiles tras la conversión deben quedar entre 0001 y 9999; los valores fuera de esa ventana se rechazan en lugar de formatearse con desbordamiento.
Dónde rinde un conversor de tiempo Unix y qué no es
Quienes responden a un incidente pegan un recuento crudo de segundos de una traza o línea de registro y necesitan un instante de calendario UTC para la línea de tiempo del postmortem, sin fiarse del huso del portátil. Las canalizaciones de datos normalizan columnas epoch enteras en cadenas de fecha-hora UTC antes de cargas al almacén y exportaciones de auditoría. Los equipos de ingeniería fijan datetime para entradas conocidas de modo que el formato del cliente y del servidor no discrepe entre entornos de ejecución.
Deje los milisegundos fuera de este contrato: divídalos antes, o caerá en los años 50000. La salida es siempre UTC con sufijo Z—no hay base de zonas con nombre ni rama de horario de verano—, así que los paneles que necesiten hora de ciudad aplican su propio desplazamiento después de esta conversión. Prefiera esta capacidad cuando ya tenga un recuento en segundos completos y solo necesite la cadena de calendario UTC.
Qué puede hacer con ella
Triaje de registros de incidente en UTC
Pegue un valor crudo de segundos Unix de una traza o línea de registro y obtenga una fecha-hora civil UTC determinista para la línea de tiempo del postmortem.
ETL de columnas epoch enteras
Las canalizaciones de datos convierten columnas epoch de segundos completos en cadenas de fecha-hora UTC antes de cargas al almacén, exportaciones de auditoría y uniones posteriores.
Preguntas frecuentes
¿Cómo convierto el tiempo Unix a una fecha y hora UTC?
Envíe un timestamp entero finito (segundos completos desde 1970-01-01T00:00:00Z).
¿Por qué se rechazan los timestamps fraccionarios?
El tiempo Unix POSIX es un recuento de segundos completos.
¿El conversor usa la zona horaria local?
No. La salida es siempre UTC con designador Z. Aplique un desplazamiento local después de la conversión si necesita el reloj de pared de una ciudad.
¿Qué ocurre con timestamps anteriores a 1970 o con el milmillonésimo segundo Unix?
Los enteros negativos son válidos: −1 es 1969-12-31T23:59:59Z. El entero 1000000000 es 2001-09-09T01:46:40Z. El cero es la medianoche del epoch.
¿Qué hago si mi marca de tiempo está en milisegundos?
Divídala primero entre 1000 e introduzca el resultado en segundos enteros. Aquí el tiempo Unix es un recuento de segundos, no de milisegundos, y un número con decimales se rechaza en lugar de redondearse.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
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)Ejemplo de solicitud
{
"timestamp": 1000000000
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.unix_time",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
El tiempo Unix es el recuento entero de segundos completos desde la medianoche del Tiempo Universal Coordinado del 1 de enero de 1970, el epoch que emplean núcleos tipo Unix, APIs JSON, bases de datos y canalizaciones de registro. Los timestamps fraccionarios, los infinitos y los valores no numéricos se rechazan con invalid_input en lugar de redondearse en silencio, porque un epoch de medio segundo no es un recuento POSIX de segundos.
Contrato de entrada, regla solo-entero y forma de la respuesta
Envíe por POST un cuerpo JSON con el campo obligatorio timestamp igual a un entero finito (segundos completos desde el epoch Unix). Se aceptan los alias unix, epoch, ts, seconds y unix_time y se fuerzan del mismo modo. Las cadenas numéricas que coinciden con un signo opcional más dígitos se aceptan cuando un formulario envía texto; la notación científica en cadena, las cadenas vacías, los booleanos, los objetos, los infinitos, NaN y cualquier número no entero fallan con invalid_input nombrando timestamp. El precio es un fijo de $0.002 por petición exitosa con unidad item.
Dónde rinde un conversor de tiempo Unix y qué no es
Esta página apunta a quien busca tiempo Unix, conversor de tiempo Unix o timestamp epoch a fecha UTC. No es un convertidor de epoch bidireccional que también devuelve enteros a partir de fechas, ni un convertidor de timestamp NTP, ni un convertidor de unidades de duración (segundos frente a horas), ni un formateador ISO 8601 fraccionario que acepte residuo subsegundo. Las tareas fallidas que devuelven invalid_input no consumen saldo prepago, lo que mantiene baratos los scripts exploratorios cuando se envían cadenas basura a propósito. Como la implementación es parse pura de nivel A, cada llamada exitosa cuesta el $0.002 publicado, sin tokens de modelo y sin red de salida.
Casos de integración
Fixtures ancladas para APIs de tiempo
Los equipos de ingeniería fijan datetime para entradas enteras conocidas de modo que el formato de calendario del cliente y del servidor no discrepe entre entornos de ejecución.
Preguntas técnicas
¿Cuánto cuesta el conversor de tiempo Unix?
La herramienta del navegador es gratuita. Las peticiones a la API usan saldo prepago a $0.002 por llamada exitosa; la entrada inválida no se cobra.