Mejores Herramientas CLI Ligeras para Mocking de API

Necesitas una API falsa para desarrollar y la necesitas en los próximos treinta segundos. No un servicio alojado, no una pila de Docker Compose, no una interfaz gráfica de usuario para hacer clic. Solo un comando que lea un archivo y comience a servir respuestas en localhost.

Eso es lo que hace un servidor mock ligero. Lo apuntas a una especificación OpenAPI o a un pequeño archivo de datos, ejecutas un comando y obtienes puntos finales realistas que tu frontend o tus pruebas pueden usar mientras el backend real aún se está construyendo. Los mejores se envían como un solo binario o un paquete `npx`-able, se inician en menos de un segundo y casi no necesitan configuración. Algunas de las opciones más pesadas aquí se ejecutan en la JVM y hacen mucho más; se ganan su lugar cuando necesitas una coincidencia de solicitudes avanzada o un comportamiento con estado.

Esta guía clasifica seis simuladores CLI por lo poco que te exigen. Comienza con los que puedes ejecutar sin instalar nada, luego cubre los servidores JVM independientes y cierra con la ruta integrada a través de la CLI de Apidog. Cada comando de instalación y comando mock a continuación se verificó con la documentación oficial de cada herramienta. Si deseas un campo más amplio más allá de la línea de comandos, el resumen de las mejores herramientas de mock de API también cubre opciones GUI y alojadas.

Qué hace que una herramienta CLI mock sea "ligera"

Ligero se refiere a la huella y la fricción, no a la cantidad de características. Al comparar estas herramientas, considera cuatro cosas:

• Tamaño de instalación y tiempo de ejecución. Un paquete puramente Node que puedes usar con `npx` pesa unos pocos megabytes. Un servidor JVM independiente es un archivo .jar de más de 20 MB que necesita un entorno de ejecución de Java. Ambos son válidos; se sitúan en extremos diferentes de esta lista.
• Velocidad de inicio. Un buen servidor mock ya está funcionando antes de que hayas vuelto a tu editor. Las herramientas basadas en Node se inician en frío en mucho menos de un segundo.
• Configuración hasta la primera respuesta. ¿Puedes pasar de cero a un punto final en vivo con un solo archivo y un solo comando? Las herramientas más ligeras dicen que sí.
• Terminal primero. Sin cuenta, sin panel, sin paso de GUI en el bucle. La herramienta lee un archivo y lo sirve, y encaja en un script de shell o un trabajo de CI.

Las herramientas se ordenan de la más pequeña y rápida primero. Prism, Mockoon CLI y json-server son las que puedes ejecutar con `npx` y sin instalación global.

Prism (Stoplight)

Prism convierte un archivo OpenAPI en un servidor mock en vivo con un solo comando. Si ya tienes una especificación, este es el mock que requiere menos esfuerzo de la lista; lee tus `paths`, `examples` y esquemas y sirve respuestas que coincidan con ellos.

npx @stoplight/prism-cli mock ./openapi.yaml

Eso inicia un servidor en `http://127.0.0.1:4010` con cada operación de tu especificación conectada. Prism devuelve el `example` que definiste para una respuesta, o genera uno válido aleatorio a partir del esquema si no lo hiciste. También valida las solicitudes entrantes contra la especificación, por lo que una llamada malformada recibe un `422` apropiado en lugar de un paso silencioso. Para una instalación global, usa `npm install -g @stoplight/prism-cli` y omite el `npx`.

Ideal para: equipos que trabajan con especificaciones primero y quieren que el mock sea fiel al contrato. Prism tiene licencia Apache-2.0 y es compatible con OpenAPI 3.1, 3.0, 2.0 y colecciones de Postman.

Límites honestos: Prism no tiene estado. Un `POST` no persiste nada, por lo que no simulará un flujo de crear y luego leer. Su mock es tan bueno como tu especificación; ejemplos escasos significan respuestas escasas. Para un mocking preciso del contrato, ese es exactamente el objetivo, y combina bien con el flujo de trabajo de herramientas de mocking de API REST.

Mockoon CLI

Mockoon CLI ejecuta una API mock desde un archivo de datos, ya sea uno que exportaste desde la aplicación de escritorio gratuita Mockoon o una especificación OpenAPI simple. La aplicación de escritorio te permite construir rutas visualmente; la CLI ejecuta ese mismo entorno sin interfaz gráfica en CI o en un servidor.

npx @mockoon/cli start --data ./mockoon-env.json --port 3000

Apuntando `—data` a un archivo de entorno de Mockoon o a un archivo JSON/YAML de OpenAPI, el servidor se inicia inmediatamente. Si el archivo de datos proviene de una versión anterior de Mockoon, la CLI lo migra en memoria sin tocar el original. Instálalo globalmente con `npm install -g @mockoon/cli` si prefieres un comando `mockoon-cli` persistente.

Ideal para: equipos que quieren diseñar mocks en una GUI pero ejecutarlos sin interfaz gráfica. Tiene licencia MIT y cuenta con una imagen oficial de Docker para despliegues.

Límites honestos: las rutas más ricas se construyen en la aplicación de escritorio, por lo que la edición manual del archivo de entorno JSON es complicada. Si no quieres ninguna aplicación complementaria, Prism o json-server mantienen todo en un solo archivo que escribes a mano.

json-server

json-server es la forma más rápida de simular una API REST cuando aún no tienes una especificación. Escribes un archivo JSON simple que describe tus datos, y genera una API REST completa a su alrededor, con `GET`, `POST`, `PUT`, `PATCH` y `DELETE`.

echo '{ "posts": [{ "id": 1, "title": "hello" }] }' > db.json
npx json-server db.json

Eso sirve `http://localhost:3000/posts` con CRUD real. Un `POST` a `/posts` realmente añade un registro y lo escribe de nuevo en `db.json`, por lo que obtienes comportamiento con estado de forma gratuita, lo cual Prism y WireMock no te darán de forma predeterminada. También obtienes filtrado, ordenación y paginación a través de parámetros de consulta. La línea 1.x actual observa el archivo y recarga al cambiar por defecto; instálalo globalmente con `npm install -g json-server` si lo quieres siempre en tu `PATH`.

Ideal para: desarrolladores frontend que necesitan un backend REST funcional en un minuto, antes de que exista la API real. Tiene licencia MIT y es una de las opciones de servidores mock ligeros para una API RESTful que no necesita ninguna especificación.

Límites honestos: asume una forma REST tipo recurso. Las rutas profundamente personalizadas, los puntos finales no REST o la coincidencia estricta de encabezados quedan fuera de lo que hace de forma limpia. Es una herramienta de prototipado, no un validador de contratos.

MockServer

MockServer es el peso pesado para la coincidencia precisa de solicitudes. Mientras que las herramientas anteriores sirven una especificación o un archivo de datos, MockServer te permite definir expectativas: hacer coincidir una solicitud por método, ruta, encabezado, consulta o cuerpo, y luego devolver exactamente la respuesta que deseas, incluyendo retrasos y fallos para probar tiempos de espera y manejo de errores.

java -jar mockserver-netty-5.15.0-no-dependencies.jar -p 1080

Eso inicia MockServer en el puerto `1080`. Luego, envías expectativas a su API REST para configurar el comportamiento, o lo controlas programáticamente. Los usuarios de Node pueden omitir el archivo jar sin procesar y usar el envoltorio oficial:

npm install mockserver-node

const mockserver = require('mockserver-node');
mockserver.start_mockserver({ serverPort: 1080 });

Ideal para: pruebas de integración que requieren un control granular sobre cómo debe ser una solicitud y cómo responde el mock. Tiene licencia Apache-2.0 y es compatible con HTTP, HTTPS y más en un solo puerto.

Límites honestos: es un servidor JVM, por lo que es más pesado y lento de iniciar que las herramientas de Node, y la configuración de expectativas es más verbosa que apuntar a una especificación. Si solo necesitas que se sirva una especificación, es excesivo; si lo superas, la comparación de alternativas a MockServer expone las ventajas y desventajas.

WireMock (autónomo)

WireMock es el otro servidor mock JVM establecido, popular en el mundo de las pruebas de Java y JVM. Su archivo jar autónomo ejecuta el mismo motor que incrustarías en una prueba de JUnit, por lo que un mock que construyes en el desarrollo local se traslada directamente a tu suite de pruebas.

java -jar wiremock-standalone.jar --port 8080

Eso sirve en el puerto `8080`. WireMock lee asignaciones de stub de un directorio `mappings/` o de su API JSON, y también puede registrar tráfico real y reproducirlo como stubs, lo cual es útil cuando se simula una API de terceros que no controlas. Hay una imagen oficial de Docker `wiremock/wiremock` para CI.

Ideal para: equipos JVM que desean un motor de mocking compartido entre el desarrollo local y su suite de pruebas, además de grabar y reproducir. Tiene licencia Apache-2.0.

Límites honestos: al igual que MockServer, necesita un entorno de ejecución de Java y se inicia más lento que las opciones de Node. Su JSON de mapeo de stubs es potente pero más difícil de aprender que un mock de datos de un solo archivo. Si vienes del lado de JavaScript, la comparación de alternativas a Mock Service Worker (MSW) cubre dónde encaja WireMock frente al mocking centrado en el navegador.

Apidog CLI

Cada una de las herramientas anteriores resuelve una parte del mocking. Apidog toma la ruta integrada: tu diseño de API, el mock, tus pruebas y tu documentación viven en un solo proyecto, y la CLI de Apidog impulsa ese proyecto desde el terminal. Apidog no es de código abierto; es un producto comercial con una capa gratuita. Pero esa capa gratuita más la CLI te ofrecen una alternativa a unir un servidor mock, un ejecutor de pruebas y una herramienta de especificación por separado.

Apidog genera automáticamente un mock inteligente a partir de cada punto final que defines, con respuestas que siguen los tipos de campo y nombres de tu esquema, por lo que un campo `phone` devuelve un número de teléfono plausible en lugar de una cadena aleatoria. Cuando necesitas una respuesta específica para una solicitud específica, añades una expectativa de mock. La CLI gestiona esos recursos de mock como parte del proyecto:

npm install -g apidog-cli
apidog login --with-token <YOUR_TOKEN>
apidog mock --help

El grupo de comandos `mock` funciona con las expectativas de mock de tu proyecto desde scripts y CI, junto con grupos de comandos para puntos finales, esquemas, entornos y ejecuciones de pruebas. La salida es un JSON estructurado con un campo `agentHints.nextSteps`, lo que lo hace utilizable tanto por agentes de IA como por humanos. La superficie de comando completa se cubre en la guía completa de la CLI de Apidog.

Ideal para: equipos que prefieren mantener el mock, la especificación y las pruebas en un solo lugar en lugar de ejecutar tres herramientas separadas. Descarga Apidog para probar el servidor mock incorporado y la CLI en tu propio proyecto.

Límites honestos: es una plataforma, no un binario de propósito único, por lo que pide un proyecto y un inicio de sesión donde json-server no pide nada. Si todo lo que necesitas es un mock desechable de un archivo, una herramienta más ligera gana; si ya estás diseñando tu API en Apidog, el mock ya está ahí.

Cómo elegir

Adapta la herramienta a lo que ya tienes. Si tienes una especificación OpenAPI, Prism o Mockoon CLI la sirven directamente. Si aún no tienes nada, json-server inventa una API a partir de un archivo JSON. Si necesitas una coincidencia exacta de solicitudes, recurre a MockServer o WireMock. Si quieres que el mock conviva con tu diseño y tus pruebas, usa Apidog.

La regla general: herramientas `npx` para velocidad, servidores JVM para profundidad de coincidencia, Apidog cuando quieres un flujo de trabajo en lugar de varios. Si todavía estás decidiendo si simular o no, el recorrido por los casos de uso de mocking de API cubre cuándo vale la pena.

Concluyendo

El mocking ligero se reduce a una pregunta: ¿qué tienes ya para alimentar la herramienta? Una especificación va a Prism o Mockoon CLI. Una hoja en blanco va a json-server. La coincidencia estricta va a MockServer o WireMock. Y si prefieres no ejecutar y conectar varias herramientas, Apidog mantiene el mock junto al diseño y las pruebas, impulsado desde la misma CLI que de todos modos programarías.

Las seis se ejecutan desde el terminal, encajan en un trabajo de CI y te proporcionan una API falsa en segundos en lugar de horas. Elige la más pequeña que cubra tu caso y añade peso solo cuando realmente lo necesites. Para ver la versión integrada, descarga Apidog y genera un servidor mock a partir de tu diseño de API en un solo paso.