Segundos Unix a ISO 8601
Pegue una marca de tiempo Unix en segundos y obtenga la fecha y hora UTC exacta en ISO 8601: 1800000000 corresponde a 2027-01-15T08:00:00Z. También admite valores negativos anteriores a 1970 y fracciones de segundo. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Ejemplo resuelto
- Segundos
- 1 800 000 000
- Año
- 2 027
- Mes
- 1
- Día
- 15
- Hora
- 8
Un convertidor de segundos Unix a ISO 8601 responde a una pregunta diaria de ingeniería: dado un contador de epoch como mil ochocientos millones, ¿cuál es la fecha-hora civil exacta en UTC que deben mostrar registros, APIs y bases de datos? Introduzca un número finito de segundos desde 1970-01-01T00:00:00Z y esta herramienta divide el valor en un día UTC completo y una hora del día, asigna el desplazamiento de día a año-mes-día gregoriano proléptico con el algoritmo civil-from-days publicado y devuelve una cadena ISO 8601 determinista que termina en Z. Se aceptan segundos fraccionarios y se escriben con dígitos fraccionarios recortados cuando corresponde.
Qué significa un contador de segundos Unix y por qué ISO 8601 es la forma segura de mostrarlo
El tiempo Unix cuenta segundos desde la medianoche UTC del 1 de enero de 1970: una línea temporal simple entera (o real) que las máquinas intercambian sin separadores locales, nombres de mes ni reglas de horario de verano. Esa simplicidad explica por qué las líneas de registro, las claims JWT, las columnas de base de datos y las colas de mensajes guardan instantes como segundos de epoch.
Las personas siguen necesitando una cara de calendario: año, mes, día, hora, minuto y segundo en una cadena en la que los analizadores coinciden en todo el mundo. ISO 8601 con sufijo Z es esa cara para UTC—YYYY-MM-DDTHH:mm:ssZ—inequívoca entre idiomas y hojas de cálculo. Convertir bien no es un detalle opcional en un incidente: leer mal una marca de tiempo por doce horas puede enviar la ventana de postmortem equivocada o la purga de retención incorrecta.
Esta capacidad calcula la fecha civil con aritmética gregoriana proléptica pura a partir del índice de día floor(seconds dividido por 86400) y luego construye los campos del reloj con el resto no negativo. Las marcas negativas son de primera clase: un segundo antes del epoch es 1969-12-31T23:59:59Z, no un error. El mapeo nunca consulta el reloj del servidor, así que el mismo número siempre produce la misma cadena en pruebas y en producción.
Prefiera esta página cuando su intención de búsqueda sea concretamente segundos Unix a ISO 8601 en UTC, no un conversor bidireccional multiunidad ni un reloj de pared de zona local.
Consejos prácticos, límites y diferencias con herramientas relacionadas
Conserve un conjunto pequeño conocido para enseñanza y CI: cero corresponde a 1970-01-01T00:00:00Z; mil ochocientos millones a 2027-01-15T08:00:00Z; menos uno a 1969-12-31T23:59:59Z; y un fallo deliberado no numérico. Cuando un proveedor envía epoch en milisegundos, divida por mil antes de llamar para que el campo second siga el contrato de segundos Unix.
Documente que la salida es siempre UTC con sufijo Z—no hay desplazamiento local, ni base de zonas con nombre, ni rama de horario de verano—, así que los paneles que necesiten hora de ciudad deben aplicar su propio desplazamiento después de esta conversión. Los límites de año son del uno al nueve mil novecientos noventa y nueve tras la conversión; los valores extremos fuera de esa ventana civil se rechazan en lugar de formatearse con desbordamiento.
No es un convertidor de epoch bidireccional que también devuelve enteros, ni un convertidor de segundos NTP, ni una herramienta de humanizar duración, ni un mapeador de serie de hojas de cálculo. Prefiera esta capacidad cuando ya tenga un contador en segundos y solo necesite la cadena ISO UTC; si necesita ambos sentidos o conmutadores de milisegundos en un solo formulario, use un convertidor de epoch general.
Qué puede hacer con ella
Triaje de registros de incidentes en UTC
Pegue un valor crudo de segundos Unix de una traza o línea de registro y obtenga una cadena ISO 8601 UTC determinista para la línea de tiempo del postmortem.
Normalización ETL de epochs de proveedores
Las canalizaciones de datos convierten columnas de epoch en segundos mixtas en cadenas ISO 8601 antes de cargas al almacén y exportaciones de auditoría.
Preguntas frecuentes
¿El resultado está en hora local o en UTC?
Siempre UTC. La cadena iso termina en Z y timezone es la constante UTC. No se aplican desplazamientos locales ni zonas con nombre.
¿Puedo pasar milisegundos en lugar de segundos?
No directamente. Esta herramienta espera segundos. Divida los milisegundos entre 1000 antes de llamar para que la unidad quede inequívoca.
¿Qué ocurre con un valor ausente o no numérico?
La entrada ausente, vacía, no finita o no numérica se rechaza en lugar de forzar cero.
¿Es gratuito el convertidor de segundos Unix a ISO 8601?
La herramienta del navegador es gratuita y se ejecuta en local.
¿Puedo convertir marcas de tiempo negativas, anteriores a 1970?
Sí. Los valores negativos son válidos y cuentan hacia atrás desde la medianoche UTC del 1 de enero de 1970: un segundo antes da 1969-12-31T23:59:59Z, no un error.
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/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)Ejemplo de solicitud
{
"seconds": 1800000000
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.unix_seconds_to_iso",
"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
La entrada ausente o no finita se rechaza con invalid_input en lugar de forzar cero en silencio, porque un epoch vacío es un error de datos, no la medianoche del epoch Unix.
Cómo llamar a la API y qué contiene la respuesta
Los números en cadena que cumplan un patrón numérico finito estricto se aceptan cuando formularios o cadenas de consulta fuerzan texto. En éxito, la respuesta repite seconds como el número forzado, year, month, day, hour, minute y second como componentes civiles UTC, iso como la cadena ISO 8601 con designador Z, timezone como la constante UTC, formula como la descripción fija de identidad y message como un resumen de una línea. Prefiera asertar la cadena iso y los componentes repetidos en pruebas automatizadas en lugar de rederivar el calendario a mano en cada cliente. Los milisegundos debe convertirlos el llamador (dividir por mil) porque este contrato es solo segundos; eso mantiene la intención SEO estrecha y evita errores silenciosos de unidad. Envíe por POST un cuerpo JSON con el campo obligatorio seconds a un número finito (entero o fraccionario). Se aceptan los alias unix, epoch, ts, timestamp y unix_seconds por comodidad y se convierten igual que seconds. La validación fallida—campo ausente, valores no finitos, cadenas no numéricas o un año civil fuera de 0001–9999—devuelve invalid_input y no se cobra. El precio es un fijo de $0.002 por petición exitosa con unidad item.
Consejos prácticos, límites y diferencias con herramientas relacionadas
Esta página apunta a quien busca segundos Unix a ISO 8601, epoch a fecha-hora ISO o un convertidor gratuito de timestamp Unix a cadena UTC. Las tareas fallidas con invalid_input no consumen saldo prepago, lo que mantiene baratos los scripts exploratorios cuando se envían cadenas basura a propósito.
Casos de integración
Fixtures de pruebas unitarias para APIs de tiempo
Los equipos de ingeniería fijan iso para entradas de segundos conocidas de modo que el formato de fecha-hora del cliente y del servidor no diverja entre entornos de ejecución.
Preguntas técnicas
¿Cómo convierto segundos Unix a una fecha-hora ISO 8601?
Envíe un valor finito de seconds (segundos de epoch Unix desde 1970-01-01T00:00:00Z). La API devuelve iso como YYYY-MM-DDTHH:mm:ss[.frac]Z en UTC más los componentes civiles.