Circuitry Logo
Circuitry
Open Circuitry

🪝 Webhooks - The Power of Real-Time Integration

Webhooks are the backbone of modern automation, and Circuitry turns them into AI-powered workflows that can transform your business processes.

What Are Webhooks?

Webhooks are automated messages sent from apps when something happens. They're like SMS notifications for your applications - instant, automatic, and actionable.

The Circuitry Advantage

While other platforms just receive webhooks, Circuitry adds intelligent AI processing to every webhook event:

  1. Receive Event → 2. Process with AI → 3. Take Smart Actions → 4. Send Response

🚀 Tutorial: Build and Test a Webhook

This walkthrough takes you from an empty canvas to a working, tested webhook that you can build real logic on — using Listen to capture the exact shape of an incoming request, then wiring a Code node against that data.

Step 1 — Add a webhook trigger

  1. Create a new workflow (or open one) and save it into a project — webhooks live inside a project.
  2. From the node palette, drag in a Webhook node. It drops ready to receive requests — already in webhook mode with its own URL. (You can also turn any existing Start node into a webhook by opening it and setting Trigger mode to Webhook.)
  3. (Optional) Open the node and set a Webhook Path — a friendly name like orders/new. Leave it blank to use the workflow's id.
  4. Copy the Webhook Execution URL. It looks like: 
    https://circuitry.dev/api/webhook/<your-name>/<your-project>/<path>

Under Hosted on you can choose where the webhook runs: circuitry.dev (the default hosted option) or your own EServer.

Step 2 — Deploy it

A webhook only goes live once it's published to the cloud — saving to your editor isn't enough on its own.

  1. In the node's Deployment section, watch the status pill. A brand-new webhook shows ○ Not deployed.
  2. Click Deploy webhook. The pill turns ● Live — the URL will now accept requests.
  3. If you edit the webhook later, the pill shows ◐ Undeployed changes — click Redeploy to publish them.

The URL only works while the webhook is Live. If it shows Not deployed, deploy before testing.

Step 3 — Capture the real request shape (Listen)

Instead of guessing the JSON, capture a real request so you can build against the exact structure:

  1. In the webhook node, click Listen for request (or right-click the node → Listen for request).
  2. The node starts pulsing — it's waiting for the next call to your URL.
  3. Trigger the webhook from your other app or no-code tool — Stripe, Make, Zapier, or a quick test: 
    curl -X POST "https://circuitry.dev/api/webhook/<your-name>/<your-project>/<path>" \
  -H "Content-Type: application/json" \
  -d '{ "event": "order.created", "order": { "id": "ord_5571", "total": 129.99 } }'
  4. The node turns green, a toast confirms the capture, and the payload appears in the node's output.

While you're listening, the request is only captured for inspection — your workflow does not run — so it's safe to do this before you've built any downstream nodes. Listening stops automatically after a couple of minutes if nothing arrives.

Step 4 — Inspect the captured data

Open the webhook node's config panel: the captured request is shown in the output area at the bottom (you can also hover the node to see it). It contains everything the request carried:

{
  "method": "POST",
  "headers": { "content-type": "application/json", "x-request-id": "req_abc123" },
  "query": {},
  "path": "orders/new",
  "body": {
    "event": "order.created",
    "order": { "id": "ord_5571", "total": 129.99 }
  }
}

Now you know the real structure — body.order.id, body.order.total, the headers, and so on.

Step 5 — Use the data in a Code node

  1. Add a Code node and connect the webhook into it.
  2. Open the Code node. The webhook's output is shown as the node's input — an expandable tree of every field.
  3. Drag a field straight from the tree into the code box to insert a reference to it (or click a field to copy its path). No need to type paths by hand.

The incoming data is available as the input object. Code nodes run JavaScript or Python — pick your language below:

const order = input.body.order

return {
  orderId: order.id,
  total: order.total,
  isLarge: order.total > 100
}

Step 6 — Reference data anywhere with template variables

In other node types — Agent prompts, HTTP requests, conditions — reference the incoming data with template variables:

  • {{input}} — the entire output of the previous node
  • {{input.body.order.id}} — a single field, using dot-paths

You can drag fields from the input tree into any of these fields too. For example, an Agent prompt:

A new order came in. Summarise it for the warehouse team.

Order id: {{input.body.order.id}}
Total: {{input.body.order.total}}

Step 7 — Go live

  1. If you changed anything after deploying, the pill shows ◐ Undeployed changes — Redeploy.
  2. Send a real request. This time (with no listen session armed) the full workflow runs.
  3. To control what the caller receives back, end your flow with a Webhook Response node — whatever it outputs becomes the HTTP response.

🔥 Powerful Webhook Workflows

E-commerce Order Intelligence

Trigger: Shopify order webhook Workflow:

Webhook → AI Analysis → Condition → [High Value] → Priority Processing
                                  → [Regular] → Standard Processing

AI Prompt:

Analyze this order:
- Determine customer lifetime value
- Identify upsell opportunities
- Flag any fraud indicators
- Generate personalized thank you message

Customer Support Automation

Trigger: Support ticket webhook (Zendesk, Intercom, etc.) Workflow:

Webhook → Sentiment Analysis → Route by Urgency → Generate Response → Send Reply

Benefits:

  • Instant response to customers
  • Intelligent routing based on content
  • AI-generated draft responses
  • Escalation for complex issues

Payment Processing Intelligence

Trigger: Stripe payment webhook Workflow:

Payment Webhook → Fork → [Fraud Check]
                      → [Customer Analysis]
                      → [Inventory Update]
                → Join → Send Confirmation

Development Workflow Automation

Trigger: GitHub push webhook Workflow:

Code Push → AI Code Review → Generate Summary → Post to Slack → Update Jira

🎯 No-Code Platform Integration

Circuitry becomes the AI brain for your no-code stack:

Zapier → Circuitry → Action

  1. Zapier Trigger: Any of 5000+ apps
  2. Send to Circuitry Webhook: Process with AI
  3. Receive Intelligent Response: Enhanced data
  4. Continue Zapier Workflow: With AI insights

Bubble.io Integration

// In Bubble workflow
1. When button clicked
2. Send data to Circuitry webhook
3. Receive AI-processed response
4. Update database with results

Make.com (Integromat) Scenarios

Connect Make scenarios to Circuitry for AI processing:

  • Data enrichment
  • Content generation
  • Decision making
  • Sentiment analysis

📊 Webhook Data Processing

Accessing Webhook Data

In your nodes, access webhook data using:

{{input.body}}          // Request body
{{input.headers}}       // HTTP headers
{{input.query}}         // Query parameters
{{input.method}}        // HTTP method
{{input.timestamp}}     // Receipt time

Parsing Different Formats

JSON Webhooks (most common):

const data = input.body;
const orderId = data.order.id;
const customer = data.order.customer;

Form-Encoded Data:

const formData = parseFormData(input.body);
const email = formData.email;

XML Webhooks:

const xmlData = parseXML(input.body);
const status = xmlData.root.status;

🔐 Security Best Practices

Webhook Verification

Verify webhooks are from legitimate sources:

  1. Signature Verification:
// In Condition node
const signature = input.headers['x-webhook-signature'];
const isValid = verifySignature(signature, input.body, SECRET_KEY);
  1. IP Whitelisting:
const allowedIPs = ['192.168.1.1', '10.0.0.1'];
const sourceIP = input.headers['x-forwarded-for'];
const isAllowed = allowedIPs.includes(sourceIP);
  1. Token Validation:
const token = input.headers['authorization'];
const isValid = token === process.env.WEBHOOK_TOKEN;

⚡ Advanced Webhook Patterns

Webhook Chaining

Create multi-stage workflows:

Webhook A → Process → Trigger Webhook B → Process → Trigger Webhook C

Webhook Aggregation

Collect multiple webhooks before processing:

// Store webhook data
const webhooks = storage.get('pending_webhooks') || [];
webhooks.push(input.body);

// Process when threshold reached
if (webhooks.length >= 10) {
  processBacklog(webhooks);
  storage.clear('pending_webhooks');
}

Webhook Response Handling

Send data back to the webhook sender:

// In final Action node
return {
  status: 200,
  body: {
    processed: true,
    result: aiAnalysis,
    nextSteps: recommendations
  },
  headers: {
    'Content-Type': 'application/json'
  }
};

🎨 Real-World Examples

AI-Powered Form Processing

Source: Typeform, Google Forms, JotForm Use Case: Intelligent form response handling

Form Webhook → Extract Data → AI Categorization → Route to Team → Generate Reply

Social Media Monitoring

Source: Twitter, Instagram, Facebook webhooks Use Case: Brand mention analysis

Social Webhook → Sentiment Analysis → Priority Check → Alert Team → Draft Response

IoT Device Integration

Source: IoT platforms (AWS IoT, Azure IoT) Use Case: Smart device automation

Device Event → AI Analysis → Condition Check → Trigger Actions → Log Results

🚦 Webhook Testing

Testing Your Webhooks

  1. Use Webhook Testing Tools:

    • webhook.site
    • requestbin.com
    • ngrok for local testing

  2. Send Test Payloads:

curl -X POST https://api.circuitry.app/webhooks/your-id \
  -H "Content-Type: application/json" \
  -d '{"test": true, "message": "Hello Circuitry"}'
  1. Monitor Execution:
    • View real-time execution in the editor
    • Check logs for detailed information
    • Use debug mode for troubleshooting

📈 Performance Optimization

Handling High Volume

For high-volume webhooks:

  1. Use Parallel Processing:
Webhook → Fork → [Process 1]
              → [Process 2]  → Join → Response
              → [Process 3]
  1. Implement Queuing:
// Quick acknowledge, process async
return { status: 200, queued: true };
// Process in background
  1. Cache Frequent Operations:
const cached = cache.get(webhookId);
if (cached) return cached;

🌟 Why Circuitry Webhooks Are Superior

  1. AI-Enhanced: Every webhook can trigger intelligent AI processing
  2. Visual Debugging: See exactly how your webhook data flows
  3. No Code Required: Build complex webhook handlers without programming
  4. Instant Deployment: Changes take effect immediately
  5. Scalable: Handles everything from simple notifications to complex orchestrations
  6. Secure: Built-in verification and security features
  7. Universal: Works with any service that can send HTTP requests

Next Steps