What is a Webhook? A Simple Example Without Code

The n8n Webhook node — your always-on doorbell for incoming data from any app.

🍕 Picture this: You order a pizza online. The restaurant doesn't ring you every two minutes asking whether you are still hungry. They take your order, make the pizza, and only when it is ready does a driver knock at your door. That knock — that one notification at exactly the right moment — is what a webhook is.

If you have ever searched for "what is a webhook" and walked away more confused than when you started, you are not alone. Most explanations are written for backend developers, not for the business owners and automation builders who actually need to use them every day. This guide fixes that.

By the time you finish reading, you will know exactly what a webhook is, how it differs from a normal API call, where it fits inside a real business workflow, and — most importantly — how to build a live, working webhook in n8n in under 20 minutes without touching a single line of code.

What is a Webhook?

Let's start from scratch — no jargon, no assumed knowledge.

Every app you use stores data and fires events. A customer fills out your contact form: that's an event. A payment is processed on Stripe: that's an event. A file is uploaded to Google Drive: that's an event. Traditionally, if you wanted a second app to react to those events, you had two options: connect them manually, or build a "polling" system that checks every few minutes for anything new.

Webhooks are the third — and far better — option. Instead of waiting for someone to check, the source app announces itself the second the event happens.

The Technical Definition (Made Simple)

A webhook is simply an HTTP POST request that a source application sends to a destination URL you define — called the webhook endpoint. The request carries a payload: a small package of data (usually JSON) describing what just happened.

Think of a webhook as a doorbell. You don't stand at the door all day checking if someone is there. You install a bell, give the address to anyone who might visit, and wait for it to ring. The Webhook node in n8n is that doorbell. — From real-world n8n testing at TriggerWorkflow

The Three Parts of Every Webhook

1. The Event: Something that happens in the source app — "new order placed," "form submitted," "payment failed."
2. The Payload: A JSON object containing the event details — customer name, order ID, amount, timestamp, etc.
3. The Endpoint: The URL that receives the payload — in our case, the URL generated by n8n's Webhook node.

A Brief History: Where Did Webhooks Come From?

The term "webhook" was coined by developer Jeff Lindsay in 2007 as a way to create "user-defined HTTP callbacks." The idea was simple: give non-developers a way to subscribe to application events without requiring deep API integrations. GitHub adopted webhooks early, followed by Stripe, PayPal, Shopify, and eventually almost every major SaaS platform. Today, webhooks power billions of real-time data transfers every day.

According to Zapier's developer documentation, webhooks are now supported by over 95% of major integration-ready platforms — making them the universal language of automation.

Webhook vs API: What is the Real Difference?

This is the question that trips up almost every beginner. Both webhooks and APIs move data between applications — but they work in completely opposite ways, and choosing the wrong one wastes time and money.

Side-by-Side Comparison

The Cost Difference in Practice

Imagine you want to know when a new Typeform submission arrives. Using a polling trigger set to check every minute, n8n executes 1,440 times per day — even if zero forms are submitted. Using a webhook, it executes exactly once per submission. If you get 50 submissions a day, that is 1,440 executions vs 50 — a 96.5% reduction in execution count, which directly extends your free tier or reduces your cloud bill.

When Polling is Still the Right Choice

Webhooks are not always the answer. There are cases where polling makes more sense:

• The source app does not support webhooks — many legacy tools (older CRMs, internal databases) have no outgoing webhook support. Polling via API is your only option.
• You need to fetch historical data — webhooks only fire for future events. To import past records, you pull via API.
• You want to check for a condition, not an event — "Is the inventory below 10 units?" is a question you ask on a schedule, not something a webhook can push to you.

6 Real-World Webhook Use Cases for Small Businesses

Webhooks sound technical until you see the actual business problems they solve. These are the six patterns I have personally built and tested for clients running e-commerce stores, freelance agencies, and service businesses.

How n8n Webhooks Work Under the Hood

You do not need to understand this to build webhooks, but knowing it will save you hours of debugging later.

The Request Lifecycle

When an external app sends data to your n8n webhook URL, here is exactly what happens in sequence:

1. HTTP POST arrives at your n8n server on the webhook path you defined (e.g., /webhook/incoming-data).
2. n8n validates the request: checks the path, method (GET/POST), and — if you configured one — a secret header value.
3. The workflow executes: n8n passes the entire request as the first node's output, including headers, body, query parameters, and IP address.
4. n8n responds to the sender: by default it immediately returns a 200 OK with a small JSON acknowledgment. This tells the sender "I got it."
5. The rest of your workflow continues: all downstream nodes run after the response is sent (unless you use "Respond to Webhook" mode).

What the Incoming Data Looks Like

Inside your n8n workflow, the Webhook node output contains the full request. For a POST with a JSON body, the structure looks like this:

{
  "headers": {
    "content-type": "application/json",
    "x-webhook-secret": "your-secret-here",
    "user-agent": "Stripe/1.0"
  },
  "params": {},
  "query": {},
  "body": {
    "event": "payment_intent.succeeded",
    "customer_name": "Alice Martin",
    "customer_email": "[email protected]",
    "amount": 4900,
    "currency": "usd",
    "order_id": "ORD-20260615-0042"
  }
}

In your subsequent nodes, you reference this data using n8n expressions:

• {{ $json.body.customer_name }} → Alice Martin
• {{ $json.body.amount / 100 }} → 49 (converting cents to dollars)
• {{ $json.headers['x-webhook-secret'] }} → your secret value for validation

Test URL vs Production URL: A Critical Distinction

This is the most common source of confusion for n8n beginners, and it has burned everyone at least once.

Build Your First Webhook in n8n (Step-by-Step, No Code)

We are going to build a real, working webhook that:

• Accepts a POST request from any app (or a manual test tool)
• Parses the incoming data
• Sends a formatted notification to Telegram — or logs it to Google Sheets if you prefer

Step-by-Step Instructions

{
  "name": "Alice Martin",
  "email": "[email protected]",
  "message": "I'm interested in your automation services.",
  "source": "contact-form"
}

If everything is working, n8n will show the received data in the node output panel. You will see $json.body.name, $json.body.email, etc.

📬 *New Webhook Received*

👤 Name: {{ $json.customer_name }}
📧 Email: {{ $json.customer_email }}
💬 Message: {{ $json.message_preview }}
🕐 Received: {{ $json.received_at }}

Routing Multiple Event Types with a Switch Node

Most webhook sources send different event types to the same URL. Stripe, for example, sends payment_intent.succeeded, customer.subscription.deleted, and charge.refunded all to one endpoint. A Switch node lets you handle each differently without building separate workflows.

Add a Switch node after the Set node. Create rules like:

• If {{ $json.body.event }} equals payment_intent.succeeded → Branch 1: send invoice email
• If {{ $json.body.event }} equals charge.refunded → Branch 2: send refund confirmation + log to Sheets
• Default → Branch 3: log unknown events to a monitoring sheet

This is the exact pattern used in production at several of the businesses I work with. One webhook URL, one workflow, multiple intelligent branches.

Webhook Security: How to Lock Down Your Endpoint

An open webhook URL is a public HTTP endpoint. In theory, anyone who knows your URL can send fake data to it and trigger your workflow. In practice, this is rarely exploited — but it is a real risk you should address before going to production with anything business-critical.

Method 1: Webhook Secret (Recommended)

Most platforms (Stripe, GitHub, Shopify) sign their webhook payloads with a secret. They add a special header — like X-Stripe-Signature or X-Hub-Signature-256 — containing an HMAC hash of the payload. In n8n, you can validate this header in a Code node before processing the data.

For simpler cases (Typeform, Tally, custom apps), use n8n's built-in Header Auth. In the Webhook node settings, set Authentication to "Header Auth." This requires the sending app to include a specific header — X-Webhook-Token: your-secret-value — or n8n will reject the request with a 401 error.

Security Checklist Before Going Live

• Use HTTPS exclusively — never expose a webhook on HTTP in production.
• Set Header Auth or validate the platform signature in a Code node.
• Add an Error Trigger workflow that alerts you when executions fail.
• Validate that $json.body contains expected fields before processing — use an IF node to guard against malformed payloads.
• Log all incoming webhook events to a Google Sheet for an audit trail.

Webhook Troubleshooting: The 6 Most Common Problems

I have debugged more failed webhooks than I can count. Here are the six problems that account for about 90% of webhook failures, and exactly how to fix each one.

Free Download: Webhook Workflow JSON

Import this workflow into n8n in under 60 seconds: Workflows → Import from File. Replace the Telegram credential placeholder with your actual bot credentials.

{
  "name": "Webhook to Telegram Logger",
  "nodes": [
    {
      "parameters": {
        "path": "incoming-data",
        "responseMode": "onReceived",
        "options": {}
      },
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "values": {
          "string": [
            { "name": "customer_name",  "value": "={{ $json.body.name }}"    },
            { "name": "customer_email", "value": "={{ $json.body.email }}"   },
            { "name": "message",        "value": "={{ $json.body.message }}" },
            { "name": "received_at",    "value": "={{ new Date().toISOString() }}" }
          ]
        },
        "options": {}
      },
      "name": "Set",
      "type": "n8n-nodes-base.set",
      "typeVersion": 2,
      "position": [450, 300]
    },
    {
      "parameters": {
        "chatId": "YOUR_TELEGRAM_CHAT_ID",
        "text": "📬 *New Webhook Received*\n\n👤 Name: {{ $json.customer_name }}\n📧 Email: {{ $json.customer_email }}\n💬 Message: {{ $json.message }}\n🕐 Time: {{ $json.received_at }}",
        "additionalFields": { "parse_mode": "Markdown" }
      },
      "name": "Telegram",
      "type": "n8n-nodes-base.telegram",
      "typeVersion": 1,
      "position": [680, 300],
      "credentials": { "telegramApi": { "id": "YOUR_TELEGRAM_CREDENTIAL_ID" } }
    }
  ],
  "connections": {
    "Webhook": { "main": [[{ "node": "Set",      "type": "main", "index": 0 }]] },
    "Set":     { "main": [[{ "node": "Telegram", "type": "main", "index": 0 }]] }
  },
  "active": false,
  "settings": { "executionOrder": "v1" }
}

Frequently Asked Questions

Continue Learning on TriggerWorkflow

Webhooks are the foundation of nearly every real-time automation. Now that you understand them, these guides will help you solve the most common problems and build more advanced workflows: