Skip to content
Docs/Integrations/Make

Connect Netounim to Make

Pipe Netounim events into Make.com (formerly Integromat) scenarios for visual, drag-and-drop automation across 1,500+ apps. No code, ~5 minutes to set up.

Heads up. Netounim doesn't yet have a dedicated Make app in the Make app store. This guide uses Make's built-in Custom Webhook module, which works on every Make plan including Free. A native app is on the roadmap.

Quickstart — 3 steps

1

Create the scenario trigger in Make

  1. Sign in to make.com and click Create a new scenario.
  2. Click the first module: search and pick Webhooks → Custom webhook.
  3. Click Add → name it (e.g. "Netounim events") → Save.
  4. Make shows you a webhook URL like:
    https://hook.eu1.make.com/abc123xyz...
  5. Copy the URL.
2

Register the webhook in Netounim

  1. Open Settings → Webhooks.
  2. Click Create webhook.
  3. Paste the Make URL into the URL field.
  4. Check the events you want to forward (e.g. EMAIL_REPLIED, LEAD_ADDED, BULK_COMPLETED).
  5. Save. Netounim returns the signing secret once — copy it.
3

Test and map the payload

  1. Back in your Netounim webhook detail, click Send test event.
  2. In Make, click Run once on the webhook module — it captures the test payload and learns the field structure (event, data.*, signature).
  3. Add any next module (Slack, Google Sheets, HubSpot, OpenAI…) and drag fields from the webhook output into its inputs.
  4. Toggle the scenario ON at the bottom to activate.

Done. Every event triggers the scenario in near real-time.

Verify the signature (recommended)

Netounim signs every webhook delivery with HMAC-SHA256. To verify inside Make, add a Tools → Set variable module followed by a Flow Control → Router with a filter. Or, simpler, use the built-in Iterator → Set Multiple Variablescombined with a JavaScript snippet via the Tools → Compose a string module.

The cleanest path is the Tools → Compose a string module with a small JavaScript expression:

// In a "Compose a string" module, paste this as a custom expression:
//
// Inputs available:
//   {{1.headers.`x-netounim-signature`}}  // header from webhook
//   {{1.`__IMTHTTPBODY__`}}                  // raw body from webhook
//
// Compare against HMAC-SHA256(secret, "${t}.${body}") :

if (
  sha256(`${parseSignature(headers).t}.${body}`, MAKE_SECRET) ===
  parseSignature(headers).v1
) {
  // valid → continue scenario
} else {
  // invalid → exit via Flow Control → Break
}

For complex verification logic, prefer the HTTP → Make a request module to ping a tiny serverless function (Cloudflare Worker, Vercel Function) that runs the HMAC verify and returns a 200/401. Make then continues only on 200.

Scenario examples

EMAIL_REPLIEDRun OpenAI sentiment analysis → tag in Pipedrive

When a reply comes in, send the body to OpenAI for sentiment classification, then update the Pipedrive deal's tag accordingly. All in one scenario.

LEAD_ADDEDCross-check against Clearbit → enrich row in Airtable

Pipe new leads through Clearbit for extra company data, then mirror everything to an Airtable base for sales team visibility.

BULK_COMPLETEDUpload CSV to Dropbox + notify Discord

After bulk enrichment finishes, generate a CSV via Make's CSV module, drop it in Dropbox, and post a Discord notification with the link.

CAMPAIGN_SENTIncrement a counter in Notion + tag the sender

Track per-SDR campaign volume in a Notion database. Useful for individual quotas and weekly reporting.

FAQ

Does this require a paid Make plan?
No. The Free plan includes 1,000 operations/month and unlimited scenarios — more than enough for low-volume webhook triggers. High- volume events (e.g. EMAIL_OPENED on a 10k-recipient campaign = 10k operations) will hit the cap — filter at the Netounim webhook level to avoid this.
Make vs Zapier — which should I pick?
Make is cheaper, more powerful for complex multi-branch scenarios, and pricing is per-operation (more predictable for high volume). Zapier has more apps in its directory and a simpler UI for beginners.

Use Make if you're comfortable with conditional logic. Use Zapier if you want the simplest possible setup or your team already uses it.
What's the difference vs the native Webhooks tab in Netounim?
None on the Netounim side — Make's URL is just another webhook target. Make adds the no-code orchestration layer: chain multiple apps, transform payloads, branch on conditions. Without Make, you'd need to write your own HTTP server.
What about the Make app store — when will Netounim be there?
Publishing a native Make app means Netounim-branded modules in Make's search bar — better discoverability, no webhook setup. It's faster to ship than a Zapier app (no formal review), but still adds maintenance overhead. We'll prioritize it based on user demand.

Ready to wire your first scenario?

Webhooks settings are in your dashboard.

Open Settings → Webhooks
Netounim — B2B prospecting in one workspace