n8n Without the Testing Node

If you don’t want to install the Mibo Testing Node, you can send traces from n8n to Mibo using a standard HTTP Request node. This is useful if you want to get started quickly, can’t install community nodes, or prefer to keep your workflow self-contained.

Note

The Mibo Testing Node provides auto-detection of workflow nodes, automatic compression for large payloads, HTTP Request parameter resolution, and x-request-id correlation for active testing. If you need these features, consider installing the node instead.

Prerequisites

• A Mibo project with an n8n platform configured
• A Mibo API key for that project (create one in Settings > API Keys)
• Your platform ID (find it in the platform settings page)

How it works

You add two nodes at the end of your workflow:

1. A Code node that collects outputs from your workflow nodes and builds the trace payload
2. An HTTP Request node that sends the payload to Mibo’s trace endpoint

Step-by-step setup

1. Add a Code node

   Add a Code node at the end of your workflow, after all the nodes you want to capture. This node will build the trace payload.

   Paste this code into the Code node. It builds the trace payload in the optimized format that Mibo expects:

   // Collect outputs from the nodes you want to trace.
   // Replace these node names with your actual workflow node names.
   const nodesToCapture = ['Webhook', 'AI Agent', 'HTTP Request'];
   
   const traceData = {};
   
   for (const nodeName of nodesToCapture) {
     try {
       const nodeOutput = $node[nodeName].json;
       traceData[nodeName] = {
         output: nodeOutput,
         type: 'unknown', // n8n doesn't expose node types in expressions
         status: 'success'
       };
     } catch (e) {
       // Node didn't execute or doesn't exist, skip it
     }
   }
   
   // If you have an AI Agent node with tool calls, include them:
   // traceData['AI Agent'].tools_called = [
   //   { name: 'search', input: { query: '...' }, output: { results: [...] } }
   // ];
   
   return {
     json: {
       payload: {
         data: {
           status: 'success',
           data: traceData,
           metadata: {
             workflow_id: $workflow.id,
             workflow_name: $workflow.name,
             timestamp: new Date().toISOString()
           }
         },
         platformId: 'YOUR_PLATFORM_ID',
         metadata: {
           workflowId: $workflow.id
         }
       }
     }
   };

   Replace nodesToCapture with the names of the nodes in your workflow that you want Mibo to evaluate. Replace YOUR_PLATFORM_ID with your actual platform ID.

   Tip

   You don’t need to capture every node, just the ones relevant to your test assertions. For example, if you only care about what the AI Agent said and which tools it called, you can skip utility nodes like Set, If, or Merge.

2. Add an HTTP Request node

   Add an HTTP Request node after the Code node.

   Configure it with these settings:

   • Method: POST
   • URL: https://api.mibo-ai.com/public/traces
   • Authentication: Header Auth
     • Name: x-api-key
     • Value: your Mibo API key
   • Send Body: JSON
   • Body Content Type: JSON
   • JSON: use an expression to reference the Code node output:

     {{ $json.payload }}

3. Activate and test

   Save your workflow, then trigger it (e.g., by sending a message to the webhook). Check your Mibo dashboard. You should see a new trace appear for the platform.

Simplified example: text only

If you just need semantic assertions (no node-level checks), you can skip the Code node entirely and send a minimal payload directly from the HTTP Request node:

{
  "data": {
    "text": "{{ $node['AI Agent'].json.text }}"
  },
  "platformId": "YOUR_PLATFORM_ID"
}

This is enough for semantic, response_regex, json_match, and json_schema assertions.

Including tool calls

If your AI Agent node returns tools_called in its output, you can include them in the trace to enable node_call + expected_tool_calls assertions:

// In the Code node
const agentOutput = $node['AI Agent'].json;

return {
  json: {
    payload: {
      data: {
        status: 'success',
        data: {
          'AI Agent': {
            output: agentOutput,
            type: '@n8n/n8n-nodes-langchain.agent',
            status: 'success',
            tools_called: agentOutput.tools_called || []
          }
        }
      },
      platformId: 'YOUR_PLATFORM_ID'
    }
  }
};

Limitations compared to the Testing Node

Feature	Testing Node	HTTP Request approach
Node auto-detection	Yes: discovers all nodes automatically	No: you manually list nodes to capture
HTTP Request node parameters	Yes: with n8n API Key	No: only the node’s response output
Automatic compression	Yes: gzip for payloads > 5 MB	No
x-request-id correlation	Yes: auto-detects from webhook headers	No: active testing won’t match traces
Node type detection	Yes: includes full n8n type identifiers	No: type must be set manually or as "unknown"
Setup effort	Install once, works for all workflows	Build the Code node per workflow

Caution

Active testing limitation: Without x-request-id correlation, Mibo cannot match webhook-triggered test executions to traces sent via this approach. This method works best for passive testing (production monitoring). For active testing, use the Mibo Testing Node or API polling.

n8n Trace Format Reference Full specification of the trace data formats Mibo accepts for n8n.

Install the Mibo Testing Node For automatic node detection, compression, and active testing support.