Make.com Integration

Connect Loyalite to Make.com (formerly Integromat). Loyalite works in both directions:

Direction	What it means	How
Trigger	Loyalite fires an event → Make.com runs a scenario	Custom Webhook module (this page)
Action	Something happens elsewhere → Make.com calls Loyalite	HTTP module (this page)

Part 1 — Loyalite as a Trigger

Use this when you want to react to loyalty events — a customer enrolls, earns stamps, or redeems a coupon — and do something in another app.

Examples:

Sync new loyalty enrollments to your CRM (HubSpot, Salesforce, Pipedrive)
Create Airtable records for every stamp transaction
Post stamp milestones to a Slack channel
Generate coupon redemption reports in Google Sheets
Trigger n8n or other downstream workflows

Setup guide

Create a new scenario

Go to make.com (opens in a new tab) → Scenarios → + Create a new scenario.

Add a Custom Webhook trigger

Click the large + to add the first module.
Search for "Webhooks" → select Custom Webhook.
Click Add to create a new webhook → give it a name like "Loyalite Events".
Click Save.

Copy your Make.com webhook URL

Make.com will display a URL like:

https://hook.eu1.make.com/abcdef1234567890

Copy this URL.

Add the webhook to Loyalite

Open the merchant app.
Go to Account → Settings → Integrations → Webhooks.
Tap Add Webhook.
Paste the Make.com URL as the Endpoint URL.
Set a description like "Make.com scenario".
Choose event types (or All Events).
Tap Save.
Store the signing secret safely if you want to verify HMAC signatures in Make.

Send a test event

In the merchant app:

Tap the endpoint → Test.
Select an event type (e.g. stamp.earned).

Back in Make, click Run once while Make is listening, then trigger the test. Make will capture the webhook data and show you the payload structure.

Make.com requires you to click Run once before it listens for the first payload. If you miss the window, click Run once again and re-send the test from Loyalite.

Map the payload fields

After the test, Make shows all fields from the Loyalite payload. You can now map them to downstream modules:

bundle.body.event              → "stamp.earned"
bundle.body.occurred_at        → "2026-04-19T14:30:00Z"
bundle.body.organization       → "kahveci-mehmet"
bundle.body.data.customer_code → 482193
bundle.body.data.stamps_added  → 2
bundle.body.data.stamp_balance → 7

Add downstream modules

Click + after the webhook module to add actions:

Example: HubSpot — Create Contact

Map bundle.body.data.masked_email to Email field
Map bundle.body.data.customer_code to a custom property

Example: Google Sheets — Add Row

Map timestamp, customer code, event type, and balance fields

Example: Slack — Send Message

Text: New stamp earned! Customer {{bundle.body.data.customer_code}} now has {{bundle.body.data.stamp_balance}} stamps.

Activate your scenario

Click Save then toggle the scenario On. It will now run each time Loyalite sends a webhook.

Filtering by event type in Make

To handle different event types in the same scenario, add a Router module after the webhook:

Add a Router module.
Create separate routes for each event type.
For each route, add a filter: event → Equal to → stamp.earned (or whichever event).

Verifying HMAC signatures in Make

Loyalite signs every webhook with X-Loyalite-Signature-256: sha256=<hex> (HMAC-SHA256 of the raw request body).

Make.com does not expose the raw request body to formula functions, and its sha256() function is a plain digest — not an HMAC. This makes reliable in-scenario signature verification impractical.

⚠️

For production security, verify signatures on your own server and have Loyalite POST to your server first. Your server can then forward verified events to Make.com via its own HTTP request. See the Security guide for code samples.

Part 2 — Loyalite as an Action

Use this when something happens in another app and you want Make.com to call Loyalite — to enroll a customer, record a transaction, or redeem points.

Examples:

WooCommerce / Shopify order placed → earn points for the customer
Google Form / Typeform submitted → enroll the customer in Loyalite
New row added to Google Sheets → award stamps
Customer submits redemption request → redeem points via Loyalite

All actions use Make.com's HTTP — Make a request module to call the Loyalite POS API.

Authentication

Every HTTP request to Loyalite must include your API key. Find it in Merchant App → Settings → Integrations.

Configure these headers on every HTTP module:

Header	Value
`X-Api-Key`	Your Loyalite secret key
`Content-Type`	`application/json`

Action: Enroll a customer

Trigger example: New form submission (Google Forms, Typeform, Tally…)

Add an HTTP — Make a request module

Click + in your scenario → search "HTTP" → select Make a request.

Configure the module

URL: https://{your-slug}.loyalite.app/webhook/customer
Method: POST
Body type: Raw
Content type: application/json

Request content:

{
  "email": "{{your trigger email field}}",
  "consent_terms": true,
  "consent_privacy": true
}

Headers: add X-Api-Key and Content-Type as above.

Parse the response

Enable Parse response in the module settings. Make.com will expose the response body fields for use in downstream modules:

Field	Description
`data.customer_code`	The customer's 6-digit code
`data.is_new`	`true` if just enrolled, `false` if already existed
`data.point_balance`	Current point balance
`data.stamp_count`	Current stamp count

Action: Earn points or stamps

Trigger example: New order in WooCommerce, Shopify, or any e-commerce platform

Add an HTTP — Make a request module

Click + → HTTP → Make a request.

Configure the module

URL: https://{your-slug}.loyalite.app/webhook/pos
Method: POST
Body type: Raw
Content type: application/json

Request content:

{
  "customer_code": {{customer_code from enroll step}},
  "amount": {{order total}},
  "card_type": "point",
  "external_id": "{{order_id}}"
}

⚠️

Always map external_id to a unique order ID from your trigger. If Make.com retries the scenario, the duplicate is detected automatically — no double points.

Full WooCommerce → Loyalite example scenario

[WooCommerce: New Order]
        ↓
[HTTP: POST /webhook/customer]
  email           → {{customer.email}}
  consent_terms   → true
  consent_privacy → true
        ↓
[HTTP: POST /webhook/pos]
  customer_code → {{data.customer_code}}  ← from step above
  amount        → {{total}}
  card_type     → point
  external_id   → {{id}}                 ← WooCommerce order ID

Action: Redeem points or stamps

Trigger example: Customer submits a redemption form

Add an HTTP — Make a request module

URL: https://{your-slug}.loyalite.app/webhook/redeem
Method: POST

Request content:

{
  "customer_code": {{customer_code}},
  "value": {{points_to_redeem}},
  "card_type": "point",
  "external_id": "{{unique_redemption_id}}"
}

Handle errors

Add an Error Handler route on the HTTP module:

HTTP 422 → insufficient_balance — add a filter to check balance before this step
HTTP 402 → subscription_required — notify the merchant

Action: Look up a customer's balance

Use case: Check the current balance before offering a reward or before a redemption step.

Add an HTTP — Make a request module

URL: https://{your-slug}.loyalite.app/webhook/customer?code={{customer_code}}
Method: GET
Headers: X-Api-Key only (no body needed)

Use the response in filters

After the lookup, add a Filter between modules:

Condition: data.point_balance → Greater than or equal to → {{minimum_required}}

This prevents a downstream redeem call from failing due to insufficient balance.

Reusable HTTP module tip

In Make.com you can save a configured HTTP module as a template in your organization. Set up the X-Api-Key header once and reuse it across all Loyalite action modules in your scenarios.

Zapier Integration Troubleshooting