Generador y constructor de comandos cURL
Construye comandos curl en tu navegador: define método, cabeceras, autenticación y cuerpo, y obtén el comando listo para copiar al instante. Presets para Bearer, POST JSON y subida de archivos. Gratis, privado, sin registro.
¿Qué es un comando curl?
curl es una herramienta de línea de comandos para transferir datos a través de HTTP y docenas de otros protocolos. Un comando curl es el nombre del binario, un conjunto de indicadores y una URL — por ejemplo `curl -X POST https://api.example.com/users -H 'Content-Type: application/json' -d '{"name":"Ada"}'`. Como curl viene instalado en prácticamente cualquier sistema Linux, macOS y Windows moderno, es la forma universal de probar una API, reproducir una petición desde la documentación o comprobar el estado de un servicio desde un script de CI. La concisión que lo hace poderoso también hace difícil recordarlo, que es exactamente por qué un constructor visual ayuda.
Todo comando curl tiene la misma anatomía. El método (`-X GET`, `-X POST`, …) establece el verbo HTTP y usa GET por defecto. La URL es el endpoint, con los parámetros de consulta añadidos después de `?`. Las cabeceras (`-H 'Clave: Valor'`, repetibles) llevan metadatos como `Accept` y `Content-Type`. La autenticación es simplemente una cabecera especial — `-H 'Authorization: Bearer …'` para un token, `-u usuario:contraseña` para autenticación Basic o una `-H 'X-API-Key: …'` personalizada. El cuerpo (`-d` para datos sin formato o de formulario, `-F` para multipart y subidas de archivos) lleva el payload. Por último, los indicadores de opción como `-L` (seguir redirecciones), `-i` (incluir cabeceras de respuesta) y `-v` (verbose) modulan el comportamiento. Esta herramienta presenta cada una de esas partes como un campo de formulario y reconstruye el comando en tiempo real.
Recurre a un generador de comandos curl cuando de otro modo estarías luchando con el entrecomillado, olvidando la cabecera `Content-Type` en un POST JSON, o ensamblando manualmente una subida multipart. El constructor resuelve el entrecomillado seguro para el shell con comillas simples, codifica tu cadena de consulta y adjunta las cabeceras correctas para cada tipo de cuerpo — y entonces copias un comando en el que puedes confiar. Para una referencia exhaustiva indicador por indicador con más de 40 ejemplos ejecutables, lee la hoja de referencia de curl; para codificar valores de cadena de consulta complicados puedes usar nuestro codificador de URL.
Todo ocurre en tu navegador. Tus tokens, credenciales, URL y cuerpos de petición se ensamblan con JavaScript del lado del cliente y nunca se envían a ningún lugar — así que puedes construir comandos contra endpoints de producción reales con claves de API reales y nada abandona tu dispositivo.
# Plain GET — curl defaults to GET
curl https://api.example.com/users
# GET with a Bearer token (auth is just a header)
curl https://api.example.com/me \
-H 'Authorization: Bearer YOUR_TOKEN'
# POST a JSON body — note the Content-Type header
curl -X POST https://api.example.com/users \
-H 'Content-Type: application/json' \
-d '{"name":"Ada","role":"admin"}'
# Multipart file upload — '@' reads the file from disk
curl -X POST https://api.example.com/upload \
-F 'file=@report.pdf' \
-F 'title=Q3 report' Características principales
Constructor visual de peticiones
Presenta toda la petición como campos de formulario — método, URL, parámetros de consulta, cabeceras, autenticación, cuerpo y opciones — en lugar de tener que memorizar el orden de los indicadores y el entrecomillado. Sin más dudas sobre si la URL va antes o después del `-d`.
Comando en tiempo real con Copiar y Exportar
El comando curl se reconstruye con cada pulsación de tecla al pie de la página. Cópialo al portapapeles con un solo clic, o usa Exportar .sh para descargar un script de shell ejecutable que puedes añadir directamente a un repositorio o a un trabajo de CI.
Soporte completo de autenticación
Token Bearer, autenticación Basic (`-u usuario:contraseña`) y cabeceras personalizadas de API-key, emitidas cada una en el formato exacto que esperan los servidores. Elige el esquema, pega la credencial y se genera la cabecera `Authorization` o personalizada correcta.
Todos los tipos de cuerpo
JSON sin formato (con la cabecera `Content-Type` correspondiente añadida automáticamente), campos de formulario `application/x-www-form-urlencoded` y subidas `multipart/form-data` donde cualquier campo puede convertirse en archivo con el prefijo `@`.
Seis presets con un solo clic
GET con Bearer, POST JSON, Subida de formulario, Autenticación básica, Descarga `-o` y Depuración verbose rellenan todo el formulario con un toque. Comienza desde una petición funcional para las tareas de API más habituales y ajústala desde ahí.
Salida multilínea y en una sola línea
Alterna entre un comando compacto en una sola línea para pegado rápido y una versión multilínea con continuaciones de barra invertida, fácil de leer en un script o revisar en un pull request. El mismo comando, dos formatos.
Privacidad 100% basada en el navegador
Los tokens, URL, cabeceras y cuerpos de petición se ensamblan íntegramente en el lado del cliente y nunca abandonan tu dispositivo — verifícalo en la pestaña Red. Seguro para endpoints de producción y credenciales reales con cero exposición de datos.
Diseñado para el flujo de trabajo con DevTools
Pensado para el ciclo diario de probar API y reproducir peticiones desde la opción «Copiar como cURL» de DevTools del navegador. Una pestaña Convertir que analiza un comando curl pegado y lo transforma en fetch, requests, Go, PHP, Ruby y Node.js se lanzará en la próxima versión.
Alternativas a curl y clientes HTTP
HTTPie
CLI, sintaxis amigable para humanosUna CLI moderna con salida en color y una sintaxis más concisa (`http POST api.example.com/users name=Ada`). Establece `Content-Type` JSON por defecto. Más amigable para uso interactivo; curl gana en ubicuidad y portabilidad para scripts.
wget
CLI, orientado a descargasIdeal para descargas recursivas y mirroring de sitios; sigue redirecciones y reintenta por defecto. Más débil que curl para métodos arbitrarios, cabeceras personalizadas y pruebas de API. A menudo viene preinstalado junto con curl en Linux.
Postman
Aplicación GUIUna interfaz gráfica completa para construir, guardar y compartir peticiones con colecciones, entornos y sincronización en equipo. Ideal para exploración de API; puede importar/exportar curl. Más pesado que un comando de una línea para comprobaciones rápidas o CI.
Insomnia
Aplicación GUIUna alternativa de código abierto más ligera a Postman con un constructor de peticiones limpio e importación/exportación de curl. Útil para organizar peticiones de API; como Postman, es más de lo que necesitas para una llamada scripted puntual.
fetch() / requests
Clientes HTTP en códigoJavaScript `fetch()` y Python `requests` son la forma de hacer la llamada desde el código de la aplicación. Construye y verifica la petición como curl primero, luego tradúcela — la próxima pestaña Convertir generará el equivalente en fetch, requests y otros clientes.
Ejemplos de comandos curl
Petición GET simple
curl https://api.example.com/users
Sin indicador de método, curl usa GET por defecto. Es la petición más sencilla posible: obtiene un recurso e imprime el cuerpo de la respuesta en tu terminal. Añade parámetros de consulta en el constructor y se codifican automáticamente al final de la URL (`?page=2&limit=50`).
GET con token Bearer
curl https://api.example.com/me \ -H 'Authorization: Bearer YOUR_TOKEN'
La llamada autenticada más habitual contra una REST API. El preset de autenticación Bearer añade la cabecera `Authorization: Bearer …` por ti. Para inspeccionar el contenido de un JWT antes de enviarlo, pega el token en nuestro decodificador JWT.
POST con cuerpo JSON
curl -X POST https://api.example.com/users \
-H 'Content-Type: application/json' \
-d '{"name":"Ada","role":"admin"}' El elemento fundamental del generador de peticiones curl POST: el tipo de cuerpo JSON establece `-X POST`, adjunta la cabecera `Content-Type: application/json` y envía el payload con `-d`. Formatea las respuestas de la API con nuestro formateador JSON.
POST con formulario (urlencoded)
curl -X POST https://api.example.com/login \ -H 'Content-Type: application/x-www-form-urlencoded' \ -d 'username=ada&password=s3cret'
Envío clásico de formulario HTML. Cada par `-d campo=valor` se une con `&` y se envía como `application/x-www-form-urlencoded`. curl codifica en URL los caracteres reservados; construye los campos en la sección de cuerpo del formulario y la herramienta ensambla la cadena por ti.
Subida de archivo multipart
curl -X POST https://api.example.com/upload \ -F 'file=@report.pdf' \ -F 'title=Q3 report'
El comando de subida de archivos con curl usa `-F` para `multipart/form-data`. Añade el prefijo `@` a un valor para adjuntar un archivo del disco; mezcla campos de archivo y de texto libremente. curl establece el límite multipart y el `Content-Type` automáticamente — nunca lo configures manualmente.
Descarga a un archivo
curl -L -o archive.zip \ https://example.com/files/archive.zip
Guarda el cuerpo de la respuesta en un archivo con nombre usando `-o`, y `-L` sigue las redirecciones hacia la URL real de descarga (habitual en CDN y enlaces de activos de versiones). Usa `-O` en lugar de `-o` para conservar el nombre de archivo del servidor.
Autenticación básica
curl -u ada:s3cret \ https://api.example.com/private
La autenticación básica de curl usa `-u usuario:contraseña`; curl codifica las credenciales en Base64 en una cabecera `Authorization: Basic …` al transmitirlas. Envía siempre la autenticación básica sobre HTTPS — Base64 es codificación, no cifrado, y es trivialmente reversible.
Depuración verbose
curl -v -i https://api.example.com/health
Cuando una petición falla, `-v` imprime la línea de petición completa, cada cabecera enviada y recibida, y el apretón de manos TLS; `-i` incluye las cabeceras de respuesta en la salida del cuerpo. El primer recurso cuando una API devuelve el código de estado incorrecto.
Cómo construir un comando curl
- 1
Elige el método HTTP
Selecciona GET, POST, PUT, PATCH, DELETE, HEAD u OPTIONS. curl usa GET por defecto; elegir POST u otro verbo añade `-X MÉTODO` al comando generado. O pulsa un preset para establecer el método y un cuerpo compatible con un solo clic.
- 2
Introduce la URL y los parámetros de consulta
Escribe la URL de la petición (p. ej. `https://api.example.com/users`). Añade parámetros de consulta como pares clave/valor y la herramienta los codifica en URL y añade `?clave=valor&…` a la URL automáticamente — no es necesaria ninguna codificación manual.
- 3
Añade cabeceras y autenticación
Añade cabeceras de petición como pares clave/valor y luego elige un esquema de autenticación: Ninguna, token Bearer, Basic (usuario/contraseña) o una cabecera personalizada de API-key. Se genera la cabecera `Authorization` o personalizada correcta en el formato exacto que espera el servidor.
- 4
Configura el cuerpo de la petición
Para POST/PUT/PATCH, elige un tipo de cuerpo: pega JSON sin formato (la cabecera `Content-Type` se añade por ti), construye campos de formulario urlencoded, o ensambla una subida multipart y convierte cualquier campo en archivo con el prefijo `@`.
- 5
Activa las opciones
Activa los indicadores que necesites — seguir redirecciones (`-L`), TLS inseguro (`-k`), verbose (`-v`), incluir cabeceras (`-i`), comprimido (`--compressed`), salida a archivo (`-o`), tiempo de espera de conexión o proxy (`-x`). Cada activación actualiza el comando en tiempo real.
- 6
Copia, exporta o restablece
Copia el comando terminado, usa Exportar .sh para descargarlo como script, o Restablecer para limpiar el formulario. Usa el interruptor Multilínea para alternar entre salida en una sola línea y con continuaciones de barra invertida antes de copiar.
Errores comunes en curl
Falta -X con un método que tiene cuerpo
Enviar un cuerpo con `-d` implica POST, pero si necesitas PUT o PATCH debes indicarlo explícitamente con `-X`. Olvidarlo envía el cuerpo como POST y el servidor devuelve el estado incorrecto o rechaza la petición.
# Intentaba un PATCH, pero -d solo implica POST
curl -d '{"role":"admin"}' \
https://api.example.com/users/7 # Establece el verbo explícitamente
curl -X PATCH -d '{"role":"admin"}' \
-H 'Content-Type: application/json' \
https://api.example.com/users/7 Falta Content-Type en un POST JSON
Enviar JSON con `-d` NO establece la cabecera `Content-Type` — curl usa `application/x-www-form-urlencoded` por defecto. La mayoría de las API entonces no pueden analizar el cuerpo y devuelven un 400 o 415. Adjunta siempre el tipo de contenido JSON (o usa el preset de cuerpo JSON, que lo añade por ti).
# El servidor recibe urlencoded, no JSON — 400/415
curl -X POST https://api.example.com/users \
-d '{"name":"Ada"}' # Declara el tipo de contenido JSON
curl -X POST https://api.example.com/users \
-H 'Content-Type: application/json' \
-d '{"name":"Ada"}' Escape con comillas simples vs dobles
Dentro de las comillas dobles el shell expande `$`, comillas inversas y `!`, distorsionando el JSON o fallando con una `$variable` dentro del payload. Las comillas simples pasan el cuerpo literalmente. Usa comillas simples para los cuerpos JSON; cambia a comillas dobles solo en `cmd.exe`, que no respeta las comillas simples.
# $name es expandido por el shell a cadena vacía
curl -d "{\"user\":\"$name\"}" \
https://api.example.com/users # Las comillas simples envían el cuerpo literalmente
curl -d '{"user":"$name"}' \
https://api.example.com/users Usar -d en una petición GET
Añadir `-d` a una petición la convierte silenciosamente en POST. Si querías un GET con parámetros de consulta, ponlos en la URL (o usa `-G` para añadir los datos de `-d` a la cadena de consulta). Un `-d` en un GET es una de las razones más comunes de «mi GET no funciona».
# -d convierte esto en POST, no en GET curl -d 'page=2&limit=50' \ https://api.example.com/users
# La cadena de consulta en la URL lo mantiene como GET curl 'https://api.example.com/users?page=2&limit=50'
Continuación de línea en Windows: ^ vs \
La barra invertida (`\`) continúa un comando en la siguiente línea en bash, Git Bash y WSL. En `cmd.exe` el carácter de continuación es el acento circunflejo (`^`), y PowerShell usa una comilla invertida (`` ` ``). Pegar un comando con continuación de barra invertida en `cmd` lo rompe — cambia esta herramienta a salida en una sola línea para `cmd` de Windows.
:: cmd.exe — la barra invertida no es carácter de continuación
curl -X POST https://api.example.com/users \
-d '{"name":"Ada"}' :: cmd.exe — una línea, o usa ^ para continuar
curl -X POST https://api.example.com/users -d "{\"name\":\"Ada\"}" Espacios en la URL sin codificar
Un espacio en bruto (o `&`, `#`, `?`) en una URL o valor de consulta rompe el comando — el shell divide el argumento y curl ve una URL truncada. Codifica en porcentaje el valor (un espacio se convierte en `%20`) o deja que curl lo codifique con `--data-urlencode`. Los campos de parámetros de consulta de esta herramienta codifican automáticamente.
# El espacio divide el argumento — curl ve dos args curl https://api.example.com/search?q=hello world
# Codifica el espacio (o entrecomilla toda la URL) curl 'https://api.example.com/search?q=hello%20world'
Casos de uso habituales
- Prueba de REST API
- Construye y envía peticiones contra un endpoint REST sin salir de la terminal: establece el método, pega un token Bearer, envía un cuerpo JSON y lee la respuesta. La forma más rápida de confirmar que una API funciona antes de escribir el código del cliente.
- Reproducir una petición desde la documentación
- La documentación de la API muestra endpoints y parámetros, pero rara vez un comando completo listo para copiar. Rellena el método, la URL, las cabeceras y la autenticación aquí y obtén un comando curl que funciona tal cual — sin luchar con el entrecomillado ni cabeceras `Content-Type` faltantes.
- Scripts de prueba de humo en CI/CD
- Genera un comando curl para una comprobación de estado o una prueba de humo post-despliegue, luego usa Exportar .sh para añadirlo a un pipeline. Añade `--connect-timeout` y `--max-time` para que un endpoint colgado no pueda bloquear la compilación, y comprueba los códigos de estado con `-w`.
- Subida y descarga de archivos
- Ensambla una subida `multipart/form-data` con `-F campo=@archivo`, o construye una descarga con `-L -o nombre_de_archivo` que sigue las redirecciones hacia un CDN. Codifica primero los nombres de archivo o valores de consulta complicados con nuestro codificador de URL.
- Depuración de webhooks
- Reproduce un payload de webhook enviando el mismo cuerpo JSON que el proveedor envía, con las cabeceras de firma y `Content-Type` correctas. Reproduce la petición exacta localmente para depurar por qué tu manejador la rechazó.
- Informes de errores reproducibles
- Pega un único comando curl autocontenido en un informe de error o PR para que cualquiera pueda reproducir la petición exacta — método, cabeceras, marcador de autenticación y cuerpo. Mucho más claro que describir la petición en prosa.
- Aprender los indicadores de curl
- Ve cómo cada elección del formulario se corresponde con un indicador real — elige autenticación Basic y observa cómo aparece `-u`, añade un cuerpo JSON y ve cómo se adjunta la cabecera `Content-Type`. Una forma práctica de aprender la sintaxis, combinada con nuestra hoja de referencia de curl.
- Preparar una petición para convertir a código
- Construye y verifica la petición como curl primero, luego tradúcela al cliente HTTP de tu aplicación. La próxima pestaña Convertir transformará un comando curl pegado en fetch, requests, Go, PHP, Ruby y Node.js — comienza desde un comando curl que sabes que funciona.
Referencia de indicadores y sintaxis de curl
- Entrecomillado y escape del shell
- La herramienta envuelve los valores entre comillas simples, la forma más segura en shells POSIX porque nada dentro de una cadena entre comillas simples se expande. Una comilla simple literal dentro de un valor se emite como la secuencia `'\''` (cierra comilla, comilla escapada, reabre comilla). En `cmd.exe` cambia a comillas dobles; Git Bash y WSL ejecutan los comandos con comillas simples generados sin cambios.
- -d vs --data-raw vs --data-binary
- `-d`/`--data` elimina los saltos de línea y retornos de carro del cuerpo — válido para pares `clave=valor`, con pérdida para contenido multilínea. `--data-raw` es lo mismo pero no tratará un `@` inicial como nombre de archivo. `--data-binary` envía los bytes exactamente como se proporcionan (usa `@archivo` para subir contenidos de archivo brutos). Los tres implican POST salvo que se anule el método.
- Multipart (-F) vs urlencoded (-d)
- `-F campo=valor` produce `multipart/form-data` con un límite generado — necesario para subidas de archivos (`-F archivo=@ruta`) y formularios mixtos de archivos y texto. `-d campo=valor` produce `application/x-www-form-urlencoded`, una cadena única unida por `&`. Nunca establezcas `Content-Type` manualmente para multipart; curl calcula el límite y establece la cabecera por sí mismo.
- Codificación de la cabecera de autenticación
- La autenticación Bearer envía `Authorization: Bearer
` literalmente (RFC 6750). La autenticación Basic de `-u usuario:contraseña` se codifica en Base64 como `Authorization: Basic ` al transmitirla — es codificación, no cifrado, así que usa HTTPS. Una API key es cualquier cabecera personalizada que requiera el servicio, p. ej. `X-API-Key: `. - Codificación de la cadena de consulta
- Los parámetros de consulta añadidos en el constructor se codifican en porcentaje y se añaden como `?clave=valor&clave2=valor2`. Los caracteres reservados (espacios, `&`, `=`, `#`) se escapan para que la URL sea válida. Para los campos del cuerpo que deban codificarse, el propio `--data-urlencode` de curl gestiona la codificación en el momento de la petición.
- Comportamiento de las redirecciones (-L)
- Sin `-L`, curl imprime una respuesta 301/302 y se detiene. Con `-L` sigue la cabecera `Location` hasta la URL final. Ten en cuenta que curl elimina la cabecera `Authorization` cuando una redirección cruza a un host diferente (un comportamiento de seguridad por defecto); usa `--location-trusted` solo cuando entiendas las implicaciones.
- Respuestas comprimidas
- `--compressed` añade una cabecera `Accept-Encoding` que anuncia compatibilidad con gzip/deflate/brotli y descomprime la respuesta de forma transparente, ahorrando ancho de banda. El cuerpo descodificado es idéntico al de una petición sin comprimir — es puramente una optimización de la transferencia, seguro de activar en la mayoría de llamadas a la API.
- Salida: -o vs -O
- `-o nombre_de_archivo` escribe el cuerpo de la respuesta en un archivo que tú nombras; `-O` lo guarda con el nombre de archivo remoto de la ruta de la URL. Ambos suprimen el volcado normal por stdout. Combínalos con `-L` para que las redirecciones se resuelvan al activo real antes de escribir el archivo.
Buenas prácticas para peticiones curl
- Nunca codifiques secretos en comandos compartidos
- Un comando curl que pegas en un PR, un ticket o un chat será leído por otros e indexado por herramientas. Reemplaza los tokens y contraseñas por un marcador (`YOUR_TOKEN`) o referencia una variable de entorno (`-H "Authorization: Bearer $API_TOKEN"`). Para credenciales largas, curl puede leer una cabecera de un archivo con `-H @archivocabecera` para que el secreto nunca aparezca en el historial del shell.
- Prefiere --data-binary @archivo para payloads binarios
- Cuando el cuerpo es un archivo cuyos bytes importan — una imagen, un payload firmado, JSON donde el espacio en blanco es significativo — usa `--data-binary @archivo` en lugar de `-d @archivo`. El `-d` simple elimina los saltos de línea y retornos de carro, corrompiendo silenciosamente el contenido binario y multilínea. `--data-binary` envía el archivo exactamente como está en el disco.
- Entrecomilla los valores de las cabeceras
- Envuelve siempre los valores de `-H` entre comillas: `-H 'Content-Type: application/json'`. Sin entrecomillar, el espacio después de los dos puntos divide el argumento y curl ve una cabecera malformada. Las comillas simples también evitan que el shell expanda `$`, `*` y otros caracteres especiales dentro del valor — exactamente lo que esta herramienta emite por defecto.
- Usa --compressed para ahorrar ancho de banda
- Añade `--compressed` en llamadas a la API y descargas para solicitar codificación gzip/brotli y que curl descomprima de forma transparente. Para las API con mucho JSON, esto puede reducir el tamaño de la transferencia en un 70-90% sin ningún cambio en la respuesta que ves — una mejora gratuita en scripts que sondean endpoints repetidamente.
- Fija los tiempos de espera en los scripts
- En cualquier contexto automatizado, añade `--connect-timeout` y `--max-time` para que un endpoint lento o colgado no pueda bloquear un pipeline indefinidamente. Una comprobación de estado con `--max-time 10` falla rápido y permite que tu CI continúe. Combínalo con `--retry N` para absorber fallos de red transitorios sin rendirse de inmediato.
- Verifica con -v antes de automatizar
- Antes de incluir un comando curl en un script o trabajo cron, ejecútalo una vez con `-v` para ver la línea de petición exacta, las cabeceras y el apretón de manos TLS. Es la forma más rápida de detectar un método incorrecto, un `Content-Type` faltante o una cabecera de autenticación que no se adjuntó — depura interactivamente y luego elimina `-v` para producción.
Preguntas frecuentes
¿Qué hace esta herramienta?
¿Se suben mis datos (tokens, URL) a algún servidor?
¿Cómo envío una petición POST con JSON en curl?
¿Cómo añado un token Bearer a una petición curl?
¿Cómo subo un archivo con curl?
¿Puedo importar un comando copiado desde DevTools del navegador («Copiar como cURL»)?
¿En qué se diferencia curl en Windows?
¿Cuál es la diferencia entre -d, --data-raw y --data-binary?
¿Cómo envío cookies con curl?
¿Cómo sigo las redirecciones?
¿Cómo establezco un tiempo de espera para una petición?
Herramientas relacionadas
Ver todas las herramientas →Conversor de Bases — Binario, Hex, Decimal, Octal
Herramientas de Conversión
Convierte números entre binario, hexadecimal, decimal, octal y cualquier base personalizada (2-36) al instante. Gratis, privado, sin registro — todo el procesamiento ocurre en tu navegador.
Decodificador y Codificador Base64
Codificación y Formato
Decodifica y codifica Base64 online de forma gratuita. Conversión en tiempo real con soporte completo de UTF-8 y emojis. 100% privado — funciona en tu navegador. Sin registro.
Convertidor de Mayúsculas, Minúsculas, camelCase y Más
Procesamiento de Texto
Convierte texto entre UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE y 6 formatos más al instante. Gratis, en el navegador, sin registro.
Convertidor de Color — HEX, RGB, HSL y OKLCH
Herramientas de Conversión
Convierta HEX a RGB, HSL, OKLCH, OKLAB y CMYK en su navegador — copie cualquier formato con un clic. Gratis, sin registro, sus colores nunca salen de la página.
Generador Crontab y Constructor de Expresiones Cron
Fecha y Hora
Construye, valida y decodifica expresiones cron en el navegador. Vista previa de próximas ejecuciones en hora local o UTC. POSIX 5 campos, presets y descripción natural. Gratis y privado.
Convertidor de CSV a JSON
Codificación y Formato
Convierte CSV a JSON en tu navegador. RFC 4180, inferencia de tipos, fila de cabecera, seguro para big-int. 100% privado, sin carga.