Conversor de Marca de Tiempo
Convierte entre marcas de tiempo Unix y formatos de fecha y hora
Marca de Tiempo a Fecha
Fecha a Marca de Tiempo
Comparación de Zonas Horarias
Ejemplos de Formatos Comunes
¿Qué es una Marca de Tiempo?
Una marca de tiempo es un valor numérico que representa un momento específico. La marca de tiempo Unix es el número de segundos transcurridos desde el 1 de enero de 1970 00:00:00 UTC (llamada época Unix). Es la forma estándar de representar tiempo en sistemas informáticos, con consistencia multiplataforma y multizona horaria. Las marcas de tiempo se dividen en nivel de segundos (10 dígitos) y nivel de milisegundos (13 dígitos). Las de segundos se usan comúnmente en sistemas Unix/Linux, mientras que las de milisegundos son comunes en JavaScript y otros lenguajes. Cuando se usa con otras personas, entradas, supuestos y resultado esperado deben quedar claros para evitar malinterpretaciones.
Cómo usar
De marca de tiempo a fecha
- Introduce una marca de tiempo Unix en la tarjeta izquierda
- Selecciona la zona horaria de destino (p. ej., hora de Pekín UTC+8)
- Haz clic en el botón de conversión para ver la fecha y hora convertida
- Los resultados incluyen: formato estándar, ISO 8601, formato en chino y más
De fecha a marca de tiempo
- Selecciona la fecha y hora en la tarjeta derecha
- Selecciona la zona horaria de origen usada por esa fecha y hora
- Haz clic en el botón de conversión para obtener la marca de tiempo Unix
- Los resultados incluyen marcas de tiempo en segundos y milisegundos
Consejos sobre zonas horarias
- Comprueba si el valor original usa segundos o milisegundos; mezclar marcas de tiempo de 10 y 13 dígitos es una causa frecuente de fechas incorrectas.
- Confirma siempre la zona horaria prevista al convertir fechas legibles, sobre todo en registros, tareas programadas y sistemas entre regiones.
Casos de uso
Principio técnico
Una marca de tiempo Unix cuenta el tiempo transcurrido desde la Época Unix, definida como 1970-01-01T00:00:00Z, que es el punto cero que el tiempo POSIX usa para etiquetar cada instante posterior. El tiempo POSIX ignora deliberadamente los segundos intercalares: cada día calendario se trata como exactamente 86.400 segundos, por lo que dos marcas de tiempo que abarquen una inserción de segundo intercalar tendrán un desvío de un segundo respecto a un conteo estricto de reloj atómico, pero la ventaja es que la conversión entre segundos de época y campos calendario UTC se mantiene como un divmod limpio por 86.400. Los dos formatos que aparecen a diario son segundos (10 dígitos actualmente, p. ej. 1717000000) y milisegundos (13 dígitos, p. ej. 1717000000000). El Date.now() de JavaScript devuelve milisegundos desde la época y `new Date(ms)` espera milisegundos, mientras que el `date +%s` de Unix, el time.Unix de Go y la mayoría de las columnas TIMESTAMP de bases de datos usan segundos. La detección por longitud es la desambiguación habitual: un valor de 10 dígitos cae en el rango 2001-2286 si se lee como segundos, y el mismo valor leído como milisegundos estaría dentro de 1970. Mostrar una marca de tiempo requiere una zona horaria. UTC se escribe con el sufijo `Z`; otros desplazamientos usan `±HH:MM` (p. ej. `+08:00` para la hora estándar de China, `-05:00` para la hora estándar del este de EE. UU.). ISO 8601 permite varios separadores opcionales mientras que RFC 3339 es un perfil más estricto que los fija, razón por la cual las especificaciones de API suelen requerir RFC 3339 con un desplazamiento explícito. Los sistemas heredados que almacenan segundos de época en un entero con signo de 32 bits desbordan en el valor máximo positivo 2147483647, que corresponde a 2038-01-19T03:14:07Z (el problema Y2038); el almacenamiento de 64 bits empuja el límite muy por encima de cualquier relevancia humana.
- La Época Unix está fijada en 1970-01-01T00:00:00Z y el tiempo POSIX ignora los segundos intercalares, por lo que cada día se trata como exactamente 86.400 segundos.
- JavaScript Date.now() devuelve milisegundos; `Math.floor(Date.now() / 1000)` convierte a una marca de tiempo a nivel de segundos.
- Límite Y2038: una marca de tiempo con signo de 32 bits desborda en 2147483647 = 2038-01-19T03:14:07Z; el almacenamiento de 64 bits evita este problema.
- ISO 8601 vs RFC 3339: RFC 3339 es un perfil más estricto de ISO 8601 que requiere un desplazamiento explícito (`Z` o `±HH:MM`) y es preferido para APIs y registros.
- ECMAScript Date está limitado a ±100.000.000 días desde la época (≈ ±273.785 años), razón por la cual `new Date(8.64e15)` y `new Date(-8.64e15)` son los límites absolutos.
- Los claims JWT `exp`, `iat` y `nbf`, `Cache-Control: max-age` y Cookie `Expires` usan segundos Unix (RFC 7519, RFC 7234), así que súmalos o réstalos directamente contra `Math.floor(Date.now()/1000)`.
- La zona horaria afecta la fecha y hora renderizada, pero no el valor de la marca de tiempo en sí; el mismo segundo de época se muestra como horas de reloj diferentes en UTC+8 y UTC-5.
Ejemplos
Convertir una marca de tiempo Unix de 10 dígitos a una fecha legible
Entrada: 1781526600
UTC: 2026-06-15 12:30:00
Pekín (UTC+8): 2026-06-15 20:30:00
ISO 8601: 2026-06-15T12:30:00Z
POSIX: IEEE 1003.1 define el tiempo Unix como segundos desde 1970-01-01 00:00:00 UTC (la Época)
ISO: ISO 8601 define el formato YYYY-MM-DDThh:mm:ssZ para una representación inequívoca de fecha y horaConvertir una fecha de vuelta a marca de tiempo
Entrada: 2026-01-01 00:00:00 (UTC)
Segundos (10 dígitos): 1767225600
Milisegundos (13 dígitos): 1767225600000
Comando Unix: date -d @1767225600
Nota: JavaScript Date.getTime() devuelve milisegundos; Python time.time() devuelve segundos (float)
POSIX: el tipo time_t es tradicionalmente un entero con signo de 32 o 64 bitsDistinguir entre segundos y milisegundos
1781526600 -> 10 dígitos, segundos -> 2026-06-15 12:30:00 UTC
1781526600000 -> 13 dígitos, milisegundos -> 2026-06-15 12:30:00.000 UTC
Error común: un valor de 13 dígitos leído como segundos daría aproximadamente el año 74.000
Truco rápido: 10-11 dígitos = segundos (1970-2286), 13 dígitos = milisegundos (predeterminado en JavaScript)Decodificar la claim exp de un JWT
Payload JWT: { "exp": 1798617600 }
Decodificado: 2027-01-01 00:00:00 UTC
Ahora actual: 1781526600
Válido por: 17.091.000 segundos (~198 días restantes)
RFC: RFC 7519 sección 2 define NumericDate como segundos desde la ÉpocaVerificación del límite Y2038
Marca de tiempo máxima con signo de 32 bits: 2147483647
Decodificado: 2038-01-19 03:14:07 UTC
Un segundo después: 2147483648 -> desbordamiento en sistemas legacy de 32 bits
Solución: usar time_t de 64 bits (predeterminado en Linux/macOS modernos) o almacenar como cadena ISO 8601
POSIX: los sistemas con time_t de 32 bits darán la vuelta tras 2038-01-19Preguntas frecuentes
¿Qué es una marca de tiempo Unix?
El número de segundos transcurridos desde el 1970-01-01 00:00:00 UTC, la 'época Unix'. JavaScript y muchas API usan milisegundos desde la misma época (timestamp Unix × 1000). La página acepta ambos y muestra la fecha correspondiente en tu hora local y en UTC.
¿Segundos, milisegundos, microsegundos o nanosegundos?
Distintos sistemas usan distinta precisión. La función `time()` de Unix devuelve segundos. Date.now() de JavaScript devuelve milisegundos. Instant de Java admite nanosegundos. La página detecta automáticamente por número de dígitos: 10 dígitos = segundos (entre 2001-2286), 13 = milisegundos, 16 = microsegundos, 19 = nanosegundos.
¿Por qué es importante el 19 de enero de 2038?
Es el 'problema del año 2038': las marcas de tiempo Unix con signo de 32 bits desbordan a las 03:14:07 UTC del 2038-01-19. Los sistemas que aún usen un time_t de 32 bits volverán a 1901. Los sistemas modernos de 64 bits no se ven afectados durante miles de millones de años; los sistemas embebidos antiguos necesitan parche.
¿Cómo gestiona las zonas horarias?
Las marcas de tiempo Unix son inherentemente UTC. La página muestra tu hora local, UTC, y te permite elegir cualquier zona horaria IANA (Asia/Shanghai, America/New_York, Europe/London) para visualizaciones adicionales. El horario de verano se aplica automáticamente según la zona.
¿Por qué interpretar 'YYYY-MM-DD' asume UTC en algunos sitios?
Las fechas ISO 8601 sin zona horaria son ambiguas. El constructor Date de JavaScript trata las cadenas solo de fecha como UTC y las cadenas de fecha-hora como locales: una fuente notoria de errores de un día. La página es explícita sobre qué zona horaria aplica.
¿La conversión se hace localmente?
Sí. Los cálculos usan Date de JavaScript junto con Intl.DateTimeFormat. Ninguna marca de tiempo se sube.
¿Puedo generar una marca de tiempo futura?
Sí. Elige una fecha futura y la página devuelve la marca de tiempo correspondiente. Útil para fijar el claim exp de un JWT, fechas de prueba para cron, o ventanas de expiración de caché en código.