Cómo usar scripts pre-request y post-response en Apidog

Algunas solicitudes requieren trabajo antes de salir de tu máquina, y otras necesitan procesamiento cuando llega la respuesta. Por ejemplo, una API de pagos puede requerir una firma HMAC basada en una marca de tiempo y un secreto; un endpoint de inicio de sesión puede devolver un token para llamadas posteriores; y un flujo de pago debe comprobar que la respuesta devolvió un 200 y el ID de pedido esperado. Hacerlo manualmente es lento, difícil de compartir y propenso a errores.

Prueba Apidog hoy

Los scripts resuelven este problema. En Apidog, puedes adjuntar fragmentos de JavaScript a una solicitud para ejecutarlos automáticamente antes de enviarla o después de recibir la respuesta. Si ya utilizas scripts de Postman, la transición es directa: el motor de Apidog es compatible con la misma API del objeto pm.

En esta guía implementarás dos casos prácticos:

1. Firmar una solicitud con HMAC en un Preprocesador.
2. Extraer y validar un token en un Postprocesador.

Consulta todos los comportamientos disponibles en la documentación de scripts de Apidog.

Qué hacen los scripts de pre y post

Apidog ejecuta scripts en dos etapas.

Preprocesadores

Los Preprocesadores se ejecutan antes de enviar la solicitud al servidor. Úsalos para preparar datos dinámicos:

• Generar una marca de tiempo.
• Calcular una firma HMAC.
• Crear un ID de pedido aleatorio.
• Leer una variable y convertirla en una cabecera.
• Modificar parámetros, cuerpo o cabeceras antes del envío.

En esta etapa todavía no existe una respuesta, por lo que no debes usar pm.response.

Postprocesadores

Los Postprocesadores se ejecutan después de recibir la respuesta. Úsalos para:

• Validar códigos de estado.
• Comprobar la estructura del JSON.
• Extraer tokens de autenticación.
• Guardar IDs de recursos creados.
• Persistir cursores de paginación.

Dos reglas prácticas:

1. pm.response —incluidos code, status, headers, responseTime, responseSize, text() y json()— solo funciona en Postprocesadores.
2. Las variables permiten comunicar ambas etapas: un Preprocesador guarda un valor, la solicitud lo consume y un Postprocesador puede reutilizarlo o sobrescribirlo.

Si vienes de Postman, recuerda la equivalencia:

Postman	Apidog
Script de pre-solicitud	Preprocesadores
Pruebas	Postprocesadores

Configuración: encuentra los Preprocesadores y Postprocesadores

Descarga Apidog si todavía no lo tienes. Funciona en macOS, Windows y Linux.

Abre la solicitud que quieres automatizar. Junto a las pestañas habituales de Params, Headers y Body, encontrarás:

• Preprocesadores
• Postprocesadores

Para añadir lógica:

1. Abre la pestaña correspondiente.
2. Selecciona añadir un Script Personalizado.
3. Escribe JavaScript usando el objeto pm.

Antes de trabajar con variables, ten en cuenta el orden de prioridad de Apidog:

Variables Locales > Variables de Entorno > Variables Globales Compartidas dentro del Proyecto > Variables Globales Compartidas dentro del Equipo

Si una variable devuelve un valor inesperado, revisa si existe otra variable con el mismo nombre en un nivel superior. Para configuraciones estables a nivel de proyecto, utiliza parámetros globales en Apidog.

Ejemplo de Preprocesador: firmar una solicitud con HMAC

Supongamos que un endpoint de pagos exige una firma HMAC-SHA256 para cada solicitud. El servidor espera:

1. Una marca de tiempo.
2. El cuerpo de la solicitud.
3. Una firma generada con tu secreto de API.

Este patrón es común en validaciones de webhooks. Por ejemplo, la documentación de firmas de Stripe describe un enfoque similar.

Apidog incluye crypto-js, por lo que no necesitas instalar paquetes adicionales.

En Preprocesadores, añade un Script Personalizado:

// Preprocesador: firma la solicitud antes de enviarla
const CryptoJS = require('crypto-js');

// Marca de tiempo Unix actual en segundos
const timestamp = Math.floor(Date.now() / 1000).toString();

// Lee el secreto desde una variable de entorno
const secret = pm.environment.get('payments_api_secret');

// Construye el contenido que se firmará:
// marca de tiempo + salto de línea + cuerpo crudo
const body = pm.request.body ? pm.request.body.toString() : '';
const payload = timestamp + '\n' + body;

// Calcula la firma HMAC-SHA256 en hexadecimal
const signature = CryptoJS
  .HmacSHA256(payload, secret)
  .toString(CryptoJS.enc.Hex);

// Guarda los valores para usarlos en la solicitud
pm.environment.set('x_timestamp', timestamp);
pm.environment.set('x_signature', signature);

pm.console.log('Solicitud firmada en ' + timestamp);

Después, abre la pestaña Headers de la solicitud y añade:

X-Timestamp: {{x_timestamp}}
X-Signature: {{x_signature}}

El flujo de ejecución será:

1. Apidog ejecuta el Preprocesador.
2. El script crea x_timestamp y x_signature.
3. Apidog sustituye {{x_timestamp}} y {{x_signature}} en las cabeceras.
4. El servidor recibe una firma válida para ese envío.

require('crypto-js') importa el módulo completo. Usa esa forma, no rutas de submódulos como require('crypto-js/sha256').

Las operaciones de variables actualizan los valores actuales, no los valores iniciales del editor de entorno. Esto es apropiado para firmas efímeras.

Si necesitas comparar este enfoque con Postman, consulta la guía sobre scripts de pre-solicitud de Postman.

Ejemplo de Postprocesador: extraer y validar un token

Imagina que tu endpoint de inicio de sesión devuelve esta respuesta:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "user": {
    "id": 4812,
    "email": "[e-mail]"
  },
  "expires_in": 3600
}

En Postprocesadores, añade un Script Personalizado:

// Postprocesador: valida la respuesta y extrae el token
pm.test('El estado es 200', function () {
  pm.response.to.have.status(200);
});

const jsonData = pm.response.json();

pm.test('La respuesta devuelve un token', function () {
  pm.expect(jsonData.token).to.be.a('string').and.not.empty;
});

pm.test('El ID de usuario está presente', function () {
  pm.expect(jsonData.user.id).to.be.a('number');
});

// Guarda el token para solicitudes posteriores
pm.environment.set('auth_token', jsonData.token);

pm.console.log('Token guardado para el usuario ' + jsonData.user.email);

Este script hace dos tareas:

• Valida que la respuesta tiene el estado y la estructura esperados.
• Guarda el token en la variable de entorno auth_token.

Las solicitudes posteriores pueden incluir esta cabecera:

Authorization: Bearer {{auth_token}}

Así evitas copiar y pegar tokens manualmente entre solicitudes.

Para profundizar en validaciones, revisa esta guía sobre aserciones de API en Apidog. Si necesitas datos de prueba realistas, puedes combinar este flujo con Faker.js en Apidog.

Ten en cuenta estas limitaciones en Postprocesadores:

• pm.iterationData es de solo lectura.
• pm.cookies devuelve las cookies de la respuesta, no las cookies enviadas en la solicitud.

Reutilizar lógica con Scripts Públicos

Copiar un bloque HMAC en diez endpoints crea diez lugares que tendrás que actualizar si cambia el algoritmo. Para evitarlo, usa Scripts Públicos.

1. Ve a Configuración > Scripts Públicos.
2. Crea un script reutilizable.
3. Añádelo a la lista de Preprocesadores o Postprocesadores de cada solicitud.

El orden importa:

• Los Scripts Públicos se ejecutan antes que los Scripts Personalizados de la misma lista.
• Si hay varios Scripts Públicos, se ejecutan de arriba hacia abajo.

Para que un Script Personalizado pueda llamar a una función definida en un Script Público, debes declararla globalmente.

Script Público:

// Omite var, let y const para hacer global la función sign
sign = function (payload, secret) {
  const CryptoJS = require('crypto-js');

  return CryptoJS
    .HmacSHA256(payload, secret)
    .toString(CryptoJS.enc.Hex);
};

Script Personalizado debajo del Script Público:

const timestamp = Math.floor(Date.now() / 1000).toString();
const secret = pm.environment.get('payments_api_secret');

pm.environment.set('x_timestamp', timestamp);
pm.environment.set('x_signature', sign(timestamp, secret));

Si declaras la función con const, let, var o una declaración function normal, quedará limitada a su propio script y el siguiente script no podrá usarla.

Librerías, paquetes externos y depuración

Apidog incluye varias librerías que puedes cargar con require():

• crypto-js (v3.1.9-1) para hashing y HMAC.
• jsrsasign (v10.3.0) para JWT y RSA; requiere Apidog 1.4.5 o posterior.
• chai (v4.2.0) para matchers de aserción.
• lodash, moment, uuid, xml2js, cheerio, postman-collection, atob, btoa, csv-parse/lib/sync, tv4 y ajv.
• Módulos de Node como path, assert, buffer, util, url, querystring, stream y events.

Si necesitas un paquete no incluido, usa $$.liveRequire():

$$.liveRequire('nanoid', (nanoid) => {
  const id = nanoid.nanoid();

  pm.environment.set('request_id', id);
});

$$.liveRequire() descarga el paquete durante la ejecución, por lo que requiere conexión a internet. Las librerías incorporadas no necesitan red.

Depuración con logs

Usa pm.console.log() o console.log() para inspeccionar valores:

pm.console.log('Firma calculada:', signature);
pm.console.log('Token recibido:', jsonData.token);

Revisa la consola de Apidog después de enviar la solicitud para verificar los valores generados.

Límites importantes

pm.sendRequest() usa callbacks, no Promesas. Evita usar await:

pm.sendRequest('https://api.example.com/status', function (error, response) {
  if (error) {
    console.log(error);
    return;
  }

  console.log(response.json());
});

Además, pm.nextRequest() de Postman no es compatible. Para ejecutar flujos con pasos condicionales, bifurcaciones y secuencias de solicitudes, utiliza Escenarios de Prueba.

Automatiza el flujo con la CLI de Apidog

Los scripts no se limitan al botón Enviar. Si guardas tus solicitudes y aserciones en un Escenario de Prueba, la CLI de Apidog puede ejecutarlo sin interfaz gráfica, incluyendo Preprocesadores y Postprocesadores.

Instala la CLI, autentícate y ejecuta un escenario:

npm install -g apidog-cli
apidog login --with-token <TU_TOKEN_DE_ACCESO>
apidog run --access-token $APIDOG_ACCESS_TOKEN -t <ID_ESCENARIO> -e <ID_ENTORNO> -r cli

Parámetros principales:

• -t: ID del escenario de prueba.
• -e: ID del entorno.
• -r: reportero; admite cli, html o junit. Puedes separar varios reporteros por comas.

Genera un token de acceso desde la configuración de tu cuenta de Apidog y expórtalo como APIDOG_ACCESS_TOKEN.

Evita dependencias que existan solo en tu máquina, como archivos locales o paquetes cargados manualmente. Un script puede funcionar en escritorio y fallar en CLI si el ejecutor no tiene esa dependencia. Prioriza las librerías incorporadas o $$.liveRequire().

Preguntas frecuentes

¿Son compatibles los scripts de Apidog con scripts de Postman?

En su mayoría, sí. Apidog usa la misma API del objeto pm, por lo que llamadas como pm.environment.set(), pm.response.json(), pm.test() y pm.expect() funcionan de forma similar.

Recuerda estas diferencias:

• Las pestañas se llaman Preprocesadores y Postprocesadores.
• Algunas funciones, como pm.nextRequest(), no son compatibles.

¿Por qué pm.response devuelve undefined en mi script de pre-solicitud?

Porque todavía no existe una respuesta. Los Preprocesadores se ejecutan antes de enviar la solicitud.

Si necesitas acceder a datos antes del envío, usa:

• pm.request
• Variables de entorno o globales
• Librerías disponibles en Apidog

Consulta cómo recuperar parámetros de solicitud en scripts pre y post.

¿Cómo comparto un script entre varias solicitudes?

Usa Scripts Públicos en Configuración > Scripts Públicos. Añade el script a cada solicitud y asegúrate de que se ejecute antes del Script Personalizado que dependa de él.

Si necesitas compartir una función, declárala sin var, let ni const.

¿Puedo importar un paquete npm que Apidog no incluye?

Sí:

$$.liveRequire('package-name', (pkg) => {
  // Usa el paquete aquí
});

Esto requiere conexión a internet. Para paquetes incorporados como crypto-js, moment o uuid, utiliza require() directamente.

¿Dónde veo la salida de mi script?

Usa:

pm.console.log('Mensaje de depuración');

o:

console.log('Mensaje de depuración');

Después, revisa la consola de Apidog tras ejecutar la solicitud.

Conclusión

Los Preprocesadores y Postprocesadores convierten solicitudes estáticas en flujos reutilizables y verificables:

• Firma datos antes de enviar la solicitud.
• Valida respuestas después de recibirlas.
• Extrae tokens e IDs para reutilizarlos.
• Centraliza lógica compartida con Scripts Públicos.
• Ejecuta el mismo flujo en CI mediante la CLI.

Abre Apidog, selecciona una solicitud y añade tu primer Script Personalizado para automatizar un paso repetitivo de tu flujo de API.