Convertidor de timestamp (UNIX ↔ Fecha)

Convierte segundos/milisegundos epoch a fechas legibles y viceversa. Privado por diseno (100 % del lado del cliente).

Entradas y acciones

El analisis usa el comportamiento predeterminado del navegador; esto solo afecta los resultados mostrados.
Epoch actual: s · ms

Resultado

Resultado:

Conversion por lotes (un valor por linea)

5 curiosidades sobre los timestamps UNIX

El cero es una fecha de nacimiento

Una marca temporal de 0 es el inicio exacto de la epoch Unix: 1970-01-01T00:00:00Z (UTC).

Inicio del epoch

Cuenta los digitos

10 digitos = segundos; 13 digitos = milisegundos. Agrega o quita tres ceros para pasar de una unidad a otra.

Segundos vs ms

Mismo instante, distintos relojes

Las marcas temporales son independientes de la zona horaria. Londres, Nueva York o Tokio muestran horas locales distintas, pero es el mismo instante.

Independiente de huso

El problema de 2038

El 2038-01-19 03:14:07 UTC, los contadores de segundos de 32 bits se desbordan. Los sistemas modernos de 64 bits evitan este problema.

Limite de 32 bits

La "Z" significa Zulu (UTC)

En ISO-8601, la Z final (p. ej., 2025-03-01T10:30:00Z) significa UTC: la misma hora en todas partes.

ISO-8601

Sobre UNIX / tiempo epoch

Una marca temporal UNIX (tambien llamada tiempo epoch) es un numero unico que cuenta cuanto tiempo ha pasado desde la epoch Unix: 1970-01-01T00:00:00Z (UTC). Se usa mucho en logs, bases de datos y APIs porque es compacto, ordenable e independiente de la zona horaria.

Datos rapidos

  • Segundos vs milisegundos vs nanosegundos:
    • 10 digitos → segundos (p. ej., 1700000000)
    • 13 digitos → milisegundos (p. ej., 1700000000000)
    • 16 digitos → microsegundos (p. ej., 1700000000000000)
    • 19 digitos → nanosegundos (comun en sistemas de alta precision)
  • Independiente de zona horaria: el numero representa un instante absoluto; solo cambia su visualizacion segun zona horaria/horario de verano.
  • Valores negativos representan fechas anteriores a 1970-01-01 (p. ej., -31536000 → 1969-01-01T00:00:00Z).
  • Limite Y2038 (segundos de 32 bits): 2147483647 → 2038-01-19T03:14:07Z. Los sistemas modernos usan 64 bits y no sufren este limite.

Ejemplos comunes

SignificadoSegundosMilisegundosUTC (ISO-8601)
Inicio de epoch 0 0 1970-01-01T00:00:00Z
Mil millones de segundos 1000000000 1000000000000 2001-09-09T01:46:40Z
Limite de 2038 (32 bits) 2147483647 2147483647000 2038-01-19T03:14:07Z
Ejemplo de epoca actual 1600000000 1600000000000 2020-09-13T12:26:40Z

Zonas horarias y horario de verano

  • Una marca temporal se almacena en UTC. Al verla en “Europe/London” o “America/New_York”, solo cambia la cadena mostrada.
  • Los cambios de horario de verano no alteran el timestamp base; solo cambian como se muestra la hora local.
  • Para evitar ambiguedades, usa ISO-8601 como 2025-03-01T10:30:00Z o con desplazamiento (p. ej., +01:00).

Consejos de analisis

  • Los navegadores interpretan una fecha sin zona horaria en la zona local del usuario:
    • 2025-03-01 10:30:00 → hora local
    • 2025-03-01T10:30:00Z → UTC (la Z final indica Zulu/UTC)
    • 2025-03-01T10:30:00+05:30 → UTC+5:30
  • Si pegas un numero de 10 digitos (segundos) pero esperas milisegundos, multiplica por 1000.
  • Si pegas un valor de 19 digitos (nanosegundos), divide entre 1,000,000 para obtener milisegundos.

Cuando usar cada unidad?

  • Segundos: muchas APIs de back-end, bases de datos y utilidades de shell.
  • Milisegundos: JavaScript Date, navegadores y la mayor parte del codigo front-end.
  • Nanosegundos: logs/telemetria de alta precision; conviertelos a ms para Date en JS.

Tiempo epoch por lenguaje (recetas rapidas)

Fragmentos listos para copiar y pegar: obtener el epoch actual, convertir una fecha legible → epoch y convertir epoch → fecha.

JavaScript (Browser & Node) 
// current epoch
const s  = Math.floor(Date.now() / 1000); // seconds
const ms = Date.now();                     // milliseconds

// date → epoch
const dt = new Date("2025-03-01T10:30:00Z");
const epochSeconds = Math.floor(dt.getTime() / 1000);

// epoch → date
const d1 = new Date(1700000000 * 1000); // seconds → ms
const d2 = new Date(1700000000000);     // ms
Python 
import time, datetime, calendar

# current epoch
sec = time.time()          # float seconds
ms  = round(time.time()*1000)

# date → epoch (UTC)
dt = datetime.datetime(2025, 3, 1, 10, 30, tzinfo=datetime.timezone.utc)
epoch_seconds = int(dt.timestamp())

# epoch → date (UTC)
dt2 = datetime.datetime.fromtimestamp(1700000000, tz=datetime.timezone.utc)
Java 
import java.time.*;

long sec = Instant.now().getEpochSecond();      // current epoch (s)
long ms  = Instant.now().toEpochMilli();        // current epoch (ms)

// date → epoch
Instant ins = Instant.parse("2025-03-01T10:30:00Z");
long epochSeconds = ins.getEpochSecond();

// epoch → date
Instant ins2 = Instant.ofEpochSecond(1700000000);
ZonedDateTime zdt = ins2.atZone(ZoneId.of("UTC"));
C# (.NET) 
using System;

long sec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
long ms  = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

// date → epoch
var dto = new DateTimeOffset(2025, 3, 1, 10, 30, 0, TimeSpan.Zero);
long epochSeconds = dto.ToUnixTimeSeconds();

// epoch → date
var dto2 = DateTimeOffset.FromUnixTimeSeconds(1700000000); // UTC
Go 
package main
import ("fmt"; "time")

func main() {
  sec := time.Now().Unix()        // seconds
  ms  := time.Now().UnixMilli()   // milliseconds

  // date → epoch (UTC)
  t, _ := time.Parse(time.RFC3339, "2025-03-01T10:30:00Z")
  fmt.Println(t.Unix())

  // epoch → date
  t2 := time.Unix(1700000000, 0).UTC()
  fmt.Println(t2.Format(time.RFC3339))
}
PHP 
// current epoch
$sec = time();                   // seconds
$ms  = round(microtime(true)*1000);

// date → epoch (UTC recommended)
$dt = new DateTime("2025-03-01T10:30:00Z");
$epoch = $dt->getTimestamp();

// epoch → date
$dt2 = (new DateTime())->setTimestamp(1700000000)->setTimezone(new DateTimeZone("UTC"));
echo $dt2->format(DATE_RFC3339);
Ruby 
# current epoch
s  = Time.now.to_i       # seconds
ms = (Time.now.to_f*1000).to_i

# date → epoch (UTC)
t  = Time.utc(2025,3,1,10,30,0)
s2 = t.to_i

# epoch → date
t2 = Time.at(1700000000).utc
Rust 
use std::time::{SystemTime, UNIX_EPOCH, Duration};

// current epoch
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let sec = now.as_secs();
let ms  = now.as_millis();

// epoch → date (example with chrono)
use chrono::{DateTime, Utc, TimeZone};
let d: DateTime<Utc> = Utc.timestamp_opt(1_700_000_000, 0).unwrap();
Kotlin 
import java.time.Instant
import java.time.ZoneId

val sec = Instant.now().epochSecond
val ms  = Instant.now().toEpochMilli()

// date → epoch
val ins = Instant.parse("2025-03-01T10:30:00Z")
val epochSeconds = ins.epochSecond

// epoch → date
val zdt = Instant.ofEpochSecond(1700000000).atZone(ZoneId.of("UTC"))
Swift 
import Foundation

let sec = Int(Date().timeIntervalSince1970)       // seconds
let ms  = Int(Date().timeIntervalSince1970 * 1000)

// date → epoch (ISO8601)
let iso = ISO8601DateFormatter().date(from: "2025-03-01T10:30:00Z")!
let epoch = Int(iso.timeIntervalSince1970)

// epoch → date
let d = Date(timeIntervalSince1970: 1700000000)
C++ (C++11+) 
#include <chrono>
using namespace std::chrono;

// current epoch
auto now  = system_clock::now();
auto sec  = duration_cast<seconds>(now.time_since_epoch()).count();
auto ms   = duration_cast<milliseconds>(now.time_since_epoch()).count();

// epoch → time_point
auto tp = system_clock::time_point{seconds{1700000000}};
Bash / shell Unix 
# current epoch
date +%s                # seconds
python3 - <<'PY'\nimport time; print(round(time.time()*1000))\nPY  # ms fallback

# date → epoch (UTC)
date -u -d "2025-03-01 10:30:00" +%s

# epoch → date (local or -u for UTC)
date -d @1700000000
PowerShell 
# current epoch
$sec = [int][double]::Parse((Get-Date (Get-Date).ToUniversalTime() -UFormat %s))
$ms  = [int]([DateTimeOffset]::UtcNow.ToUnixTimeMilliseconds())

# epoch → date
[DateTimeOffset]::FromUnixTimeSeconds(1700000000).UtcDateTime
PostgreSQL 
-- current epoch (seconds)
SELECT EXTRACT(EPOCH FROM NOW());

-- date → epoch (UTC)
SELECT EXTRACT(EPOCH FROM TIMESTAMP '2025-03-01 10:30:00+00');

-- epoch → timestamp
SELECT TO_TIMESTAMP(1700000000) AT TIME ZONE 'UTC';
MySQL / MariaDB 
-- current epoch
SELECT UNIX_TIMESTAMP();

-- date → epoch (assumes UTC string if suffixed with 'Z')
SELECT UNIX_TIMESTAMP('2025-03-01 10:30:00');

-- epoch → datetime
SELECT FROM_UNIXTIME(1700000000);

Consejo: prefiere cadenas ISO-8601 (p. ej., 2025-03-01T10:30:00Z) para UTC sin ambiguedad. Si una API espera segundos y tienes milisegundos, divide por 1000 (y multiplica para la operacion inversa).

Preguntas frecuentes

Cambia un timestamp UNIX con los husos horarios?

No. El timestamp codifica un instante absoluto; solo cambia su visualizacion segun la zona horaria o el horario de verano.

Segundos vs. milisegundos: cual debo usar?

Los sistemas back-end y muchas API suelen usar segundos; los navegadores y JavaScript normalmente usan milisegundos. Esta herramienta admite ambos.

Puedo copiar resultados en ISO-8601?

Si. Usa la salida UTC para cadenas estilo ISO-8601 como YYYY-MM-DDTHH:mm:ssZ.

Es privado?

Si. Todo se calcula en tu navegador, sin solicitudes de red para las conversiones.

Explora mas herramientas