Integrations: Zapier, Make & n8n
Connect OOHLEMON to your existing tools — receive webhooks, verify signatures, control via API. No server of your own required: copy & paste is enough.
There are two directions: OOHLEMON notifies you (webhooks) and you control OOHLEMON (REST API). Zapier, Make and n8n combine the two into automations — no server of your own, with copy-ready code for signature verification.
Before you start
- The API and webhooks are part of the Pro package (fully available during the 14-day trial).
- Only the team owner or admins can create webhook endpoints.
- For controlling OOHLEMON via the API you need a key with “Read + write” access (read-only is enough for pure reporting).
- Privacy: delivery happens at least once and in no guaranteed order — deduplicate by event ID. Targets outside the EU (e.g. Zapier) are transfers to third countries; if you want to avoid that, self-hosted n8n is the way to go.
Trigger: webhooks
OOHLEMON sends a signed HTTP request to your URL whenever something happens. In Zapier/Make/n8n you catch it and kick off your workflow.
Action: REST API
The other way round, you call the API: list displays, reload a playlist, restart a player. Using a bearer key.
Step by step — per platform
Zapier
1Start a Zap when something happens in OOHLEMON
- Create a new Zap in Zapier. Choose “Webhooks by Zapier” with the event “Catch Hook” as trigger and copy the URL shown.
- In the dashboard under Integrations → Webhooks, create an endpoint with this URL and select the events you want. The endpoint automatically gets the Zapier badge.
- Store the secret (ool_whsec_…) safely — you need it for signature verification.
- Click “Test trigger” in Zapier, then send a sample event in the dashboard.
2Verify the signature in Zapier (optional, recommended)
- Use the event “Catch Raw Hook” instead of “Catch Hook” — it provides the unmodified body and the headers.
- Add “Code by Zapier” → “Run JavaScript” as the second step and create three fields under Input Data: body (raw body), signature (header OOHLEMON-Signature) and secret (your ool_whsec_…). Then paste the code.
- Then add “Filter by Zapier”: only continue if valid is true. The verified fields (type, object_id, object_name) are available to the following steps.
Code by Zapier — Run JavaScript
const crypto = require('crypto');
const body = inputData.body; // raw body (Catch Raw Hook)
const header = inputData.signature || ''; // OOHLEMON-Signature header
const secret = inputData.secret; // ool_whsec_…
const parts = header.split(',').map((p) => p.trim().split('='));
const t = (parts.find(([k]) => k === 't') || [])[1];
const signatures = parts.filter(([k]) => k === 'v1').map(([, v]) => v);
const expected = crypto.createHmac('sha256', secret).update(`${t}.${body}`).digest('hex');
const fresh = Math.abs(Date.now() / 1000 - Number(t)) <= 300;
const matches = signatures.some((sig) =>
sig.length === expected.length &&
crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected)));
const valid = Boolean(t) && fresh && matches;
const event = valid ? JSON.parse(body) : null;
output = {
valid,
type: event ? event.type : null,
test: event ? event.test === true : null,
object_id: event ? event.data.object.id : null,
object_name: event ? event.data.object.name : null,
};3Control OOHLEMON from a Zap
- In the dashboard’s “API keys” tab, create a key with “Read + write” access. It is shown only once.
- In the Zap, choose the action “Webhooks by Zapier” → “Custom Request”.
- Take method and URL from the API examples in the API reference. Under Headers: Authorization with the value Bearer + your key, Content-Type with application/json.
- Enter the JSON body under Data and map fields from the trigger. Check with “Test step”.
Make
1Start a Make scenario when something happens in OOHLEMON
- Create a new scenario in Make and add the module “Webhooks” → “Custom webhook”. Click “Add” to create a webhook and copy the URL.
- In the dashboard under Integrations → Webhooks, create an endpoint with this URL and select the events. The endpoint automatically gets the Make badge.
- Start “Redetermine data structure” in the webhook module (or run the scenario with “Run once”) and send a sample event in the dashboard. Make picks up the structure.
- Add further modules and map the fields.
2Verify the signature in Make (optional)
- In the webhook’s advanced settings, enable “Get request headers” and “JSON pass-through”. The unmodified body is then in the value field.
- Compare the signature with variables and a filter as shown in the snippet. Only then split the body into fields with “JSON → Parse JSON”.
Make — variables and filter
// 1) Tools > Set variable "sig"
{{first(map(1.headers; "value"; "name"; "oohlemon-signature"))}}
// 2) Tools > Set multiple variables
t = {{replace(first(split(sig; ",")); "t="; "")}}
v1 = {{replace(last(split(sig; ",")); "v1="; "")}}
// 3) Filter (Text operators: Equal to)
{{sha256(t.1.value; "hex"; "ool_whsec_…")}} = {{v1}}
// t.1.value = pill "t", a literal ".", pill "1.value"
// 4) JSON > Parse JSON
{{1.value}}3Control OOHLEMON from a Make scenario
- In the dashboard’s “API keys” tab, create a key with “Read + write” access.
- Add the module “HTTP” → “Make a request”.
- Enter URL and method from the API examples in the API reference. Under Headers: Authorization with Bearer + your key.
- Choose body type “Raw”, content type “JSON (application/json)” and enter the JSON body. Enable “Parse response”.
n8n
1Start an n8n workflow when something happens in OOHLEMON
- In n8n, create a workflow with the “Webhook” node: HTTP Method POST, any path (e.g. oohlemon-media-ready), Respond “Immediately”. Turn on “Raw Body” under Options if you verify the signature.
- Save and activate the workflow. Copy the production URL from the Webhook node — the test URL (webhook-test) only works while n8n is waiting for a test event.
- In the dashboard under Integrations → Webhooks, create an endpoint with the production URL and select the events.
- To test, send a sample event in the dashboard.
2Verify the signature in n8n (recommended)
- Turn on “Raw Body” under Options in the Webhook node. The unchanged body is then available as the binary field data.
- Add a “Code” node (JavaScript, “Run Once for All Items”) right after it and paste the snippet. Enter the secret and event type in the two TODO lines.
- Self-hosted n8n only allows the crypto module with the environment variable NODE_FUNCTION_ALLOW_BUILTIN=crypto.
n8n — Code node (Run Once for All Items)
// OOHLEMON webhook: verify signature (t=...,v1=..., HMAC-SHA256, 5 min tolerance)
// Mode: Run Once for All Items. Self-hosted n8n needs NODE_FUNCTION_ALLOW_BUILTIN=crypto.
const SECRET = 'ool_whsec_TODO'; // TODO: webhook secret from OOHLEMON (Settings > Integrations > Webhooks)
const ONLY_TYPE = 'media.ready'; // TODO: event type to pass on, or null for all events
const TOLERANCE_SECONDS = 300;
const crypto = require('crypto');
const item = $input.first();
const header = item.json.headers['oohlemon-signature'] || '';
let raw;
try {
raw = (await this.helpers.getBinaryDataBuffer(0, 'data')).toString('utf8');
} catch (error) {
throw new Error('Raw body missing: enable the option "Raw Body" in the Webhook node.');
}
const parts = header.split(',').map((part) => part.trim().split('='));
const t = (parts.find(([key]) => key === 't') || [])[1];
const signatures = parts.filter(([key]) => key === 'v1').map(([, value]) => value);
const expected = crypto.createHmac('sha256', SECRET).update(`${t}.${raw}`).digest('hex');
const fresh = Math.abs(Date.now() / 1000 - Number(t)) <= TOLERANCE_SECONDS;
const matches = signatures.some((sig) =>
sig.length === expected.length &&
crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected)));
if (!t || !fresh || !matches) throw new Error('Invalid OOHLEMON signature');
const event = JSON.parse(raw);
// ping (connection check) and other types stop here without an error
if (event.type === 'ping' || (ONLY_TYPE && event.type !== ONLY_TYPE)) return [];3Control OOHLEMON from an n8n workflow
- Create a key in the dashboard’s “API keys” tab (with “Read + write” for display commands).
- In n8n, create a “Header Auth” credential: name Authorization, value Bearer + your key. That keeps the key out of the workflow.
- Add an “HTTP Request” node and choose Authentication “Generic Credential Type” → “Header Auth”. “Import cURL” takes over the API examples directly.
- Insert IDs from the trigger as expressions and check with “Test step”.
Even easier: the dashboard (Integrations → Apps) has a ready-to-import example workflow — paste it into an empty n8n workflow with Ctrl+V and all nodes appear.
Three recipes to get started
New media → Slack message
As soon as a video or image finishes processing, a Slack bot tells the team. No more asking whether the new clip is live.
Playlist change → Google Sheets log
Every playlist change lands as a row in a spreadsheet — a change log: which playlist, which media were added or removed, which displays are affected.
Schedule update → email to the branch manager
When the schedule for a location changes, the branch is notified automatically — nobody has to check the dashboard.
What works today — and what does not
Works: read and update displays, send player commands, read media/playlists/schedules/campaigns, receive webhooks.
Not yet: creating media via API (coming soon) — an n8n example scenario therefore uses a published web-page table plus reload_playlist. Documented honestly, so you don’t build on something that doesn’t exist.
If something doesn’t work
- “Invalid signature”: Are you verifying the raw body (not the parsed JSON)? Is the secret correct? Does the header match exactly “t=…,v1=…”?
- Delivery happens at least once and in no guaranteed order — deduplicate in your workflow by event ID (otherwise e.g. duplicate Slack posts).
- An endpoint is automatically deactivated after 3 days without a successful delivery — reactivate it in the dashboard.
- The delivery log under Integrations → Webhooks shows every delivery and lets you resend with a click.
Prefer to start in the dashboard?
All integration tabs (webhooks, API keys, Zapier/Make/n8n recipes with copy buttons) live under Integrations.