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.

Back to documentation

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

  1. Create a new Zap in Zapier. Choose “Webhooks by Zapier” with the event “Catch Hook” as trigger and copy the URL shown.
  2. 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.
  3. Store the secret (ool_whsec_…) safely — you need it for signature verification.
  4. Click “Test trigger” in Zapier, then send a sample event in the dashboard.

2Verify the signature in Zapier (optional, recommended)

  1. Use the event “Catch Raw Hook” instead of “Catch Hook” — it provides the unmodified body and the headers.
  2. 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.
  3. 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

  1. In the dashboard’s “API keys” tab, create a key with “Read + write” access. It is shown only once.
  2. In the Zap, choose the action “Webhooks by Zapier” → “Custom Request”.
  3. 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.
  4. Enter the JSON body under Data and map fields from the trigger. Check with “Test step”.

API reference with all examples

Make

1Start a Make scenario when something happens in OOHLEMON

  1. Create a new scenario in Make and add the module “Webhooks” → “Custom webhook”. Click “Add” to create a webhook and copy the URL.
  2. In the dashboard under Integrations → Webhooks, create an endpoint with this URL and select the events. The endpoint automatically gets the Make badge.
  3. 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.
  4. Add further modules and map the fields.

2Verify the signature in Make (optional)

  1. In the webhook’s advanced settings, enable “Get request headers” and “JSON pass-through”. The unmodified body is then in the value field.
  2. 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

  1. In the dashboard’s “API keys” tab, create a key with “Read + write” access.
  2. Add the module “HTTP” → “Make a request”.
  3. Enter URL and method from the API examples in the API reference. Under Headers: Authorization with Bearer + your key.
  4. Choose body type “Raw”, content type “JSON (application/json)” and enter the JSON body. Enable “Parse response”.

API reference with all examples

n8n

1Start an n8n workflow when something happens in OOHLEMON

  1. 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.
  2. 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.
  3. In the dashboard under Integrations → Webhooks, create an endpoint with the production URL and select the events.
  4. To test, send a sample event in the dashboard.

2Verify the signature in n8n (recommended)

  1. Turn on “Raw Body” under Options in the Webhook node. The unchanged body is then available as the binary field data.
  2. 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.
  3. 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

  1. Create a key in the dashboard’s “API keys” tab (with “Read + write” for display commands).
  2. In n8n, create a “Header Auth” credential: name Authorization, value Bearer + your key. That keeps the key out of the workflow.
  3. Add an “HTTP Request” node and choose Authentication “Generic Credential Type” → “Header Auth”. “Import cURL” takes over the API examples directly.
  4. 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.

API reference with all examples

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.

Trigger → media.readyAction → Slack: send message

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.

Trigger → playlist.updatedAction → Google Sheets: append row

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.

Trigger → schedule.updatedAction → Send email

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.