Build Custom Webhooks Without Coding Tools

What You'll Need

• n8n Cloud or self-hosted n8n
• Hetzner VPS or Contabo VPS for hosting (optional, for self-hosted)
• Namecheap if you need a custom domain
• DigitalOcean as an alternative hosting provider

Table of Contents

• What You'll Need
• Understanding Webhooks Without the Code
• Setting Up Your First Webhook Receiver
• Building Webhook Workflows That React to Data
• Transforming and Routing Webhook Payloads
• Testing Your Webhooks in Production
• Getting Started

Understanding Webhooks Without the Code

I've spent the last three years building automation systems, and here's what I've learned: webhooks are the nervous system of any modern workflow. They're how your apps talk to each other in real-time without polling databases constantly.

Most people think you need to write code to handle webhooks. You don't. Not anymore.

A webhook is just an HTTP request—typically POST or GET—sent from one application to another when something happens. Your Shopify store processes an order, it sends a webhook. Someone fills out your form, it fires a webhook. Your payment processor confirms a transaction, webhook. All of these can trigger downstream actions without touching a single line of code.

The old way required you to spin up a server, write endpoint handlers, manage SSL certificates, and pray your error handling caught edge cases. n8n Cloud flips this entirely. You get a webhook URL instantly, point any service at it, and build logic visually.

When you're comparing automation platforms—and if you're evaluating options, I'd recommend reading about Make vs n8n vs Zapier API integrations 2026—you'll notice n8n gives you the most control over webhook behavior without forcing you into the paid tiers for custom logic.

Setting Up Your First Webhook Receiver

Let me walk you through creating a webhook that listens for incoming data.

Log into n8n Cloud. Click "New" and start a blank workflow.

In the left sidebar, search for the "Webhook" node. Drag it onto your canvas. This is your listening post.

Here's what you'll see in the node settings:

{
  "method": "POST",
  "path": "webhook/my-first-webhook",
  "responseCode": 200,
  "responseData": "success",
  "nodeCredentialType": "httpBasicAuth",
  "authentication": "none"
}

That path becomes part of your unique webhook URL. If your n8n instance lives at https://n8n.chasebot.online, your webhook lands at https://n8n.chasebot.online/webhook/my-first-webhook.

Leave authentication as "none" for now—we'll secure it later. Click the "Webhook" node again and you'll see a blue button that says "Execute Webhook". Click it, and n8n generates a unique, testable URL.

Now add a second node: search for "Set" in the left sidebar. Connect the Webhook node to Set by dragging the output dot. In the Set node, you're going to map the incoming webhook data to fields you want to use downstream.

The webhook payload arrives as $json in n8n. Here's what that configuration looks like:

{
  "assignments": [
    {
      "name": "incoming_email",
      "value": "{{ $json.body.email }}",
      "type": "string"
    },
    {
      "name": "incoming_name",
      "value": "{{ $json.body.name }}",
      "type": "string"
    },
    {
      "name": "incoming_timestamp",
      "value": "{{ $json.headers['x-timestamp'] }}",
      "type": "string"
    }
  ]
}

The dollar-sign syntax is n8n's expression language. $json.body.email pulls the email field from whatever JSON was sent to your webhook. $json.headers grabs HTTP headers.

Now test it. In n8n Cloud, click the blue "Execute Webhook" button and copy the URL. Open a new browser tab and use an online webhook testing tool (RequestBin, Webhook.cool, or even curl from your terminal):

curl -X POST https://webhook.n8n.cloud/[YOUR-UNIQUE-URL] \
  -H "Content-Type: application/json" \
  -d '{"name":"Sarah Chen","email":"sarah@example.com"}'

Watch your n8n workflow execute. You'll see the data flow through the Webhook node, then the Set node transforms it. That's it. No server. No code. No DevOps nightmare.

💡 Fast-Track Your Project: Don't want to configure this yourself? I build custom n8n pipelines and bots. Message me with code SYS3-DEVTO.

Building Webhook Workflows That React to Data

Now that you have incoming data, let's do something with it.

I'm going to show you a real workflow: receiving a webhook from a form submission, then triggering different actions based on what's in the payload.

Start fresh. Add a Webhook node. This time, in the node settings, click "Add Field" under "Request Body Schema". Manually define the shape of data you expect:

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "User email address"
    },
    "product_id": {
      "type": "string",
      "description": "Which product was clicked"
    },
    "source": {
      "type": "string",
      "enum": ["web", "mobile", "api"],
      "description": "Where the request came from"
    }
  },
  "required": ["email", "product_id"]
}

This schema validates incoming webhooks. If someone sends a webhook without email and product_id, n8n rejects it with a 400 error and logs the mismatch. This saves you from garbage data tanking your downstream workflow.

Next, add a conditional node. Search for "If" in the left sidebar. Connect the Webhook output to it.

In the If node, set up a condition:

{
  "conditions": [
    {
      "value1": "{{ $json.source }}",
      "operation": "equals",
      "value2": "mobile"
    }
  ],
  "combineOperation": "any"
}

This branches your workflow: if the source is "mobile", take the true branch; otherwise, take the false branch.

From the true branch, add a node that sends a Slack message (search for "Slack" in the node library and authenticate with your workspace). Connect it to the true output of your If node:

{
  "channel": "#sales-alerts",
  "text": "📱 Mobile signup from {{ $json.email }} – Product: {{ $json.product_id }}",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Mobile Conversion Alert*\nEmail: {{ $json.email }}\nProduct ID: {{ $json.product_id }}"
      }
    }
  ]
}

From the false branch, add a different Slack message (or any other action—email, database write, webhook forward, etc.).

Deploy this workflow. Now whenever anyone submits a form or triggers an external webhook pointing to your n8n instance, it automatically routes notifications based on the source. Mobile users get flagged in a specific channel. Web users go elsewhere.

This scales to dozens of branches. The visual canvas lets you see the entire logic at once, which beats digging through code files any day.

Transforming and Routing Webhook Payloads

Here's where things get powerful. Many webhooks arrive in messy formats. Your Stripe webhook looks different from your Shopify webhook. Your custom app payload doesn't match your form plugin's structure.

You need to normalize them.

Add a "Function" node (search for it in the node library). This is JavaScript you can write without leaving the visual interface. Don't worry—it's sandboxed and forgiving.

Here's a practical example: you're receiving webhooks from multiple sources, and you want to standardize all of them into a single format before storing them in a database:

const sourceType = $json.source_system || 'unknown';
const timestamp = new Date().toISOString();

let standardizedPayload = {
  id: generateId(),
  source: sourceType,
  receivedAt: timestamp,
  data: {}
};

if (sourceType === 'shopify') {
  standardizedPayload.data = {
    customerId: $json.customer_id,
    orderId: $json.order_id,
    total: $json.total_price,
    email: $json.customer_email,
    createdAt: $json.created_at
  };
} else if (sourceType === 'stripe') {
  standardizedPayload.data = {
    customerId: $json.customer,
    orderId: $json.id,
    total: $json.amount / 100,
    email: $json.metadata?.email || null,
    createdAt: new Date($json.created * 1000).toISOString()
  };
} else if (sourceType === 'custom_form') {
  standardizedPayload.data = {
    customerId: $json.user_id,
    orderId: $json.submission_id,
    total: parseFloat($json.price) || 0,
    email: $json.email_address,
    createdAt: $json.timestamp
  };
}

function generateId() {
  return 'evt_' + Math.random().toString(36).substr(2, 9);
}

return standardizedPayload;

After this Function node runs, every webhook—whether it came from Shopify, Stripe, or your custom form—exits with the same structure:

{
  "id": "evt_a1b2c3d4e",
  "source": "shopify",
  "receivedAt": "2024-01-15T14:32:00.000Z",
  "data": {
    "customerId": "cust_12345",
    "orderId": "order_67890",
    "total": 99.99,
    "email": "user@example.com",
    "createdAt": "2024-01-15T14:31:00.000Z"
  }
}

Now you can connect this to a single database write, a single API call, or a single downstream workflow—no branching logic needed. One format in, one action out.

This is where the power emerges. If you're running multiple systems on limited resources—and if you're interested in optimization, I wrote about How I Run 3 Automated Systems on a Single $7/Month VPS—normalizing payloads at the webhook layer saves you compute cycles throughout your entire architecture.

Testing Your Webhooks in Production

You can't debug what you can't see. Before pushing a webhook workflow live, you need visibility.

n8n Cloud has built-in execution history. Every time a webhook fires, n8n logs the input, the transformations, and the output. Click on any execution and drill into each node to see exactly what data passed through.

For manual testing before going live, use the "Execute Webhook"

Originally published on Automation Insider.