API Testing MCP

Resumen

El servidor MCP más completo para pruebas de API: 42 herramientas, configuración cero, nada más se le acerca. Esto no es solo un emisor de peticiones. Es un banco de trabajo de pruebas completo: peticiones HTTP con aserciones, flujos de varios pasos con extracción de variables, importación de OpenAPI con datos simulados conscientes del esquema, pruebas de carga con métricas de percentiles, comparación de respuestas entre entornos, ejecutores de pruebas masivas, colecciones reutilizables, grupos de entornos con alcance de directorio y valores predeterminados persistentes, importación/exportación de Postman y exportación de cURL. Todo mediante conversación natural. Sin cuentas, sin nube, sin archivos generados. Todo se ejecuta en línea y se almacena como JSON plano que tú posees.

Solo habla con él

No necesitas aprender nombres de herramientas o parámetros. Describe lo que quieres y la IA elegirá la herramienta adecuada.

"Create a group called my-project and add this directory as scope"
"Set up a dev environment with BASE_URL http://localhost:3000"
"Switch to prod for this session"
"Set dev as the default environment"
"Import my API spec from /api-docs-json"
"Show me all user endpoints"
"GET /users"
"Create a user with random data"
"Verify that DELETE /users/5 returns 204"
"Login as admin, extract the token, then fetch dashboard stats"
"How fast is /health with 50 concurrent requests?"
"Run all my saved smoke tests"
"Compare the users endpoint between dev and prod"
"Export the create-user request as curl"
"Export my collection to Postman"

Si has importado una especificación OpenAPI, la IA ya conoce cada endpoint, cada campo obligatorio, cada valor de enumeración válido. Cuando dices "crear una entrada de blog", lee el esquema y construye la petición correctamente, sin adivinar.

Instalación

Claude Code

claude mcp add --scope user api-testing -- npx -y @cocaxcode/api-testing-mcp@latest

Claude Desktop

Añádelo a tu archivo de configuración (~/Library/Application Support/Claude/claude_desktop_config.json en macOS, %APPDATA%\Claude\claude_desktop_config.json en Windows):

{
  "mcpServers": {
    "api-testing": {
      "command": "npx",
      "args": ["-y", "@cocaxcode/api-testing-mcp@latest"]
    }
  }
}

Cursor / Windsurf

Añádelo a .cursor/mcp.json o .windsurf/mcp.json en la raíz de tu proyecto:

{
  "mcpServers": {
    "api-testing": {
      "command": "npx",
      "args": ["-y", "@cocaxcode/api-testing-mcp@latest"]
    }
  }
}

VS Code — añádelo a .vscode/mcp.json:

{
  "servers": {
    "api-testing": {
      "command": "npx",
      "args": ["-y", "@cocaxcode/api-testing-mcp@latest"]
    }
  }
}

Codex CLI (OpenAI):

codex mcp add api-testing -- npx -y @cocaxcode/api-testing-mcp@latest

O añádelo a ~/.codex/config.toml:

[mcp_servers.api-testing]
command = "npx"
args = ["-y", "@cocaxcode/api-testing-mcp@latest"]

Gemini CLI — añádelo a ~/.gemini/settings.json:

{
  "mcpServers": {
    "api-testing": {
      "command": "npx",
      "args": ["-y", "@cocaxcode/api-testing-mcp@latest"]
    }
  }
}

Inicio rápido

Una vez instalado, configura un entorno para que las rutas relativas se resuelvan automáticamente:

"Create an environment called dev with BASE_URL http://localhost:3000"

Si tu API tiene una especificación Swagger/OpenAPI, impórtala:

"Import my API spec from http://localhost:3000/api-docs-json"

Verifica con: "List my environments" (Listar mis entornos) — deberías ver el que acabas de crear.

Características

Peticiones HTTP

Envía cualquier método HTTP con cabeceras, parámetros de consulta, cuerpo JSON, autenticación e interpolación de {{variable}}. Las URLs relativas se resuelven automáticamente contra BASE_URL.

"POST to /api/users with name Jane and email jane@company.com using my bearer token"

Soporta: GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS — Autenticación Bearer / API Key / Básica — tiempos de espera personalizados.

Aserciones

Valida las respuestas con resultados estructurados de éxito/fallo:

"Verify that GET /api/health returns 200, body.status is ok, and responds in under 500ms"

PASS — 3/3 assertions passed
  status === 200
  body.status === "ok"
  timing.total_ms < 500

10 operadores: eq, neq, gt, gte, lt, lte, contains, not_contains, exists, type

Flujos de peticiones

Encadena peticiones con extracción de variables entre pasos. Perfecto para flujos de autenticación y secuencias CRUD.

"Login as admin@test.com, extract the access token, then use it to fetch all users"

flow_run({
  steps: [
    {
      name: "login",
      method: "POST",
      url: "/auth/login",
      body: { email: "admin@test.com", password: "SecurePass#99" },
      extract: { "TOKEN": "body.access_token" }
    },
    {
      name: "get-users",
      method: "GET",
      url: "/api/users",
      headers: { "Authorization": "Bearer {{TOKEN}}" }
    }
  ]
})

Importación de OpenAPI

Importa especificaciones desde una URL o archivo local (JSON y YAML). Una vez importado, la IA conoce cada endpoint, parámetro y esquema.

"Import my API spec from http://localhost:3000/api-docs-json"
"Import the spec from ./openapi.yaml"
"What parameters does POST /users expect?"

Soporta OpenAPI 3.x con resolución completa de $ref, allOf, oneOf, anyOf. OpenAPI 2.0 parcialmente soportado.

Generación de datos simulados (Mock)

Genera datos falsos realistas a partir de tus esquemas OpenAPI. Respeta tipos, formatos (email, uuid, date-time), enumeraciones y campos obligatorios.

"Generate mock data for creating a user"

{
  "email": "user42@example.com",
  "name": "Test User 73",
  "password": "TestPass123!",
  "role": "admin"
}

Pruebas de carga

Lanza N peticiones concurrentes y obtén métricas de rendimiento:

"How fast is the health endpoint with 50 concurrent requests?"

LOAD TEST — GET /api/health
Requests:    50 concurrent
Successful:  50 | Failed: 0
Req/sec:     23.31

  Min: 45ms | Avg: 187ms
  p50: 156ms | p95: 412ms | p99: 523ms
  Max: 567ms

Comparación de respuestas (Diffing)

Ejecuta dos peticiones y compara sus respuestas campo por campo. Detecta regresiones o compara entornos.

"Compare the users endpoint between dev and prod"

Pruebas masivas

Ejecuta cada petición guardada en una colección (o filtra por etiqueta) y obtén un resumen:

"Run all my saved smoke tests"

BULK TEST — 8/8 passed | 1.2s total
  health       — GET  /health      → 200 (45ms)
  list-users   — GET  /users       → 200 (123ms)
  create-post  — POST /blog        → 201 (89ms)
  login        — POST /auth/login  → 200 (156ms)

Colecciones

Guarda peticiones para reutilizarlas con etiquetas. Construye suites de regresión.

"Save this request as create-user with tags auth, smoke"
"List all requests tagged smoke"

Entornos

Los entornos contienen tus variables — BASE_URL, tokens, claves de API — y los mantienen separados por contexto. El sistema tiene tres conceptos fundamentales:

Grupo. Un grupo organiza entornos y los vincula a directorios. Un grupo tiene N alcances (directorios) que comparten sus entornos, y exactamente un entorno predeterminado. Cuando creas un entorno dentro de un grupo, pertenece a ese grupo. Cuando haces cd a un directorio que es alcance de un grupo, sus entornos quedan disponibles automáticamente.

Predeterminado. El entorno predeterminado se activa automáticamente cuando entras en un alcance de su grupo. Persiste entre sesiones: reinicia tu editor, vuelve a abrir tu terminal y el valor predeterminado sigue ahí. Configúralo una vez y olvídate.

Activo. El entorno activo es el que se está utilizando en este momento para la resolución de variables. Comienza como el predeterminado cuando entras en un alcance, pero puedes cambiarlo en cualquier momento. La selección activa es solo para la sesión: se restablece al predeterminado al reiniciar.

Los entornos globales (no asociados a ningún grupo) siguen existiendo. Requieren activación explícita con env_switch y no persisten entre sesiones.

Ejemplo práctico:

"Create a group called my-api"
"Add this directory as scope to my-api"
"Create a dev environment with BASE_URL http://localhost:3000"   <- auto-joins group, auto-default
"Create a prod environment with BASE_URL https://api.example.com"
"List environments"                                              <- shows dev (active, default) and prod
"Switch to prod"                                                 <- session only
"Set prod as default"                                            <- persists

Interpolación automática. Cualquier {{variable}} en URLs, cabeceras, parámetros de consulta o cuerpos de petición se resuelve contra el entorno activo antes de que se dispare la petición. Configura BASE_URL una vez y cada ruta relativa funcionará.

Tus credenciales nunca salen de tu máquina. Los archivos de entorno son JSON planos almacenados en ~/.api-testing/. Nada se sincroniza con ninguna nube. Nada se incrusta en las exportaciones. Nada es rastreado por git. Tus tokens y secretos permanecen exactamente donde deberían: en tu disco, bajo tu control.

Importación y exportación de Postman

Soporte bidireccional de Postman. Migra sin problemas entre Postman y tu flujo de trabajo de IA.

"Import my Postman collection from ./exported.postman_collection.json"
"Export my collection to Postman"
"Export the dev environment for Postman"

Colección: Formato Postman v2.1. Las carpetas se convierten en etiquetas. La autenticación se hereda de las carpetas/nivel de colección. Soporta cuerpos JSON sin procesar, x-www-form-urlencoded, form-data.

Entorno: Prefiere currentValue sobre value. Omite variables deshabilitadas. Flag opcional activate.

Colección: Peticiones agrupadas en carpetas por etiqueta. Autenticación mapeada al formato nativo de Postman. {{variables}} preservadas tal cual.

Entorno: Todas las variables exportadas como enabled: true en formato compatible con Postman.

Exportación e importación nativa

Exporta colecciones y entornos a una carpeta portátil .atm/. Compártelos con tu equipo o cópialos entre proyectos.

"Export my collection and dev environment"

your-project/
└── .atm/
    ├── collection.json
    └── dev.env.json

Nota: .atm/ se añade automáticamente a .gitignore en la primera exportación.

Exportación cURL

Convierte cualquier petición guardada en un comando cURL listo para pegar con las variables resueltas.

"Export the create-user request as curl"

curl -X POST \
  'https://api.example.com/users' \
  -H 'Authorization: Bearer eyJhbGci...' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Jane","email":"jane@company.com"}'

Referencia de herramientas

42 herramientas en 9 categorías:

Consejo: No necesitas llamar a las herramientas directamente. Describe lo que quieres y la IA elegirá la correcta.

Almacenamiento

Todo es local. Sin base de datos, sin sincronización en la nube, sin telemetría. Todos los datos residen en ~/.api-testing/ como archivos JSON planos que puedes leer, respaldar o eliminar en cualquier momento.

~/.api-testing/
├── groups/               # Environment groups with scopes and defaults
├── environments/         # Environment variables — tokens, keys, passwords
├── collections/          # Saved requests (shareable, no secrets)
├── specs/                # Imported OpenAPI specs
└── project-envs.json     # Session-only active environments (cleared on restart)

Almacenamiento global vs exportaciones de proyecto. El directorio ~/.api-testing/ es tu almacén privado y global; aquí es donde viven las credenciales y nunca salen de ahí. Cuando exportas una colección o entorno, va a .atm/ en la raíz de tu proyecto. Esa carpeta se añade automáticamente a .gitignore en la primera exportación, pero incluso si decides confirmarla (commit), tus credenciales permanecen en ~/.api-testing/ y nunca se copian en .atm/. Puedes compartir de forma segura las exportaciones de .atm/ con tu equipo sin filtrar secretos.

Sobrescribe la ruta de almacenamiento predeterminada:

{
  "env": { "API_TESTING_DIR": "/path/to/custom/.api-testing" }
}

Advertencia: Si sobrescribes API_TESTING_DIR a una ruta dentro de un repositorio git, añade .api-testing/ a tu .gitignore para evitar subir credenciales.

Arquitectura

src/
├── index.ts              # Entry point (shebang + StdioServerTransport)
├── server.ts             # createServer() factory
├── tools/                # 42 tool handlers (one file per category)
│   ├── request.ts        # HTTP requests (1)
│   ├── assert.ts         # Assertions (1)
│   ├── flow.ts           # Request chaining (1)
│   ├── collection.ts     # Collection CRUD (4)
│   ├── environment.ts    # Environment management (8)
│   ├── group.ts          # Environment groups (7)
│   ├── api-spec.ts       # OpenAPI import/browse (4)
│   ├── mock.ts           # Mock data generation (1)
│   ├── load-test.ts      # Load testing (1)
│   └── utilities.ts      # curl, diff, bulk, import/export (12)
├── lib/                  # Business logic (no MCP dependency)
│   ├── http-client.ts    # fetch wrapper with timing
│   ├── storage.ts        # JSON file storage engine
│   ├── schemas.ts        # Shared Zod schemas
│   ├── url.ts            # BASE_URL resolution
│   ├── path.ts           # Dot-notation accessor (body.data.0.id)
│   ├── interpolation.ts  # {{variable}} resolver
│   └── openapi-parser.ts # $ref + allOf/oneOf/anyOf resolution
└── __tests__/            # 10+ test suites, 120+ tests

Stack: TypeScript (estricto) · MCP SDK · Zod · Vitest · tsup

MIT · Creado por cocaxcode