Convertidor de Marca de Tiempo

¿Qué es un timestamp Unix?

Un timestamp Unix (también llamado epoch time o POSIX time) es el número de segundos transcurridos desde el 1 de enero de 1970, 00:00:00 UTC. Esta fecha se denomina el Unix epoch. Cada segundo que pasa incrementa el contador en uno, lo que le asigna a cada momento en el tiempo una representación entera única. Un conversor de timestamps Unix traduce entre este entero y formatos de fecha legibles como ISO 8601, RFC 2822 o cadenas específicas de cada región.

Los timestamps Unix son el método estándar para representar el tiempo en informática. Las bases de datos almacenan las columnas created_at y updated_at como enteros o timestamps en milisegundos. Las respuestas de API incluyen timestamps para cabeceras de caché (Expires, Last-Modified), claims de JWT (iat, exp, nbf) y registros de eventos. Los archivos de log de nginx, syslog y frameworks de aplicaciones utilizan epoch time. El formato es inequívoco porque siempre representa UTC, sin zona horaria ni desplazamiento de horario de verano que pueda malinterpretarse.

Convertir entre timestamps y fechas a mano es propenso a errores. Un valor como 1711324800 no ofrece ninguna pista visual sobre la fecha que representa. Esta herramienta convierte timestamps Unix a fechas legibles y fechas de vuelta a timestamps. Tanto si estás leyendo un claim exp de JWT, depurando una consulta de base de datos o revisando un timestamp en un log, gestiona automáticamente valores de 10 dígitos (segundos) y 13 dígitos (milisegundos).

¿Por qué usar este conversor de timestamps?

Leer timestamps Unix brutos en logs, bases de datos o respuestas de API requiere memorizar la aritmética del epoch o escribir código desechable. Este conversor lo hace en tu navegador sin ninguna configuración. Tanto si necesitas decodificar una expiración de JWT, auditar una línea de log o establecer un TTL en base de datos, el resultado está a un clic. La herramienta detecta automáticamente si un valor es un timestamp de 10 dígitos en segundos o de 13 dígitos en milisegundos, así que nunca tienes que dividir manualmente entre 1000. Todo el procesamiento se ejecuta localmente en tu navegador. Ningún dato sale de tu máquina, por lo que los timestamps de sistemas internos y logs sensibles permanecen privados.

Casos de uso del conversor de timestamps

Tabla de referencia de timestamps Unix

La tabla a continuación muestra timestamps Unix conocidos y sus fechas correspondientes. Estos valores son útiles para verificaciones rápidas, pruebas y para comprender el rango de timestamps de 32 y 64 bits.

Comparación de formatos de fecha y hora

Distintos sistemas y estándares representan el mismo momento en el tiempo usando diferentes formatos de cadena. La tabla compara los formatos más comunes que encontrarás en APIs, logs y bases de datos.

Ejemplos de código

Convierte entre timestamps Unix y fechas en el lenguaje con el que trabajas. Cada ejemplo muestra ambas direcciones: timestamp a fecha y fecha a timestamp.

// Current Unix timestamp in seconds
Math.floor(Date.now() / 1000)  // → 1711324800

// Unix timestamp to Date object
const date = new Date(1711324800 * 1000)
date.toISOString()             // → "2024-03-25T00:00:00.000Z"
date.toUTCString()             // → "Mon, 25 Mar 2024 00:00:00 GMT"

// Date string to Unix timestamp
Math.floor(new Date('2024-03-25T00:00:00Z').getTime() / 1000)
// → 1711324800

// Millisecond timestamps (common in JS APIs)
Date.now()                     // → 1711324800000 (ms)
Date.parse('2024-03-25')       // → 1711324800000 (ms)

import time
from datetime import datetime, timezone

# Current Unix timestamp
int(time.time())                                    # → 1711324800

# Unix timestamp to datetime
dt = datetime.fromtimestamp(1711324800, tz=timezone.utc)
dt.isoformat()                                      # → '2024-03-25T00:00:00+00:00'
dt.strftime('%Y-%m-%d %H:%M:%S %Z')                 # → '2024-03-25 00:00:00 UTC'

# Datetime string to Unix timestamp
dt = datetime.fromisoformat('2024-03-25T00:00:00+00:00')
int(dt.timestamp())                                  # → 1711324800

# Parse RFC 2822 dates (from email headers)
from email.utils import parsedate_to_datetime
parsedate_to_datetime('Mon, 25 Mar 2024 00:00:00 +0000').timestamp()
# → 1711324800.0

package main

import (
    "fmt"
    "time"
)

func main() {
    // Current Unix timestamp
    now := time.Now().Unix() // → 1711324800

    // Unix timestamp to time.Time
    t := time.Unix(1711324800, 0).UTC()
    fmt.Println(t.Format(time.RFC3339))
    // → 2024-03-25T00:00:00Z

    // Parse a date string to Unix timestamp
    parsed, _ := time.Parse(time.RFC3339, "2024-03-25T00:00:00Z")
    fmt.Println(parsed.Unix())
    // → 1711324800

    // Millisecond timestamp
    ms := time.Now().UnixMilli() // → 1711324800000
    fmt.Println(now, ms)
}

# Current Unix timestamp
date +%s                                    # → 1711324800

# Convert timestamp to human-readable date (GNU date)
date -d @1711324800                         # → Mon Mar 25 00:00:00 UTC 2024

# Convert timestamp to ISO 8601
date -d @1711324800 --iso-8601=seconds      # → 2024-03-25T00:00:00+00:00

# macOS (BSD date) — slightly different flags
date -r 1711324800                          # → Mon Mar 25 00:00:00 UTC 2024

# Date string to timestamp (GNU date)
date -d "2024-03-25 00:00:00 UTC" +%s       # → 1711324800

Preguntas frecuentes