# Example: HTTP Webhook Workflow
Learn to create a simple webhook that receives HTTP requests and processes data.
## What You'll Build
A webhook workflow that:
1. Receives HTTP POST requests
2. Extracts data from request body
3. Logs the data
4. Returns success response
**Time Required:** 10 minutes
**Difficulty:** Beginner
**Prerequisites:** None
---
## Problem Statement
You need an endpoint that receives webhook notifications from external services (e.g., GitHub, Stripe, payment processors) and logs the received data for debugging and monitoring purposes.
**Real-World Use Cases:**
- Receive payment notifications from Stripe
- Log GitHub webhook events
- Process form submissions
- Monitor API callbacks
- Debugging third-party integrations
---
## Solution Architecture
```
HTTP POST Request
↓
[Webhook Node] → Receives request, extracts body
↓
[Code Node] → Logs data to console
↓
[Response] → Returns 200 OK
```
**Workflow Characteristics:**
- **Trigger:** HTTP Webhook
- **Nodes:** 2 (Webhook, Code)
- **Complexity:** Simple
- **Response Time:** <100ms
---
## Step-by-Step Tutorial
### Step 1: Start Conversation in Claude Desktop
```
You: "I need to create a webhook workflow in my staging environment that logs incoming requests"
Claude: I'll help you create a webhook workflow in staging. Let me use the http-webhook-workflow prompt to generate the structure.
[MCP tool call: create_workflow]
{
"instance": "staging",
"name": "Webhook Logger",
"nodes": [
{
"id": "webhook_1",
"name": "Webhook",
"type": "n8n-nodes-base.webhook",
"typeVersion": 1,
"position": [250, 300],
"parameters": {
"path": "webhook-logger",
"responseMode": "onReceived",
"options": {}
}
},
{
"id": "code_1",
"name": "Log Data",
"type": "n8n-nodes-base.code",
"typeVersion": 2,
"position": [450, 300],
"parameters": {
"mode": "runOnceForAllItems",
"jsCode": "// Log incoming webhook data\nconst data = $input.all();\n\nconsole.log('='.repeat(50));\nconsole.log('Webhook Received:', new Date().toISOString());\nconsole.log('Data:', JSON.stringify(data, null, 2));\nconsole.log('='.repeat(50));\n\n// Return the data for next nodes\nreturn data;"
}
}
],
"connections": {
"Webhook": {
"main": [[{ "node": "Log Data", "type": "main", "index": 0 }]]
}
},
"active": false
}
✅ Workflow "Webhook Logger" created successfully in "staging"
Details:
- ID: 123
- Webhook URL: https://staging.app.n8n.cloud/webhook/webhook-logger
- Status: Inactive (activate when ready)
- Nodes: 2 (Webhook, Log Data)
The webhook will log all incoming POST requests to the n8n console.
```
---
### Step 2: Activate the Workflow
```
You: "Activate this workflow"
Claude: I'll activate the workflow now.
[MCP tool call: activate_workflow]
{
"instance": "staging",
"id": "123"
}
✅ Workflow activated successfully
The webhook is now live at:
https://staging.app.n8n.cloud/webhook/webhook-logger
You can test it with:
curl -X POST https://staging.app.n8n.cloud/webhook/webhook-logger \
-H "Content-Type: application/json" \
-d '{"test": "data", "timestamp": "2025-01-15T10:30:00Z"}'
```
---
### Step 3: Test the Webhook
#### Using curl:
```bash
curl -X POST https://staging.app.n8n.cloud/webhook/webhook-logger \
-H "Content-Type: application/json" \
-d '{
"event": "user.signup",
"user_id": 12345,
"email": "user@example.com",
"timestamp": "2025-01-15T10:35:00Z"
}'
```
**Expected Response:**
```json
{"status":"ok"}
```
#### Using Postman:
1. **Method:** POST
2. **URL:** `https://staging.app.n8n.cloud/webhook/webhook-logger`
3. **Headers:** `Content-Type: application/json`
4. **Body (raw JSON):**
```json
{
"event": "payment.success",
"amount": 49.99,
"currency": "USD",
"customer_id": "cus_12345"
}
```
#### Using JavaScript:
```javascript
fetch('https://staging.app.n8n.cloud/webhook/webhook-logger', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
event: 'form.submit',
name: 'John Doe',
email: 'john@example.com'
})
})
.then(response => response.json())
.then(data => console.log('Success:', data));
```
---
### Step 4: Verify Execution
```
You: "Show me the most recent execution for this workflow"
Claude: I'll retrieve the latest execution details.
[MCP tool call: list_executions]
{
"instance": "staging",
"workflowId": "123",
"limit": 1
}
Most recent execution:
- Execution ID: 9876
- Status: Success ✅
- Started: 2025-01-15 10:35:23
- Finished: 2025-01-15 10:35:23
- Duration: 245ms
- Mode: webhook
The workflow successfully processed your test request.
Check the n8n logs to see the logged data.
```
---
## Complete Workflow Definition
```json
{
"name": "Webhook Logger",
"nodes": [
{
"id": "webhook_1",
"name": "Webhook",
"type": "n8n-nodes-base.webhook",
"typeVersion": 1,
"position": [250, 300],
"parameters": {
"path": "webhook-logger",
"responseMode": "onReceived",
"options": {}
}
},
{
"id": "code_1",
"name": "Log Data",
"type": "n8n-nodes-base.code",
"typeVersion": 2,
"position": [450, 300],
"parameters": {
"mode": "runOnceForAllItems",
"jsCode": "// Log incoming webhook data\nconst data = $input.all();\n\nconsole.log('='.repeat(50));\nconsole.log('Webhook Received:', new Date().toISOString());\nconsole.log('Data:', JSON.stringify(data, null, 2));\nconsole.log('='.repeat(50));\n\nreturn data;"
}
}
],
"connections": {
"Webhook": {
"main": [[{ "node": "Log Data", "type": "main", "index": 0 }]]
}
},
"active": true,
"settings": {
"saveExecutionProgress": true,
"saveManualExecutions": true,
"saveDataErrorExecution": "all",
"saveDataSuccessExecution": "all"
}
}
```
---
## Testing Checklist
- [x] Webhook receives POST requests
- [x] Data logged to n8n console
- [x] Returns 200 OK response
- [x] Execution appears in history
- [x] Works with different JSON payloads
- [ ] Security: Add authentication (next step)
- [ ] Monitoring: Set up error alerts
---
## Viewing Logged Data
### Method 1: n8n UI
1. Open n8n UI
2. Navigate to **Executions** tab
3. Click on the execution
4. Select "Log Data" node
5. View the output in **Output** panel
### Method 2: Docker Logs (if using Docker)
```bash
docker logs n8n 2>&1 | grep "Webhook Received"
```
### Method 3: n8n Server Logs
```bash
# If running n8n locally
tail -f ~/.n8n/logs/n8n.log | grep "Webhook Received"
```
---
## Common Pitfalls
### Issue 1: Webhook Returns 404
**Symptoms:**
```bash
curl: (22) The requested URL returned error: 404
```
**Causes:**
- Workflow not activated
- Wrong webhook path in URL
- Typo in webhook path
**Solution:**
1. Verify workflow is active: `You: "Is workflow 123 in staging active?"`
2. Check webhook path matches URL
3. Ensure exact path spelling: `webhook-logger` not `webhook_logger`
---
### Issue 2: Data Not Logging
**Symptoms:**
- Webhook responds 200 OK
- But no logs appear in console
**Solution:**
1. Check n8n console logs (not browser console)
2. Open n8n UI → Executions → View Details
3. Click "Log Data" node to see output
4. Verify Code node has `console.log()` statement
---
### Issue 3: Workflow Not Triggering
**Symptoms:**
- No execution created when webhook called
- Webhook returns error
**Checklist:**
```
You: "Debug workflow 123 in staging - webhook not triggering"
Claude: I'll help debug. Let me check:
1. Is workflow active? ✓
2. Get workflow details to verify webhook configuration
3. Check recent executions for errors
```
**Common fixes:**
- Activate workflow
- Check webhook URL is correct
- Verify HTTP method (POST vs GET)
- Test with simple curl first
---
### Issue 4: Invalid JSON Error
**Symptoms:**
```
Error: Unexpected token in JSON at position 0
```
**Cause:** Sending non-JSON data to webhook expecting JSON
**Solution:**
```javascript
// ❌ Wrong - plain text
curl -d "test=data"
// ✅ Correct - JSON
curl -H "Content-Type: application/json" -d '{"test":"data"}'
```
---
## Next Steps
### 1. Add Data Validation
Enhance workflow to validate incoming data:
```
You: "Add validation to workflow 123 to check that 'email' and 'user_id' fields exist"
Claude: I'll add an IF node for validation.
[Adds validation node between Webhook and Log Data]
```
### 2. Add Error Handling
Handle malformed requests gracefully:
```javascript
{
"name": "Error Handler",
"type": "n8n-nodes-base.code",
"parameters": {
"jsCode": "try {\n const data = $input.all();\n // Validate required fields\n if (!data[0].json.email) {\n throw new Error('Missing email field');\n }\n return data;\n} catch (error) {\n console.error('Validation error:', error.message);\n return [{ json: { error: error.message } }];\n}"
}
}
```
### 3. Store Data in Database
Connect to PostgreSQL, MongoDB, or other database:
```
You: "Add a PostgreSQL node after the logger that saves the webhook data to a 'webhook_events' table"
```
### 4. Send Notifications
Alert team on specific events:
```
You: "Add a Slack notification when the webhook receives a 'payment.failed' event"
```
---
## Real-World Enhancement Examples
### Example 1: GitHub Webhook Handler
```json
{
"name": "GitHub Webhook Handler",
"nodes": [
{
"name": "Webhook",
"parameters": { "path": "github-events" }
},
{
"name": "Extract Event Type",
"type": "n8n-nodes-base.code",
"parameters": {
"jsCode": "const event = $json.headers['x-github-event'];\nconst action = $json.body.action;\nreturn [{ json: { event, action, data: $json.body } }];"
}
},
{
"name": "Route by Event",
"type": "n8n-nodes-base.switch",
"parameters": {
"rules": [
{ "value": "push" },
{ "value": "pull_request" },
{ "value": "issue" }
]
}
}
]
}
```
### Example 2: Stripe Payment Webhook
```json
{
"name": "Stripe Payment Webhook",
"nodes": [
{
"name": "Webhook",
"parameters": { "path": "stripe-payments" }
},
{
"name": "Verify Stripe Signature",
"type": "n8n-nodes-base.code",
"parameters": {
"jsCode": "// Verify webhook signature for security\nconst stripe = require('stripe');\nconst signature = $json.headers['stripe-signature'];\n// Validation logic here\nreturn [$json];"
}
},
{
"name": "Process Payment",
"type": "n8n-nodes-base.switch"
}
]
}
```
---
## Key Takeaways
✅ **Learned:**
- Create simple webhook workflows via Claude Desktop
- Activate and test webhooks
- View execution logs
- Debug common webhook issues
✅ **Best Practices:**
- Always test in staging first
- Validate incoming data
- Log important events
- Monitor webhook executions
✅ **Next Level:**
- Add authentication
- Implement data validation
- Store data persistently
- Send notifications on events
---
**Estimated Reading Time:** 15 minutes
**Hands-On Time:** 10 minutes
**Total Time:** 25 minutes
