logo
GeekFormat

Conversor Unix Timestamp

Marca de tiempo Unix actual
1784571479
2026-07-21 02:17:59 (UTC)

Ejemplos de código

JavaScript
// Obtener marca de tiempo actual new Date(Convertir marca a fecha).toLocaleString()
Python
import time time.time() # Obtener marca de tiempo actual time.ctime(1800000000) # Convertir marca a fecha
Go
import "time" time.Now().Unix() // Obtener marca de tiempo actual time.Unix(1800000000, 0).String()
Bash
# Obtener marca de tiempo actual date +%s # Convertir marca a fecha date -d @1800000000

La marca de tiempo Unix cuenta los segundos transcurridos desde el 1 de enero de 1970, 00:00:00 UTC.

Conversor online gratuito de Unix Timestamp con conversión bidireccional segundos/milisegundos/microsegundos, detección automática de unidades, conmutador UTC/zona horaria local y ejemplos de código multilingües integrados. Listo para usar instantáneamente para desarrollo y depuración.

Relacionado

¿Qué es un Unix Timestamp?

Un Unix Timestamp (también llamado Epoch Time o POSIX Time) es una forma de representar el tiempo como un único número: el recuento de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 UTC (el Unix Epoch), sin contar los segundos intercalares. En el propio Unix Epoch, el timestamp es 0.

La mayor ventaja de los timestamps es la independencia de zona horaria — el mismo momento produce el mismo timestamp en cualquier parte de la Tierra, sin problemas de conversión de zona horaria. Esto los hace ideales para: tiempos de creación/actualización de registros en bases de datos, rastreo de logs en sistemas distribuidos (IDs trace/span con timestamps), parámetros de tiempo de API, tiempos de expiración de tokens JWT, valores TTL de caché y tiempos de modificación del sistema de archivos.

Diferentes lenguajes y sistemas usan diferentes precisiones: C/Unix/Python usan por defecto segundos (10 dígitos), JavaScript/Java usan milisegundos (13 dígitos), y los sistemas de alta precisión (trading financiero, cálculo científico) usan microsegundos (16 dígitos) o incluso nanosegundos (19 dígitos). Esta herramienta cubre las tres precisiones más comunes: segundos, milisegundos y microsegundos.

Casos de uso

  • Convertir timestamps en archivos de log a fechas legibles durante la depuración para localizar rápidamente los momentos de los problemas
  • Verificar campos timestamp en payloads de petición/respuesta durante la integración de API
  • Convertir horas de negocio a timestamps para consultas SQL de rango de tiempo en operaciones de base de datos
  • Comparar timestamps UTC con la hora local durante la operación de servidores para solucionar problemas de implementaciones en múltiples zonas horarias
  • Copiar fragmentos de código para obtener timestamps en varios lenguajes al escribir scripts
  • Convertir fechas históricas (anteriores a 1970) o futuras a timestamps para probar casos límite

Cómo Usar

  1. La parte superior de la página muestra un timestamp Unix actual en tiempo real que se puede copiar directamente con un clic
  2. Para convertir timestamp a fecha: Introduce el timestamp en la pestaña 'Timestamp → Fecha' — la herramienta detecta automáticamente segundos/milisegundos/microsegundos
  3. Selecciona UTC u hora local; el resultado aparece instantáneamente y se puede copiar con el botón de copia
  4. Para convertir fecha a timestamp: Cambia a la pestaña 'Fecha → Timestamp' y rellena los campos año/mes/día/hora/minuto/segundo
  5. Después de seleccionar la zona horaria, el timestamp en segundos aparece instantáneamente — copia con un clic para código o consultas

Características

  • Detección automática de unidades: Pega cualquier timestamp e identifica automáticamente segundos/milisegundos/microsegundos — no se necesita selección manual
  • Tres niveles de precisión: Cobertura completa de segundos (10 dígitos), milisegundos (13 dígitos) y microsegundos (16 dígitos) para todos los lenguajes y sistemas
  • Conmutador UTC/Zona horaria local: UTC para logs de servidor, Local para hora de negocio — cambio con un clic para comparación
  • Entrada de fecha campo por campo: Cuadros de entrada separados para año/mes/día/hora/minuto/segundo para conversión fecha-a-timestamp — sin memorizar formatos de fecha
  • Visualización de timestamp en vivo: Timestamp Unix actual en tiempo real con fecha UTC mostrada en la parte superior, copia con un clic
  • Fragmentos de código multilingües: Código JavaScript/Python/Go/Bash integrado para obtener y convertir timestamps, copia con un clic
  • Soporte para timestamps negativos: Convierte cualquier fecha desde 1920 hasta 2100, cubriendo fechas históricas y futuras
  • Cálculo en el cliente: Todas las conversiones se ejecutan localmente en tu navegador — los timestamps nunca se envían a ningún servidor

Ejemplos de Código

Obtener y convertir timestamps en JavaScript

javascript

Métodos comunes para obtener timestamps actuales en segundos/milisegundos en navegadores y Node.js, y convertirlos a hora local legible.

// Obtener el timestamp actual en segundos
const tsSec = Math.floor(Date.now() / 1000);
console.log(tsSec); // ej. 1700000000

// Obtener el timestamp actual en milisegundos
const tsMs = Date.now();
console.log(tsMs); // ej. 1700000000000

// Timestamp en segundos a hora local legible
const date = new Date(tsSec * 1000);
console.log(date.toLocaleString('es-ES'));
// "14/11/2023 23:13:20"

// Timestamp en milisegundos a formato ISO
console.log(new Date(tsMs).toISOString());
// "2023-11-14T22:13:20.000Z"

Manejo de timestamps en Python

python

Uso de los módulos estándar time y datetime de Python para obtener y convertir timestamps, incluido el manejo de zonas horarias.

import time
from datetime import datetime, timezone

# Obtener el timestamp actual en segundos
ts = int(time.time())
print(ts)  # 1700000000

# Timestamp a cadena de hora local
print(time.ctime(ts))
# 'Tue Nov 14 23:13:20 2023'

# Timestamp a hora formateada
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)))
# '2023-11-14 23:13:20'

# Timestamp a hora UTC
print(datetime.fromtimestamp(ts, tz=timezone.utc))
# 2023-11-14 22:13:20+00:00

Operaciones de timestamp en línea de comandos Linux/macOS

bash

Comandos de Shell comunes para obtener timestamps actuales y convertirlos, notando las diferencias entre Linux GNU date y macOS BSD date.

# Obtener el timestamp actual en segundos (funciona en Linux y macOS)
date +%s

# Timestamp a fecha (Linux GNU date)
date -d @1700000000
# "Tue Nov 14 22:13:20 UTC 2023"

# Timestamp a fecha (macOS BSD date)
date -r 1700000000

# Timestamp a fecha UTC (Linux)
date -u -d @1700000000
# "Tue Nov 14 22:13:20 UTC 2023"

# Salida en formato personalizado
date -d @1700000000 '+%Y-%m-%d %H:%M:%S'

Preguntas Frecuentes

¿Qué es un Unix Timestamp?

Un Unix Timestamp (también llamado Epoch Time o POSIX Time) es el número de segundos transcurridos desde el 1 de enero de 1970 a las 00:00:00 UTC (Tiempo Universal Coordinado), sin contar los segundos intercalares. Por ejemplo, 1700000000 corresponde al 2023-11-14 22:13:20 UTC. Es independiente de la zona horaria — el mismo timestamp representa el mismo momento en cualquier parte de la Tierra — lo que lo convierte en el estándar para el registro de tiempo entre sistemas, rastreo de logs, parámetros de API y almacenamiento en bases de datos.

¿Cómo distinguir timestamps de segundos, milisegundos y microsegundos?

Por el número de dígitos: 10 dígitos = segundos (ej. 1700000000), 13 dígitos = milisegundos (ej. 1700000000000), 16 dígitos = microsegundos (ej. 1700000000000000). Esta herramienta detecta automáticamente la unidad según el número de dígitos que pegues — no se necesita selección manual. También elimina espacios automáticamente, así que puedes pegar directamente desde logs.

¿Por qué el timestamp en los logs tiene 8 horas de diferencia con la hora local?

Los timestamps Unix están fundamentalmente basados en UTC. Si tu zona horaria local es UTC+8 (ej. hora estándar de China), convertir un timestamp UTC según las reglas de la zona horaria local mostrará una diferencia de 8 horas. Esta herramienta proporciona un conmutador UTC/Local — usa UTC al leer logs de servidor (la mayoría de servidores usan UTC) y la hora local para timestamps orientados al negocio.

¿Cómo obtener y convertir timestamps en JavaScript?

Obtener el timestamp actual en segundos con `Math.floor(Date.now() / 1000)`, en milisegundos con `Date.now()`; convertir a tiempo legible con `new Date(ts * 1000).toLocaleString()` (multiplica los segundos por 1000, pasa los milisegundos directamente). Se proporcionan fragmentos de código integrados para JavaScript, Python, Go y Bash en la parte inferior de la página para copiar directamente.

¿Pueden los timestamps ser negativos? ¿Qué representan?

Sí. Los timestamps negativos representan fechas anteriores al 1 de enero de 1970. Por ejemplo, -1 corresponde al 1969-12-31 23:59:59 UTC. Esta herramienta admite timestamps negativos y cubre fechas desde 1920 hasta 2100, admitiendo tanto fechas históricas como futuras.

¿Qué es el problema del año 2038? ¿Afectará el uso?

El problema del año 2038 ocurre cuando los sistemas que usan enteros con signo de 32 bits para almacenar timestamps Unix se desbordan después del 19 de enero de 2038 a las 03:14:07 UTC, provocando que las fechas vuelvan a valores negativos. Los sistemas modernos usan enteros de 64 bits (seguros durante ~292 mil millones de años), y JavaScript usa flotantes de 64 bits (seguros hasta el año 285 616 con precisión de milisegundos). Como esta herramienta se ejecuta en tu navegador usando JavaScript, no se ve afectada.

¿Por qué usar un conversor online en lugar de la línea de comandos?

Las herramientas de línea de comandos (como `date` de Linux) requieren memorizar banderas de formato, y los parámetros difieren entre plataformas (Linux GNU date y macOS BSD date tienen banderas diferentes). Esta herramienta funciona instantáneamente en tu navegador, detecta unidades automáticamente, proporciona campos de entrada de fecha visuales (campos separados para año/mes/día/hora/minuto/segundo — sin memorizar formatos de fecha), conmutador de zona horaria y fragmentos de código multilingües integrados.

Glosario

Unix Timestamp
Segundos transcurridos desde 1970-01-01 00:00:00 UTC, 10 dígitos, independiente de zona horaria, globalmente consistente.
Epoch Time
Nombre alternativo para Unix Timestamp, que se refiere al tiempo contado desde el Unix Epoch (1970-01-01 UTC).
Timestamp de segundos
Precisión de 10 dígitos al segundo (ej. 1700000000), por defecto en Unix/Python/C.
Timestamp de milisegundos
Precisión de 13 dígitos a 1/1000 de segundo (ej. 1700000000000), por defecto en JavaScript/Java.
Timestamp de microsegundos
Precisión de 16 dígitos a 1/1.000.000 de segundo (ej. 1700000000000000), usado en sistemas de alta precisión.
UTC
Tiempo Universal Coordinado, el estándar de tiempo global y la línea base para cálculos de zonas horarias, aproximadamente equivalente a GMT.
Desfase de zona horaria
Diferencia entre la hora local y UTC, ej. hora de Europa Central es UTC+1 (o UTC+2 en horario de verano), hora del Este de EE. UU. es UTC-5 (hora estándar).
ISO 8601
Estándar internacional de formato fecha/hora (ej. 2024-01-15T08:30:00+08:00), el estándar para parámetros de API.
Problema del año 2038
Desbordamiento de timestamps de enteros con signo de 32 bits después del 19 de enero de 2038; los sistemas de 64 bits y JavaScript no se ven afectados.

Conversiones comunes de unidades de tiempo

Unidad de tiempoSegundosEjemplo de uso
1 minuto60TTL de caché corto, timeouts de API
1 hora3,600Tokens de corta duración, timeouts de sesión
1 día86,400Estadísticas diarias, informes diarios
1 semana604,800Informes semanales, expiración de cookies
1 mes (30,44 días)2,629,743Facturación mensual, ciclos de suscripción
1 año (365,24 días)31,556,926Datos anuales, tokens JWT de larga duración

Operaciones de timestamp por lenguaje de programación

LenguajeObtener actual (seg.)Timestamp a legible
JavaScriptMath.floor(Date.now()/1000)new Date(ts*1000).toLocaleString()
Pythonimport time; int(time.time())import time; time.ctime(ts)
JavaSystem.currentTimeMillis()/1000new Date(ts*1000L).toString()
Gotime.Now().Unix()time.Unix(ts, 0).String()
PHPtime()date('Y-m-d H:i:s', ts)
MySQLSELECT UNIX_TIMESTAMP()SELECT FROM_UNIXTIME(ts)
Bash (Linux)date +%sdate -d @ts
Bash (macOS)date +%sdate -r ts

Authoritative References