Author picture Fongang Rodrique

How to Receive and Replay External Webhooks in Make with Hookdeck

Published · Updated

Webhooks introduce event-driven integrations between different applications or platforms. When it comes to building event-driven architectures, it is recommended to introduce an event gateway to manage webhooks for security, routing, log tracing, throttled delivery, and webhook event replay.

In this article, we will explore how to leverage Hookdeck, an event gateway, to receive and replay webhooks to your Make workflows.

Creating a custom Make webhook receiver

To be able to receive custom webhook events from other platforms in Make, you need to create a custom webhook receiver. To do this, follow the steps outlined below.

  • Sign up or log in to your Make account.
  • Create a new scenario or select an existing one where you wish to receive the webhook.
  • Insert the Custom webhook module into a scenario in Each scenario must have its own webhook; you cannot use one webhook in multiple scenarios.

Make custom webhook

  • Click on Create a webhook, then give it a name and Save.

Create webhook in Make

Make generates a URL for the webhook receiver and starts listening for requests sent to this URL. You can send a request to this URL to have Make automatically determine the data structure for the webhook. Note the webhook URL provided, as it is needed below.

Learn more about Make webhooks here.

Creating a Hookdeck connection

Now that we have the custom setup and listening on Make, let's integrate Hookdeck to handle webhook events and enable replay functionality. Follow the steps below to create a webhook connection in Hookdeck.

  • Sign up or log in to your Hookdeck dashboard.
  • Click on Connections on the side panel and Create + a new connection. This opens a right sidebar.
  • Fill in the required information and Save.
    • Source: Specify the source to be any platform or application you want to receive webhooks from.
    • Destination: Set the destination to the above URL provided by Make.

Create Make Hookdeck connection

After creating the connection, copy the source URL from Hookdeck to use on the source platform where the webhook is to come from.

After creating the connection, Hookdeck acts as an intermediary between the source platform and your webhook receiver, relaying the webhook events.

Receiving webhook events

You can utilize the Hookdeck Console to simulate example webhooks from popular webhook sources.

When an event is triggered from the source platform, Hookdeck receives the webhook events and forwards them to Make’s endpoint where any further module is executed with the data received. You can monitor the events within the Hookdeck dashboard and track their delivery status.

From your Hookdeck dashboard, switch to the Events tab from the side panel and filter as per the connection created above. This shows the activities of events on that connection. events in Hookdeck

Events received can be visualized on the Make dashboard. Switch to Webhooks on the left menu and click on LOGS.

Events received in Make dashboard

Replaying error or failed webhooks

In case any webhook events fail to be processed correctly by the Make webhook receiver, Hookdeck provides the ability to replay those error events. Follow these steps to replay an error webhook:

  • From the Hookdeck Event panel, locate the failed event and click on the kebab menu (three dots).
  • Select Retry from the menu. This attempts to send the event to your Make webhook receiver again.

By replaying error webhooks, you ensure that failed events are delivered and processed correctly by the webhook receiver.

Replay Make webhook

With the integration of Hookdeck, you can enhance the management of external webhook events to Make. By following the steps outlined in this article, you have learned how to create a webhook receiver in Make and integrate it with Hookdeck to receive and replay webhooks.

Hookdeck offers many features, like tracing and routing, to help you build robust and responsive workflow automation and integrations that seamlessly and reliably communicate with external systems and services.