Guía para Desarrolladores sobre el Convertidor de Timestamps de Unix

Un convertidor de marcas de tiempo Unix es una de esas herramientas simples pero indispensables que un desarrollador o analista de datos se encuentra utilizando constantemente. Es una utilidad práctica que traduce un número largo y aparentemente aleatorio en una fecha y hora que realmente podemos entender. Esta traducción es crucial cuando estás revisando registros del sistema, trabajando con APIs o consultando bases de datos donde el tiempo se almacena en este formato super eficiente.

Qué es una Marca de Tiempo Unix y Por Qué Importa

Antes de poder apreciar realmente un buen convertidor, tienes que entender qué es ese número exactamente. En esencia, una marca de tiempo Unix es simplemente un conteo acumulado de segundos. Rastrea el número total de segundos que han pasado desde las 00:00:00 UTC del 1 de enero de 1970. Ese momento específico en el tiempo es conocido popularmente como la "época Unix".

¿Por qué este método? Simplicidad y eficiencia. Almacenar el tiempo como un solo entero es mucho más compacto y eficiente en rendimiento que una cadena verbose como "viernes, 1 de enero de 2021 12:00:00 a.m. GMT". Esto lo hace perfecto para algunas áreas clave:

• Almacenamiento en Base de Datos: Las marcas de tiempo son pequeñas, lo que las hace rápidas de indexar y consultar. Es una gran ganancia para el rendimiento.
• Cargas de Datos de APIs: Enviar un solo número de ida y vuelta es mucho más ligero en ancho de banda que enviar una cadena de fecha completa, lo que lleva a tiempos de respuesta más rápidos.
• Archivos de Registro (Logs): Cuando estás analizando registros de docenas de sistemas diferentes, tener una marca de tiempo uniforme y agnóstica al idioma es un salvavidas.
• Cálculos: ¿Necesitas saber cuánto duró un proceso? Simplemente resta la marca de tiempo de inicio de la de finalización. Es una operación matemática simple con enteros.

Segundos vs. Milisegundos y Más Allá

La marca de tiempo Unix clásica es un número de 10 dígitos que representa segundos. Pero a medida que la tecnología evolucionó, la necesidad de una medición de tiempo más granular creció. Aquí es donde empezarás a ver marcas de tiempo de diferentes longitudes, y es un obstáculo común.

Aquí tienes un desglose rápido de lo que típicamente encontrarás en el mundo real. Confundir una con otra es un error clásico de "error por mil" que puede llevar a algunos errores muy confusos.

Formatos Comunes de Marcas de Tiempo Unix de Un Vistazo

Unidad	Dígitos	Caso de Uso Típico	Valor de Ejemplo (para el mismo momento)
Segundos	10	Estándar para la mayoría de sistemas backend, bases de datos y APIs.	1609459200
Milisegundos	13	Muy común en la tecnología web, especialmente JavaScript.	1609459200000
Microsegundos	16	Utilizado en trading de alta frecuencia o computación científica.	1609459200000000

Tener estos formatos claros es clave. Si una herramienta espera segundos y le alimentas milisegundos, obtendrás una fecha que está a miles de años en el futuro. ¡Es un error que todos hemos cometido en algún momento!

El Famoso Problema del Año 2038

La elegante simplicidad de la marca de tiempo Unix también creó una bomba de tiempo: el "problema del año 2038". En sistemas de 32 bits más antiguos, las marcas de tiempo se almacenaban como un entero con signo de 32 bits. El problema es que este tipo de entero tiene un límite superior; no puede contener un número mayor que 2,147,483,647.

El 19 de enero de 2038, a las 03:14:07 UTC, la cantidad de segundos desde el comienzo superará ese límite. Cuando eso ocurra, el entero "dará la vuelta" y se convertirá en un número negativo. Esto haría que los sistemas vulnerables interpreten la fecha como si estuviéramos en 1901, lo que podría bloquear miles de millones de dispositivos heredados que aún están en uso. Puedes obtener más información sobre el epoch de Unix y su impacto de los expertos en StrongDM.

Afortunadamente, esto no es algo que la mayoría de nosotros necesitemos preocuparnos a diario. La gran mayoría de los sistemas modernos han pasado a utilizar enteros de 64 bits para el registro del tiempo. Un entero de 64 bits es tan masivo que no se desbordará por otros 292 mil millones de años, resolviendo efectivamente el problema de forma permanente.

Sin embargo, es un dato fascinante de la historia de la informática y un conocimiento crucial si alguna vez te encuentras trabajando con sistemas embebidos más antiguos o bases de código heredadas. Comprender estos fundamentos convierte cualquier conversor de marcas de tiempo de Unix en una herramienta mucho más poderosa en tus manos.

Haciendo conversiones sin esfuerzo en tu navegador

Si bien usar un comando de terminal o un fragmento de código funciona, no siempre es la forma más rápida de hacer las cosas. A veces, solo necesitas una respuesta ahora mismo, sin romper tu concentración o cambiar de ventana. Aquí es donde una buena herramienta basada en el navegador demuestra su verdadero valor, especialmente un conversor de marcas de tiempo Unix dedicado que vive directamente dentro de tu navegador.

La verdadera magia aquí se trata de mantener el flujo. Imagina esto: estás revisando una respuesta de una API en las herramientas para desarrolladores de tu navegador y detectas una marca de tiempo. En lugar de abrir otra pestaña o iniciar una terminal, presionas un acceso rápido de teclado, pegas el número y obtienes tu respuesta al instante. Ese es el tipo de flujo de trabajo fluido que obtienes con herramientas como ShiftShift Extensions, que agrupan un montón de utilidades prácticas en una sola Paleta de Comandos.

Obtén respuestas instantáneas con un acceso rápido de teclado

Todo se reduce a la rapidez. Con una herramienta como ShiftShift, un doble toque rápido de la tecla Shift (o Cmd+Shift+P en una Mac) abre una barra de comandos. Solo empieza a escribir "timestamp", y el conversor aparece. Pega tu valor, y tienes una fecha legible para humanos al instante.

Así es como se ve: la Paleta de Comandos está lista y esperando para convertir una marca de tiempo justo sobre tu página actual.

Lo mejor es cómo se integra sin estorbar. El conversor es solo una de las muchas herramientas disponibles en el mismo panel superpuesto, por lo que nunca tienes que salir de lo que estás haciendo.

Este enfoque es un salvavidas para desarrolladores, testers y cualquiera que prácticamente viva en su navegador. Además, la conversión ocurre completamente en tu máquina. Los datos sensibles de registros o respuestas de API nunca salen de tu computadora, lo cual es una gran ventaja para la privacidad.

Poder convertir una marca de tiempo, reformatear un bloque de JSON desordenado y luego calcular una diferencia de tiempo, todo desde la misma interfaz, es un enorme ahorro de tiempo. Convierte un proceso torpe y multitarea en una única acción suave.

Más que solo un caballo de una sola tarea

Una gran utilidad en el navegador rara vez es solo una herramienta individual; es parte de un conjunto de herramientas completo. Te sorprenderás usándote el conversor de marcas de tiempo junto con otras funciones.

Por ejemplo, podrías combinarlo con:

• Un formateador de JSON o SQL para limpiar algo de código antes de extraer la marca de tiempo.
• Una calculadora integrada para realizar cálculos rápidos con valores de epoch. (Puedes experimentar con una herramienta similar en la página de la calculadora de ShiftShift para ver cómo funciona).
• Una herramienta de comparación de texto para detectar diferencias entre dos respuestas de API, incluidas las marcas de tiempo.

Todas estas herramientas esenciales en un solo lugar crean un flujo de trabajo mucho más rápido y cohesivo. No se trata solo de conveniencia, sino de eliminar todas esas pequeñas interrupciones repetitivas que se acumulan y aniquilan tu productividad durante el transcurso de un día.

Conversiones prácticas de marcas de tiempo en código

Si eres desarrollador, sabes que jugar con las marcas de tiempo es solo parte del trabajo. Pero seamos honestos, la sintaxis nunca es exactamente igual de un lenguaje a otro. Esta sección es tu hoja de trucos de referencia, llena de fragmentos de código que puedes copiar y usar de inmediato para las plataformas con las que realmente trabajas. Más vueltas en antiguos hilos de Stack Overflow, solo ejemplos prácticos para hacerte avanzar.

Ya sea que estés trabajando con datos en un frontend web, escribiendo un script de Python o realizando consultas a una base de datos, convertir el tiempo epoch es una habilidad fundamental. Explicaremos los escenarios más comunes, desde convertir un entero epoch en una cadena legible hasta hacer el proceso inverso.

Conversión de marcas de tiempo en JavaScript

El objeto Date de JavaScript es tu herramienta principal aquí, pero tiene una peculiaridad importante que a menudo confunde a los desarrolladores: opera en milisegundos, no en segundos. Esta es una fuente clásica de errores cuando tu frontend se comunica con un backend que utiliza marcas de tiempo estándar de 10 dígitos basadas en segundos.

Para convertir correctamente una marca de tiempo Unix estándar (en segundos) en un objeto Date, debes multiplicarla por 1000.

// A standard 10-digit Unix timestamp (in seconds)
const unixTimestamp = 1672531200;

// Convert to milliseconds, then create a Date object
const dateObject = new Date(unixTimestamp * 1000);

// Format into a readable UTC string
// Output: Sun, 01 Jan 2023 00:00:00 GMT
console.log(dateObject.toUTCString());

¿Necesitas la marca de tiempo actual? Date.now() te la proporciona en milisegundos. Solo recuerda dividir por 1000 y redondear hacia abajo antes de enviar una marca de tiempo estándar de 10 dígitos a una API.

Manejo de conversiones con Python

En el backend, el módulo datetime de Python es muy potente. Es increíblemente flexible y tiene un excelente soporte para conversiones que consideran la zona horaria, lo que lo convierte en una opción fiable para servicios que necesitan manejar el tiempo con precisión en diferentes regiones.

Aquí tienes la forma sencilla de convertir una marca de tiempo con la biblioteca datetime:

import datetime

Una marca de tiempo Unix estándar de 10 dígitos

unix_timestamp = 1672531200

Convierte la marca de tiempo en un objeto datetime

datetime_obj = datetime.datetime.fromtimestamp(unix_timestamp)

Formátala en una cadena limpia y legible por humanos

Salida: 2023-01-01 00:00:00

print(datetime_obj.strftime('%Y-%m-%d %H:%M:%S'))
Este enfoque sencillo te brinda una manera limpia y confiable de gestionar el tiempo epoch en tus aplicaciones Python. Y si estás trabajando con estructuras de datos complejas como JSON que contienen marcas de tiempo, quizás encuentres útil nuestra guía sobre el uso de un formateador JSON para depurar.

Conversiones en bases de datos con SQL

Las bases de datos a menudo almacenan el tiempo como marcas de tiempo Unix porque son eficientes. La buena noticia es que la mayoría de los dialectos SQL tienen funciones incorporadas para manejar estas conversiones directamente dentro de tus consultas. Esto es mucho más eficiente que extraer marcas de tiempo enteras sin formato y convertirlas en el código de tu aplicación.

La marca de tiempo Unix es casi universal, utilizada en más de 90% de los lenguajes de programación, desde el Date.now() de JavaScript hasta el time.time() de Python, impulsando billones de operaciones diarias. Escrucial acertar con las zonas horarias; un sólido convertidor de marcas de tiempo Unix puede manejar más de 400 zonas IANA, lo que ayuda a prevenir errores en un 62% estimado de las aplicaciones globales que no gestionan las zonas horarias explícitamente. Puedes encontrar más detalles sobre la adopción global de estas herramientas en Fossa.

Para los desarrolladores, poder dar formato al SQL, convertir marcas de tiempo y calcular diferencias de tiempo epoch sin salir de su máquina es una gran ganancia de productividad. Este enfoque local también te mantiene en cumplimiento con estándares modernos de privacidad de datos como GDPR y CCPA.

Ejemplo en MySQL

En MySQL, la función FROM_UNIXTIME() es la que usarás con más frecuencia. Toma un entero epoch y lo convierte elegantemente en un formato estándar DATETIME.

SELECT FROM_UNIXTIME(1672531200);
-- Devuelve: '2023-01-01 00:00:00'
Para ir en la dirección contraria, desde una cadena de fecha hasta una marca de tiempo epoch, simplemente utiliza UNIX_TIMESTAMP().

SELECT UNIX_TIMESTAMP('2023-01-01 00:00:00');
-- Retorna: 1672531200

Ejemplo en PostgreSQL

PostgreSQL utiliza una función ligeramente diferente pero igualmente poderosa: to_timestamp(). Esta función convierte directamente un timestamp Unix en un valor TIMESTAMP WITH TIME ZONE .

SELECT to_timestamp(1672531200);
-- Retorna: 2023-01-01 00:00:00+00
Como es consciente de la zona horaria de inmediato, es una opción muy robusta para aplicaciones que sirven a una audiencia global donde la precisión temporal es innegociable.

Dominando las Conversiones de Timestamp en la Terminal

Si vives en la línea de comandos, cambiar a un navegador o interfaz gráfica para una rápida conversión de timestamp es un verdadero asesino de flujo de trabajo. Simplemente rompe tu concentración. La buena noticia es que no tienes que hacerlo; tanto Linux como macOS tienen herramientas nativas poderosas para manejar estas conversiones sin salir nunca de la terminal.

La utilidad estándar para esto es el humilde comando date. Está presente en prácticamente cada sistema tipo Unix, pero hay un detalle: la sintaxis para usarlo como convertidor de timestamp unix es diferente entre Linux (GNU) y macOS (BSD). Conocer la diferencia es clave para acertar cada vez.

Convirtiendo Timestamps en Linux

En Linux, la sintaxis es limpia y fácil de recordar. Solo usas la bandera -d para especificar la fecha, pero debes indicarle que estás proporcionando un timestamp de época prefijándolo con el símbolo @ .

Digamos que estás revisando registros y encuentras el timestamp 1704067200. Para ver qué significa realmente, ejecutarías esto:

date -d @1704067200

Al instante, obtendrás una fecha legible para humanos, algo como Mon Jan 1 00:00:00 UTC 2024. También puedes limpiar esa salida con tu propio formato personalizado.

date -d @1704067200 +"%Y-%m-%d %H:%M:%S"

Salida: 2024-01-01 00:00:00

Consejo Pro: Este comando se convierte en una herramienta poderosa cuando empiezas a dirigir la salida de otros comandos hacia él. Puedes grep un timestamp de un archivo de registro enorme y alimentarlo directamente a date para una conversión instantánea. Convierte una tarea de depuración de múltiples pasos en un único, elegante comando de una sola línea.

Manejando Conversiones en macOS

Ahora, si ejecutas ese mismo comando de Linux en una Mac, te dará un error. La versión BSD de date que usa macOS requiere la bandera -r en su lugar, y no necesita el prefijo @ .

Así es como convertirías el mismo timestamp en una Mac:

date -r 1704067200

Al igual que la versión de Linux, puedes añadir opciones de formato para obtener la salida exacta que deseas.

date -r 1704067200 +"%Y-%m-%d %T %Z"

Salida: 2024-01-01 00:00:00 UTC

Esta pequeña diferencia es un tropiezo clásico para cualquiera que salta frecuentemente entre Linux y macOS. Memorizar ambas versiones te ahorrará muchos dolores de cabeza en el futuro.

Una vez que domines estos comandos, podrás integrar conversiones de timestamp directamente en tus scripts de shell y análisis de registros. Es una habilidad pequeña, pero se acumula en ganancias de productividad serias, manteniéndote en la zona y enfocado en el trabajo que importa.

Errores Comunes con los Timestamps y Cómo Evitarlos

Trabajar con timestamps Unix parece sencillo a primera vista, pero algunos errores clásicos pueden llevar a errores verdaderamente enloquecedores. Estos problemas tienen el molesto hábito de aparecer lejos de donde ocurrió el error real, haciéndolos un verdadero dolor de cabeza para depurar. Piensa en esta sección como tu guía de campo para identificar y evitar las trampas de timestamp más comunes que he visto a lo largo de los años.

La Confusión entre Segundos y Milisegundos

De lejos, el error más frecuente es confundir segundos con milisegundos. Un timestamp Unix estándar es un entero de 10 dígitos que representa el número de segundos desde la época. Pero muchos sistemas, especialmente en el mundo de JavaScript, trabajan con un timestamp de 13 dígitos para milisegundos. Cuando una aplicación de frontend pasa un valor de milisegundos a un backend que espera segundos, las cosas se descontrolan.

Para un unix timestamp convertor, ese número de 13 dígitos parece una fecha miles de años en el futuro. Esto puede arruinar silenciosamente la validación de datos, la lógica de programación y cualquier registro histórico que intente conservar. Es el tipo de corrupción de datos sutil que podría no notar durante semanas.

La Trampa de las Zonas Horarias

Otra trampa que atrapa incluso a desarrolladores experimentados es el manejo de zonas horarias. Por definición, una marca de tiempo Unix siempre está en Tiempo Universal Coordinado (UTC). Representa un momento único y universal en el tiempo, completamente independiente de la ubicación. La trampa se activa cuando olvidas esto y asumes que una marca de tiempo refleja la hora local de un usuario.

Este error suele ocurrir cuando conviertes una marca de tiempo en una fecha legible sin especificar la zona horaria. Tu sistema a menudo usa por defecto la hora local del servidor, lo que genera caos. Un usuario en Nueva York podría ver una hora destinada a alguien en Londres, pero está desfasada varias horas.

La regla de oro es simple: siempre trata las marcas de tiempo como UTC en tu backend. Almacénalas como UTC, procésalas como UTC y solo conviértelas a la hora local del usuario en el frontend, justo en el momento de la visualización.

Solución de Errores Comunes de Conversión de Marca de Tiempo

Cuando las cosas salen mal, los síntomas pueden ser confusos. Aquí hay una tabla de referencia rápida que he preparado con base en la experiencia para ayudar a diagnosticar y corregir los problemas más comunes sobre la marcha.

Síntoma	Causa Probable	Solución
La fecha es en el año 52361 o algún otro futuro lejano.	Milisegundos vs. Segundos. Estás pasando una marca de tiempo de 13 dígitos en milisegundos a una función que espera una marca de tiempo de 10 dígitos en segundos.	Divide la marca de tiempo por 1000 antes de procesarla. Siempre valida el recuento de dígitos de las marcas de tiempo entrantes.
La hora está desfasada unas pocas horas, pero la fecha es correcta.	Gestión Incorrecta de Zona Horaria. La marca de tiempo fue convertida usando la hora local del servidor en lugar de la del usuario o UTC.	Asegúrate de que todas las conversiones especifiquen explícitamente la zona horaria de destino. Convierte a la hora local solo en el lado del cliente.
La fecha está en 1 de enero de 1970.	Marca de Tiempo Inválida o Nula. El valor de la marca de tiempo probablemente es 0, null, o undefined.	Agrega una verificación para asegurar que la marca de tiempo sea un entero positivo válido antes de intentar la conversión. Proporciona un valor de respaldo.
Obtienes "Fecha Inválida" o un error NaN.\n.	Tipo de Dato Incorrecto. La marca de tiempo se está tratando como una cadena u otro tipo no numérico cuando se requiere un número.	Analiza explícitamente la marca de tiempo como un entero (parseInt() en JS, int() en Python) antes de usarla en funciones de fecha.

Recuerda, una rápida verificación en la entrada puede ahorrarte horas de depuración más adelante.

Evitando Ambigüedad con Formatos Estándar

Depender de marcas de tiempo enteras sin procesar al pasar datos entre sistemas puede ser una receta para la confusión. Es por eso que estandarizar en un formato de cadena universal como ISO 8601 (2022-05-17T12:00:00Z) es una gran jugada defensiva. Convertir marcas de tiempo Unix (por ejemplo, 1652905200) a un formato claro y autoexplicativo como este ayuda a prevenir errores en un 37% estimado de llamadas API entre zonas horarias.

Considerando que 72% de las empresas de la lista Fortune 500 usan marcas de tiempo Unix para análisis de registros, donde un simple error puede costar más de $10,000 por hora en tiempo de inactividad, la precisión lo es todo. Puedes leer más sobre cómo se usa el tiempo epoch en diferentes industrias en EpochConverter.

Para quienes administran bases de datos, el manejo consistente de las marcas de tiempo es igual de crítico. Si te encuentras luchando frecuentemente con diferentes formatos de marcas de tiempo en tu base de datos, nuestra guía sobre el uso de un potente formateador SQL puede ayudarte a mantener tus consultas limpias y predecibles.

Este árbol de decisiones te ayuda a elegir el comando adecuado para tu sistema operativo, previniendo errores de sintaxis cuando necesitas una conversión rápida.

El diagrama de flujo anterior muestra claramente la diferencia de sintaxis crucial entre el comando date en Linux (-d @...) y macOS (-r ...)—una trampa común para los desarrolladores que trabajan en diferentes entornos.

Para proteger su código, siempre implemente verificaciones para validar la longitud de una marca de tiempo entrante. Una función simple que compruebe si es un valor de 10 dígitos (segundos) o 13 dígitos (milisegundos) puede detectar estos errores antes de que contaminen la lógica de su aplicación'.

Preguntas Comunes Sobre las Marcas de Tiempo Unix

Una vez que domines las marcas de tiempo Unix, casi siempre surgen algunas preguntas prácticas. He visto que estos aspectos hacen tropezar a desarrolladores de todos los niveles, así que aclaremos las más comunes que encontrarás en tu trabajo diario.

¿Por Qué Tantas APIs Usan Marcas de Tiempo en Lugar de Cadenas ISO 8601?

Realmente se reduce a la eficiencia pura. Una marca de tiempo Unix es solo un número único, lo que la hace increíblemente compacta en comparación con una cadena como '2023-10-27T10:00:00Z'. Ese tamaño más pequeño significa menos datos que enviar por la red, lo que ahorra ancho de banda y puede acelerar las respuestas de la API.

También son completamente agnósticas al lenguaje. No hay ambigüedad, no hay peculiaridades de análisis y no hay formateo regional de qué preocuparse. Para una máquina, procesar números siempre es más rápido que analizar cadenas, por lo que cualquier cálculo de fecha—como determinar el tiempo entre dos eventos—es computacionalmente menos costoso. Para los sistemas de alto rendimiento, esa simplicidad es una gran ventaja.

¿Cuál es la Forma Correcta de Manejar las Zonas Horarias?

Esta es la gran pregunta. Aquí está la regla de oro: Una marca de tiempo Unix siempre, siempre está en UTC. No tiene ningún concepto de zona horaria incorporado. Es simplemente un conteo crudo de segundos desde la época.

Las zonas horarias solo importan cuando necesitas mostrar esa marca de tiempo a un ser humano.

¿Mi consejo? Mantente en UTC para todo en el backend. Almacénala en tu base de datos como una marca de tiempo UTC, pásala por tus APIs en UTC y realiza toda tu lógica del lado del servidor en UTC. La única vez que deberías convertirla a una zona horaria local es en el front-end, justo antes de mostrarla al usuario. Esta práctica única te salvará de todo un universo de errores de zona horaria y horario de verano.

¿Debería Preocuparme por el Problema del Año 2038?

Para la mayoría de los proyectos nuevos, probablemente no. El "Problema del Año 2038" es un legado de sistemas más antiguos que usaban un entero con signo de 32 bits para almacenar la marca de tiempo. Una vez que ese número se vuelve demasiado grande, rebota y se vuelve negativo, enviando las fechas de vuelta a 1901.

Afortunadamente, casi todos los sistemas modernos—desde sistemas operativos hasta bases de datos—han migrado hace mucho a enteros de 64 bits. Esto empuja efectivamente el problema tan lejos en el camino (miles de millones de años, de hecho) que ya no es una preocupación práctica para nosotros.

Dicho esto, si estás manteniendo un sistema heredado o trabajando con hardware embebido (piensa en dispositivos IoT), definitivamente es algo de lo que debes ser consciente. Siempre sabe en qué tipo de arquitectura estás construyendo.

¿Cómo Puedo Convertir Rápidamente una Marca de Tiempo en Excel o Google Sheets?

No necesitas sacar tus datos a un convertidor de marcas de tiempo Unix separado para esto. Una fórmula simple hará el trabajo. Asumiendo que tu marca de tiempo está en la celda A1:

• Para marcas de tiempo en segundos (10 dígitos): =A1 / 86400 + DATE(1970,1,1)
• Para marcas de tiempo en milisegundos (13 dígitos): =A1 / 86400000 + DATE(1970,1,1)

Solo ingresa esa fórmula y luego formatea la celda como "Fecha" u "Fecha y Hora". Es un salvavidas cuando estás analizando rápidamente exportaciones de datos y no quieres romper tu flujo.

---

¿Cansado de cambiar constantemente entre tu editor, la línea de comando y una docena de pestañas del navegador para tareas simples? La suite de ShiftShift Extensions incluye un potente convertidor de marcas de tiempo Unix, un formateador de JSON, un embellecedor de SQL y mucho más directamente en tu navegador. Todo lo que necesitas está a solo un atajo de teclado de distancia.

Obtén ShiftShift Extensions y simplifica tu flujo de trabajo hoy en https://shiftshift.app