Como Usar Scripts de Pré-Requisição e Pós-Resposta no Apidog

Algumas requisições exigem preparação antes de sair da sua máquina, enquanto outras exigem validação quando a resposta chega. Por exemplo: uma API de pagamentos pode exigir uma assinatura HMAC baseada em timestamp e segredo; um login pode retornar um token usado nas chamadas seguintes; e um checkout pode precisar validar o status 200 e o ID do pedido. Fazer isso manualmente é repetitivo, difícil de manter e falha rapidamente quando a requisição é compartilhada com a equipe.

Experimente o Apidog hoje

Scripts resolvem esse problema. No Apidog, você adiciona trechos de JavaScript que são executados automaticamente antes do envio da requisição ou depois do recebimento da resposta. O motor é compatível com a API de objeto pm usada pelo Postman, o que facilita a migração de scripts existentes.

Neste guia, você vai:

1. Criar um Pré-Processador para assinar uma requisição com HMAC.
2. Criar um Pós-Processador para validar uma resposta e salvar um token.
3. Reutilizar lógica com Scripts Públicos.
4. Executar cenários automatizados com a CLI do Apidog.

O comportamento completo está documentado na documentação de scripts do Apidog, mas os nomes das abas e alguns comportamentos diferem do Postman.

O que os scripts pré e pós-requisição realmente fazem

O Apidog executa scripts em duas etapas:

• Pré-Processadores: executados antes do envio da requisição.
• Pós-Processadores: executados após o recebimento da resposta.

Use Pré-Processadores para preparar a requisição

Pré-Processadores são úteis para:

• Gerar timestamps.
• Calcular assinaturas HMAC.
• Criar IDs aleatórios.
• Formatar valores para cabeçalhos.
• Definir variáveis que serão usadas na requisição.

Nesse estágio, a resposta ainda não existe. Portanto, não tente acessar pm.response em um Pré-Processador.

Use Pós-Processadores para validar e reutilizar respostas

Pós-Processadores são úteis para:

• Validar o código de status.
• Verificar a estrutura do JSON retornado.
• Extrair tokens.
• Salvar IDs de recursos criados.
• Armazenar cursores de paginação.

O objeto pm.response — incluindo code, status, headers, responseTime, responseSize, text() e json() — só está disponível em Pós-Processadores.

O fluxo típico é:

Pré-Processador → define variáveis → requisição usa variáveis → Pós-Processador valida e salva dados

Se você vem do Postman, a diferença principal está nos nomes das abas:

Postman	Apidog
Pre-request Script	Pré-Processadores
Tests	Pós-Processadores

A API pm continua muito semelhante.

Configuração: encontre as abas de scripts

Baixe o Apidog na página de Download do Apidog caso ainda não o tenha instalado.

Abra uma requisição no Apidog. Ao lado das abas usuais, como Params, Headers e Body, você encontrará:

• Pré-Processadores
• Pós-Processadores

Para criar um script:

1. Abra a aba correspondente.
2. Selecione adicionar um Script Personalizado.
3. Escreva JavaScript usando o objeto pm.

Antes de começar, entenda a prioridade de variáveis no Apidog:

Variáveis Locais > Variáveis de Ambiente > Variáveis Globais Compartilhadas dentro do Projeto > Variáveis Globais Compartilhadas dentro da Equipe

Isso significa que uma variável local com o mesmo nome substitui uma variável de ambiente.

Use variáveis locais para valores temporários e variáveis de ambiente para dados reutilizados entre requisições. Para configurações estáveis do projeto, use parâmetros globais no Apidog.

Exemplo de Pré-Processador: assinar uma requisição com HMAC

Considere uma API de pagamentos que exige uma assinatura HMAC-SHA256 em cada requisição.

O servidor espera:

1. Um timestamp.
2. O corpo da requisição.
3. Uma assinatura HMAC calculada com um segredo.

Esse padrão é comum em integrações de webhook. A documentação de assinatura do Stripe descreve uma abordagem semelhante.

No Apidog, abra Pré-Processadores e adicione um Script Personalizado:

// Pré-Processador: assina a requisição antes do envio
const CryptoJS = require('crypto-js');

// Timestamp Unix atual, em segundos
const timestamp = Math.floor(Date.now() / 1000).toString();

// Lê o segredo armazenado no ambiente
const secret = pm.environment.get('payments_api_secret');

// Monta o conteúdo que será assinado
const body = pm.request.body ? pm.request.body.toString() : '';
const payload = timestamp + '\n' + body;

// Calcula a assinatura HMAC-SHA256 em hexadecimal
const signature = CryptoJS
  .HmacSHA256(payload, secret)
  .toString(CryptoJS.enc.Hex);

// Salva os valores para a requisição usar
pm.environment.set('x_timestamp', timestamp);
pm.environment.set('x_signature', signature);

pm.console.log('Requisição assinada em: ' + timestamp);

Agora adicione os valores aos cabeçalhos da requisição:

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

Ao enviar a requisição, o Apidog executa esta sequência:

1. Executa o Pré-Processador.
2. Gera o timestamp.
3. Calcula a assinatura.
4. Salva as variáveis de ambiente.
5. Substitui {{x_timestamp}} e {{x_signature}} nos cabeçalhos.
6. Envia a requisição.

A assinatura é gerada no momento do envio, sem cópia manual de valores.

Use require('crypto-js') para importar a biblioteca completa. O Apidog não suporta a importação de submódulos, como require('crypto-js/sha256').

As operações com variáveis alteram os valores atuais, não os valores iniciais configurados no editor de ambiente. Isso é ideal para assinaturas e timestamps, que são temporários.

Se você também trabalha com Postman, consulte o guia sobre scripts pré-requisição do Postman.

Exemplo de Pós-Processador: validar a resposta e extrair um token

Agora considere uma requisição de login que retorna este JSON:

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

Você quer validar a resposta e salvar o token para as próximas chamadas autenticadas.

Abra Pós-Processadores, adicione um Script Personalizado e use:

// Pós-Processador: valida a resposta e extrai o token
pm.test('Status é 200', function () {
  pm.response.to.have.status(200);
});

const jsonData = pm.response.json();

pm.test('A resposta retorna um token', function () {
  pm.expect(jsonData.token).to.be.a('string').and.not.empty;
});

pm.test('O ID do usuário está presente', function () {
  pm.expect(jsonData.user.id).to.be.a('number');
});

// Salva o token para requisições posteriores
pm.environment.set('auth_token', jsonData.token);

pm.console.log('Token salvo para o usuário: ' + jsonData.user.email);

Esse script faz duas coisas:

1. Executa asserções com pm.test() e pm.expect().
2. Salva o token com pm.environment.set().

Depois disso, qualquer requisição pode usar:

Authorization: Bearer {{auth_token}}

Isso elimina a necessidade de copiar tokens manualmente entre requisições.

Para criar validações mais completas, consulte o guia sobre asserções de API no Apidog. Se seu fluxo precisa de dados dinâmicos, combine esse padrão com Faker.js no Apidog.

Limites importantes dos Pós-Processadores

• pm.iterationData é somente leitura.
• pm.cookies retorna cookies enviados pelo servidor na resposta, não os cookies enviados na requisição.
• pm.response só pode ser usado depois que a resposta chega.

Reutilize lógica com Scripts Públicos

Copiar o mesmo script HMAC para vários endpoints cria dívida técnica. Se o algoritmo mudar, você precisará atualizar cada cópia.

Use Scripts Públicos para centralizar lógica compartilhada.

Como criar um Script Público

1. Abra Configurações > Scripts Públicos.
2. Crie o script reutilizável.
3. Adicione-o à lista de Pré-Processadores ou Pós-Processadores da requisição.

A ordem importa:

• Scripts Públicos são executados antes de Scripts Personalizados na mesma lista.
• Vários Scripts Públicos são executados de cima para baixo.

Se um Script Personalizado precisar chamar uma função de um Script Público, declare essa função globalmente.

No Script Público:

// Torna sign() global ao omitir var, let e const
sign = function (payload, secret) {
  const CryptoJS = require('crypto-js');

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

No Script Personalizado abaixo dele:

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));

Para funcionar corretamente:

1. Adicione o Script Público antes do Script Personalizado.
2. Não use const, let ou var ao declarar uma função que outro script precisa chamar.

Caso contrário, você receberá um erro de função indefinida.

Bibliotecas, pacotes externos e depuração

O Apidog inclui bibliotecas que podem ser carregadas diretamente com require().

Algumas opções disponíveis:

• crypto-js (v3.1.9-1) para hashing e HMAC.
• jsrsasign (v10.3.0) para JWT e RSA, disponível no Apidog 1.4.5 ou posterior.
• chai (v4.2.0) para matchers de asserção.
• lodash
• moment
• uuid
• xml2js
• cheerio
• postman-collection
• atob
• btoa
• csv-parse/lib/sync
• tv4
• ajv

Também há módulos nativos do Node.js, incluindo:

path
assert
buffer
util
url
querystring
stream
events

Carregue pacotes externos com $$.liveRequire()

Se você precisa de um pacote que não está incluído, carregue-o em tempo de execução:

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

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

Esse método requer conexão com a internet porque o Apidog baixa o pacote durante a execução.

Depure scripts com logs

Use pm.console.log() ou console.log():

pm.console.log('Assinatura gerada:', signature);
console.log('Token extraído:', jsonData.token);

Verifique a saída no console do Apidog para confirmar o valor de uma assinatura, token, ID ou variável.

Outros limites a considerar

pm.sendRequest() usa callbacks, não Promises. Portanto, use este padrão:

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

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

Não use await com pm.sendRequest().

Além disso, pm.nextRequest() do Postman não é suportado. Para fluxos com etapas condicionais e ramificações, use Cenários de Teste, com etapas visuais de Condição e If-Else.

Automatize o fluxo de trabalho com a CLI do Apidog

Scripts não precisam ser executados apenas no aplicativo desktop.

Quando suas requisições e asserções estão organizadas em um Cenário de Teste, a CLI do Apidog pode executar o cenário sem interface, incluindo Pré-Processadores e Pós-Processadores.

Instale e execute:

npm install -g apidog-cli
apidog login --with-token <YOUR_ACCESS_TOKEN>
apidog run --access-token $APIDOG_ACCESS_TOKEN -t <SCENARIO_ID> -e <ENV_ID> -r cli

Parâmetros principais:

Flag	Descrição
-t	ID do cenário de teste
-e	ID do ambiente
-r	Tipo de relatório: cli, html ou junit

Para gerar vários relatórios:

apidog run \
  --access-token $APIDOG_ACCESS_TOKEN \
  -t <SCENARIO_ID> \
  -e <ENV_ID> \
  -r cli,html,junit

Gere o token de acesso nas configurações da conta Apidog e exporte-o como variável de ambiente:

export APIDOG_ACCESS_TOKEN=<SEU_TOKEN>

Assim, o mesmo cenário executado localmente pode fazer parte da sua pipeline de CI.

Atenção a dependências locais

Um script pode funcionar no desktop e falhar na CLI se depender de algo disponível apenas na sua máquina, como:

• Arquivos locais.
• Pacotes carregados manualmente.
• Configurações não presentes no ambiente de execução.

Prefira bibliotecas embutidas ou $$.liveRequire() para manter o comportamento consistente entre desktop e CI.

FAQ

Os scripts do Apidog são compatíveis com scripts existentes do Postman?

Em grande parte, sim. O Apidog usa a mesma API de objeto pm, então chamadas como estas funcionam de forma semelhante:

pm.environment.set('key', 'value');
pm.response.json();
pm.test('nome do teste', function () {});
pm.expect(valor).to.equal('esperado');

As principais diferenças são:

• As abas se chamam Pré-Processadores e Pós-Processadores.
• Algumas chamadas, como pm.nextRequest(), não são suportadas.

Na maioria dos casos, você pode copiar o script do Postman e adaptá-lo apenas aos nomes e recursos disponíveis.

Por que pm.response retorna undefined no meu Pré-Processador?

Porque a resposta ainda não existe.

Pré-Processadores são executados antes do envio da requisição. Mova qualquer código que lê status, corpo ou cabeçalhos da resposta para um Pós-Processador.

Se você precisa acessar dados da requisição antes do envio, use:

pm.request
pm.environment
pm.variables

Você também pode recuperar parâmetros de pm.request.

Como compartilho um script entre várias requisições?

Use Scripts Públicos em:

Configurações > Scripts Públicos

Escreva a lógica uma vez e associe o script às requisições necessárias.

Lembre-se:

• Scripts Públicos são executados antes dos Scripts Personalizados.
• A ordem dos scripts afeta o resultado.
• Funções usadas por outros scripts precisam ser declaradas globalmente.

Posso importar um pacote npm que o Apidog não inclui?

Sim:

$$.liveRequire('package-name', (pkg) => {
  // use o pacote aqui
});

Esse método exige acesso à internet.

Para bibliotecas já incluídas, como crypto-js, moment e uuid, use apenas:

const CryptoJS = require('crypto-js');

Importe o módulo completo, não caminhos de submódulos.

Onde vejo o que meu script imprimiu?

Use:

pm.console.log('Mensagem de depuração');

ou:

console.log('Mensagem de depuração');

A saída aparece no console do Apidog depois da execução da requisição.

Conclusão

Pré-Processadores e Pós-Processadores transformam requisições estáticas em fluxos que se preparam e validam automaticamente.

Use Pré-Processadores para:

• Gerar valores dinâmicos.
• Assinar requisições.
• Configurar cabeçalhos.
• Preparar variáveis.

Use Pós-Processadores para:

• Validar respostas.
• Extrair tokens.
• Salvar IDs.
• Criar asserções reutilizáveis.

Quando a lógica precisar ser compartilhada, mova-a para Scripts Públicos. Quando precisar executá-la em CI, use Cenários de Teste e a CLI.

Abra o Apidog, escolha uma requisição e crie seu primeiro Script Personalizado para automatizar a preparação e a validação em um único envio.