Set up Linkbreakers webhooks to receive real-time notifications for QR code scans, link clicks, and workflow completions. Integrate with CRM systems, marketing platforms, and custom applications with automatic retry and comprehensive event tracking.
Learn how to use webhooks to connect Linkbreakers with your external systems, receive real-time notifications for QR code scans and workflow events, and automate your marketing workflows.
A webhook is a powerful automation tool that allows Linkbreakers to send real-time notifications to your external systems whenever specific events occur in your workflows. Think of webhooks as a way for Linkbreakers to "call" your application instantly when something important happens, like when a QR code is scanned or a workflow step is completed.
In the modern marketing and technology landscape, webhooks have become essential for creating connected, automated systems. Rather than having your applications constantly check Linkbreakers for new events (a process called polling), webhooks flip the communication model around. Instead of you asking "has anything new happened?", Linkbreakers tells you immediately when something occurs. This event-driven architecture is more efficient, faster, and enables real-time integrations that would otherwise be impractical or impossible.
When you set up a webhook in Linkbreakers, you're essentially telling our system: "When this event happens, immediately send the details to my specified URL." This enables seamless integration between Linkbreakers and your existing tools, CRM systems, marketing platforms, or custom applications.
The webhook lifecycle follows a straightforward pattern. First, an event occurs in your Linkbreakers account, a visitor scans your QR code, clicks your link, or completes a workflow step. Within milliseconds, Linkbreakers detects this event and packages up all the relevant information about what just happened. This includes details about the visitor, their device, location, the specific action they took, and contextual information about your workflow.
Immediately after detecting the event, Linkbreakers sends an instant notification to your specified webhook URL as an HTTP POST request. This notification contains a rich JSON payload with comprehensive event data. Your application receives this data at your endpoint and can take immediate action based on the information provided. This might mean adding a new lead to your CRM, triggering an email sequence, updating a dashboard, or any other automated response your business needs.
The beauty of this real-time integration is that your systems stay perfectly synchronized with Linkbreakers activity. There's no delay, no periodic checking, and no risk of missing important events. The moment something happens in Linkbreakers, your systems know about it and can respond accordingly.
Linkbreakers webhooks provide robust features designed for enterprise-grade integration needs. Real-time notifications ensure you get instant alerts for workflow completions, QR scans, and link interactions without any polling or delay. Each webhook delivers rich event data containing comprehensive information about visitors, their devices, geographic locations, and the specific actions they've taken.
Reliability is built into the core of our webhook system. We've implemented a sophisticated retry mechanism with exponential backoff that ensures your webhooks are delivered even if your endpoint experiences temporary issues. The system maintains comprehensive tracking so you can monitor webhook success rates, review delivery history, and diagnose any integration problems quickly.
Configuration flexibility allows you to set up multiple webhooks pointing to different endpoints, enabling you to route events to various systems based on your integration architecture. Whether you're connecting to one system or orchestrating data flow across multiple platforms, Linkbreakers webhooks adapt to your needs.
Each webhook delivers a carefully structured JSON payload containing detailed information about the triggering event. The payload includes event details such as the action type, precise timestamp, visitor identification, and device information. You'll receive workflow information including which steps were completed, exit events, and progression data that shows how visitors moved through your funnel.
The link context tells you exactly which QR code or shortened link triggered the event, allowing you to attribute actions to specific campaigns or channels. Workspace information ensures you can properly route and organize data when working with multiple Linkbreakers accounts or environments.
We've designed the webhook payload to be sanitized, excluding sensitive internal data while providing all the information you need for integration. This approach balances security with functionality, giving you comprehensive event data without exposing system internals.
Here's what a typical webhook payload looks like:
1{
2 "event": {
3 "id": "0a2d9a3c-3f5a-483e-93e1-10b5bd04ac5b",
4 "deviceId": "ec1d32f1-e5aa-4b12-8ad2-26da282b7261",
5 "device": {
6 "id": "ec1d32f1-e5aa-4b12-8ad2-26da282b7261",
7 "workspaceId": "a39dbbfb-be5e-41c8-b49a-7c9ada520fa4",
8 "deviceType": "DESKTOP",
9 "deviceBrand": "Apple",
10 "browserName": "Chrome",
11 "browserVersion": "140.0.0.0",
12 "browserLanguage": "en-US,en;q=0.9",
13 "platformName": "macOS",
14 "platformVersion": "10.15.7",
15 "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
16 "ipAddress": "::1",
17 "lastUsedAt": "2025-10-10T16:12:20.516858Z",
18 "createdAt": "2025-10-10T16:12:20.598647Z",
19 "updatedAt": "2025-10-10T16:12:26.929197Z"
20 },
21 "leadScoreId": "d669af89-e4cb-42de-a02d-19cb73f0cbd6",
22 "leadScore": {
23 "id": "d669af89-e4cb-42de-a02d-19cb73f0cbd6",
24 "linkId": "a3332d06-1c43-4a23-a34e-259fa393581c",
25 "workspaceId": "a39dbbfb-be5e-41c8-b49a-7c9ada520fa4",
26 "leadScore": 45,
27 "educationLevel": 44,
28 "wealthIndicator": 32,
29 "technologicalAptitude": 45,
30 "professionalIntent": 66,
31 "engagementQuality": 53,
32 "recurringInterest": 33,
33 "createdAt": "2025-10-10T16:12:27.002775Z",
34 "updatedAt": "2025-10-10T16:12:27.002775Z"
35 },
36 "action": "SCAN",
37 "httpMethod": "GET",
38 "scannedAt": "2025-10-10T16:12:20.516858Z",
39 "triggeredBy": "VISITOR",
40 "link": {
41 "id": "a3332d06-1c43-4a23-a34e-259fa393581c",
42 "shortlink": "zqVNfSC9M",
43 "entrypoint": "http://localhost:8081/zqVNfSC9M",
44 "fallbackDestination": "https://linkbreakers.com",
45 "workspaceId": "a39dbbfb-be5e-41c8-b49a-7c9ada520fa4",
46 "qrcodeDesignId": "a08d4c4e-c879-40df-b54a-648e7c33c077",
47 "qrcodeTemplateId": "c8296eec-208e-4f49-8e0e-804bab5152c7",
48 "createdAt": "2025-10-10T15:55:45.078154Z",
49 "updatedAt": "2025-10-10T16:04:34.138945Z",
50 "eventCount": 1
51 },
52 "linkId": "a3332d06-1c43-4a23-a34e-259fa393581c",
53 "entrypoint": "http://localhost:8081/zqVNfSC9M",
54 "destination": "https://linkbreakers.com",
55 "workspace": {
56 "id": "a39dbbfb-be5e-41c8-b49a-7c9ada520fa4",
57 "name": "hkjhkjl",
58 "linkSettingId": "8452f9f4-2232-4695-858a-85b270104ea5",
59 "timezone": "UTC",
60 "country": "US",
61 "createdAt": "2025-10-01T08:36:27.154708Z",
62 "updatedAt": "2025-10-01T08:36:27.154708Z"
63 },
64 "workspaceId": "a39dbbfb-be5e-41c8-b49a-7c9ada520fa4",
65 "createdAt": "2025-10-10T16:12:20.59916Z",
66 "updatedAt": "2025-10-10T16:12:27.003281Z"
67 },
68 "webhook": {
69 "id": "42806ec9-1085-404a-b353-75b156cb71b3",
70 "name": "Test Webhook",
71 "endpointUrl": "https://webhook-test.com/74d9a9bae65ebaa1900ca1b1553617ef",
72 "status": "ACTIVE",
73 "workspaceId": "a39dbbfb-be5e-41c8-b49a-7c9ada520fa4",
74 "createdBy": "a36358fe-2749-40a3-8068-e94177a8d069",
75 "createdAt": "2025-10-09T21:59:53.506032Z",
76 "updatedAt": "2025-10-10T16:12:11.194332Z",
77 "lastSentAt": "2025-10-10T16:12:11.194332Z",
78 "lastDeliveredAt": "2025-10-10T16:12:11.194332Z",
79 "successCount": 13
80 },
81 "workflowStep": {
82 "id": "3bb8a4a0-80eb-4a36-863e-03e3ed5c2a1b",
83 "linkId": "a3332d06-1c43-4a23-a34e-259fa393581c",
84 "eventAction": "CLIENT_REDIRECT",
85 "payload": {
86 "conversion_tracking": false,
87 "destination": "https://linkbreakers.com"
88 },
89 "canvasPosition": {
90 "x": 433.8118591816531,
91 "y": 164.3681611778236
92 },
93 "kind": "EXIT",
94 "createdAt": "2025-10-10T15:55:45.085099Z",
95 "updatedAt": "2025-10-10T15:55:45.085099Z"
96 },
97 "timestamp": "2025-10-10T16:12:28.161007Z",
98 "type": "step.completed"
99}
100Linkbreakers provides different webhook limits based on your subscription plan to match your integration needs as your business grows. Free and Trial accounts include 1 webhook, which is perfect for testing integrations or connecting to a single system. Pro Plan subscribers receive 5 webhooks, allowing for more sophisticated multi-system integrations and separate webhooks for different purposes. Enterprise Plan customers enjoy unlimited webhooks, enabling complex integration architectures and redundant delivery systems.
Setting up a webhook in Linkbreakers is straightforward.
Your webhook endpoint needs to meet specific requirements to work properly with Linkbreakers. It must accept HTTP POST requests with JSON payloads, as this is the standard format for webhook delivery. When your endpoint successfully receives and processes a webhook, it should return a 2xx status code (like 200 OK) to confirm receipt. This acknowledgment tells Linkbreakers the delivery was successful and prevents unnecessary retry attempts.
Security is paramount for webhook integrations, so your endpoint must use HTTPS for secure communication. We don't allow unencrypted HTTP endpoints to protect your data and your customers' information. Additionally, your endpoint should handle requests within a reasonable timeout period, typically 10-30 seconds, to ensure smooth delivery and avoid blocking our webhook processing queue.
Reliability is critical for webhook integrations, which is why Linkbreakers has built robust delivery assurance into the system. When a webhook delivery fails, perhaps your endpoint is temporarily unavailable or experiencing high load, our system doesn't simply give up. Instead, it automatically retries delivery up to 3 times using exponential backoff.
Exponential backoff means the system waits progressively longer between each retry attempt. The first retry might happen after a few seconds, the second after 30 seconds, and the third after several minutes. This approach gives your endpoint time to recover from temporary issues while still ensuring eventual delivery of important events. Throughout this process, Linkbreakers maintains a complete audit trail of all delivery attempts, allowing you to investigate any delivery issues and understand exactly what happened.
While occasional webhook failures are normal and handled gracefully by the retry system, consistent failures indicate a more serious problem that needs attention. If a webhook endpoint fails consistently, specifically, after 10 or more consecutive failures, Linkbreakers will automatically disable the webhook to prevent resource waste and alert you to the problem.
When this happens, you'll receive an email notification explaining the situation and providing details about the failures. This automated disabling protects both your system and ours from repeatedly attempting to deliver to a non-functional endpoint. Once you've resolved the underlying issue, whether it was a misconfigured URL, a server problem, or an application bug, you can easily re-enable the webhook through your dashboard.
Speed matters for real-time integrations, which is why webhooks are processed through a high-priority background queue in our infrastructure. This dedicated processing ensures webhook deliveries aren't delayed by other system operations.
In typical conditions, webhooks are delivered within seconds of the triggering event, often in under 2-3 seconds. This near-instantaneous delivery enables truly real-time integrations where your systems can respond to user actions as they happen.
One of the most popular webhook use cases is automatically adding leads to your CRM when visitors submit forms through your Linkbreakers workflows. When a visitor completes a form, the webhook immediately receives the submission data, including the visitor's contact information and any custom fields they filled out. Your integration parses this visitor information, creates a new lead record in your CRM with all the relevant details, and can even assign it to the appropriate sales team member based on territory, product interest, or lead score.
This automation eliminates manual data entry, reduces the risk of lost leads, and ensures your sales team can follow up while the lead is still hot. Instead of batch processing form submissions once a day or manually copying data between systems, everything happens in real-time without human intervention.
Webhooks enable sophisticated marketing automation based on visitor behavior. For example, you can trigger personalized email sequences based on QR code scans or link clicks. When your webhook receives a scan event, it can identify which visitor segment the person belongs to based on the link they scanned, their device type, location, or previous behavior. Based on this segmentation, your marketing automation platform receives instructions to enroll the visitor in the appropriate email campaign tailored to their interests and behavior.
This behavioral trigger approach is far more effective than time-based campaigns because it responds to actual visitor actions and intent. Someone who scans a QR code at a trade show gets different follow-up than someone who clicked a link in an email newsletter, even if they're looking at the same product.
For organizations with sophisticated analytics needs, webhooks provide a way to send event data to your data warehouse or analytics platform in real-time. When a webhook receives workflow completion data, your integration can transform it into the format required by your analytics platform, send it to your data warehouse for long-term storage and analysis, and update real-time dashboards that your team uses to monitor campaign performance.
This approach gives you complete control over your analytics stack and allows you to combine Linkbreakers data with information from other sources for comprehensive business intelligence. You're not limited to the reports available in any single platform, you can build exactly the analysis and visualizations your business needs.
Webhooks excel at powering custom notification systems that alert your team when high-value prospects engage with your content. Your webhook receives visitor data and can evaluate factors like company size, job title, or engagement history to calculate a lead score. When the score exceeds your threshold for high-value prospects, the system sends an instant notification to Slack or Microsoft Teams alerting the relevant team members and creates a task in your project management system for immediate follow-up.
This real-time alerting ensures your team can reach out to hot leads while they're actively engaged, dramatically increasing conversion rates compared to delayed follow-up.
Security should be a top priority when implementing webhook endpoints. Always use HTTPS endpoints rather than unencrypted HTTP, Linkbreakers requires this, but it's worth emphasizing because it protects your data in transit from interception or tampering. Implement idempotency handling in your endpoint code to gracefully handle duplicate webhook deliveries, which can occur during network issues or retry scenarios. Your code should detect when it's received the same event twice and process it only once.
Consider implementing request verification based on the custom headers Linkbreakers sends with each webhook. While we don't currently provide webhook signing, examining the request headers and payload structure can help you verify requests are legitimate. Additionally, implement rate limiting on your endpoint to protect it from potential abuse or accidental misconfigurations that could flood your system with requests.
Proper data handling is essential for maintaining security and reliability. Always validate webhook payloads before processing them—check that the structure matches your expectations and that required fields are present. Sanitize and validate all data before using it in database queries or passing it to other systems to prevent injection attacks. When logging webhook activity for debugging and monitoring, ensure you're not exposing sensitive information in log files that might be accessible to unauthorized users.
Handle errors gracefully by returning appropriate HTTP status codes for different scenarios. A 200 status indicates success, 400-series codes indicate problems with the request itself, and 500-series codes indicate problems with your server. Proper status codes help the Linkbreakers retry system make intelligent decisions about whether to retry delivery.
The Linkbreakers webhook dashboard provides comprehensive visibility into your webhook operations. You can access a complete delivery history showing every webhook attempt, including those that succeeded and those that failed. Success and failure rates give you at-a-glance metrics about webhook reliability, helping you identify patterns or systematic issues. For each delivery attempt, you can view the HTTP status code returned by your endpoint and the response body, which is invaluable for debugging integration problems.
Timing information shows how long each delivery took, helping you optimize your endpoint performance and identify bottlenecks. If you're seeing consistently slow responses, it might indicate your endpoint needs optimization or additional infrastructure resources.
When troubleshooting webhook issues, start with the basics. If your webhook isn't receiving data at all, verify that your endpoint URL is correct and accessible from the internet. Many developers initially test with localhost URLs, which Linkbreakers can't reach. Use a service like ngrok during development to expose your local server to the internet. Ensure your server is returning 2xx status codes for successful webhook processing, if you're returning error codes, Linkbreakers will keep retrying. Check your firewall settings to ensure they allow incoming requests from Linkbreakers' servers.
Duplicate deliveries can occur when your endpoint takes too long to respond or returns error codes inconsistently. Implement idempotency keys in your endpoint logic so that processing the same event multiple times has the same effect as processing it once. Check webhook logs in the Linkbreakers dashboard for retry attempts to understand the pattern of deliveries.
If you're seeing missing data in webhook payloads, review the webhook payload documentation to understand what fields are available for different event types. Verify that the event type matches your expectations, different events include different data. Double-check that your workflow steps are configured correctly, as misconfigured workflows might not generate the events you expect.
Thorough testing before launching webhook integrations in production prevents headaches and ensures reliability. Start by setting up a test endpoint using tools like RequestBin, Webhook.site, or a local development server exposed through ngrok. These services let you inspect webhook payloads without writing any code, helping you understand the data structure and content.
Create a test QR code and workflow specifically for webhook testing. Trigger test events by scanning the code or clicking through the workflow, then verify you're receiving the expected payload structure and data. Test your error handling by intentionally making your endpoint return error codes or time out, verify that the retry mechanism works as expected and that you can see the retry attempts in your dashboard.
Monitor the performance of your endpoint during testing. Make sure it responds within acceptable timeframes, ideally under 5 seconds, certainly under 30 seconds. Slow endpoints can cause delivery delays and trigger unnecessary retries.
Several tools make webhook testing easier during development. RequestBin and Webhook.site provide simple browser-based interfaces for inspecting webhook payloads without writing any code. These are perfect for understanding what data Linkbreakers sends before you start building your integration. Ngrok allows you to expose your local development server to the internet with a temporary public URL, enabling webhook testing without deploying code to a staging server. Postman lets you simulate webhook deliveries to your endpoint, useful for testing how your code handles different event types and edge cases.
Webhooks are triggered by workflow step completions and workflow exits. This includes QR code scans, link redirections, form submissions, and any workflow step transitions.
Linkbreakers includes automatic retry mechanisms with up to 3 delivery attempts using exponential backoff. Webhooks are only considered failed after all retry attempts are exhausted.
The system will retry delivery up to 3 times with increasing delays. If a webhook fails consistently, it will be automatically disabled and you'll receive an email notification.
Yes, Linkbreakers maintains a complete audit trail of all webhook delivery attempts, including success/failure status, HTTP responses, and timing information.
All webhooks are sent as HTTP POST requests with JSON payloads. The Content-Type header is set to "application/json" and includes custom headers for event identification.
Webhooks are processed through a high-priority background queue and typically delivered within seconds of the triggering event.
Yes, you can test webhook delivery using the Linkbreakers dashboard. We recommend setting up a test endpoint to verify your integration before using it in production.
While Linkbreakers requires HTTPS for webhook endpoints, you should implement idempotency handling on your side and consider verifying requests based on the custom headers we send.
Currently, webhooks receive all workflow-related events for your workspace. You can filter and route events within your receiving application based on the event type and data provided.
Your endpoint should return any HTTP 2xx status code (like 200 OK) to indicate successful receipt. Any other status code will trigger our retry mechanism.
Webhook limits are tied to your subscription plan. Upgrade from Free/Trial (1 webhook) to Pro (5 webhooks) or Enterprise (unlimited webhooks) through your account settings.
Yes, you can disable webhooks in your workspace settings. This preserves the configuration while preventing delivery until you re-enable it.
Webhooks are a powerful feature that extends Linkbreakers beyond simple link management into a comprehensive integration platform. By leveraging real-time notifications, you can automate workflows, synchronize data across systems, and create seamless experiences for your team and customers.
Whether you're integrating with CRM systems, triggering marketing automation, or building custom applications, Linkbreakers webhooks provide the reliability and flexibility you need for production-grade integrations. The combination of automatic retry logic, comprehensive monitoring, and rich event data means you can build integrations with confidence, knowing they'll work reliably even when facing real-world challenges like network issues or temporary service disruptions.
Ready to set up your first webhook? Head to your workspace settings and start connecting Linkbreakers with your external systems today!