Make+DiffHook

Make.com web scraping — webhook-first, no polling module

DiffHook handles the scraping, rendering, and diff. Your Make scenario starts from a Webhook module and receives a signed payload every time the page moves — never on an empty poll.

The typical Make.com scraper chains the HTTP → Get a file module with a Text parser, then a Data store with a "has it changed?" check, and finally the downstream modules. Every run consumes operations whether anything changed or not. DiffHook lets you flip the scenario to a Webhook trigger — Make only consumes operations when there's a genuine change to process.

Start freeRead the scraping docs

Workflow

Scrape into Make.com in 5 steps

Webhook trigger, not a scheduler. Make's operation count tracks real events, not empty polls.

01

Create a Webhooks → Custom webhook trigger

In Make.com, start a scenario with the Custom webhook module. Make generates a unique URL like https://hook.eu2.make.com/XXX — copy it; it goes into the DiffHook delivery.

02

Describe the scrape as a DiffHook monitor

Set type to html_css and pass the URL plus a CSS selector that pinpoints the block you care about. Flip include_html: true when the scenario needs to parse raw markup downstream.

03

Register the monitor with the Make webhook

POST once to /v1/monitors with the scrape config, an interval, and the Make URL as a webhook delivery. DiffHook owns polling, caching, and diffing from this point on.

04

Verify the signature inside Make

Add a Tools → Set variable module that reads the X-DiffHook-Signature header, then a Router with a Filter that only allows through requests where the recomputed HMAC matches. Make's built-in crypto function handles SHA-256 without a Code module.

05

Map fields to downstream modules

The webhook body's top-level fields — extracted_text, current_value, previous_value, url — surface as named items you can drop into any downstream module: Google Sheets, Notion, Airtable, Telegram.

API example

Scrape into Make, one POST

The Make webhook URL goes straight into deliveries[0].url. DiffHook handles retry, backoff, and replay out of the box.

POST /v1/monitors
POST https://api.diffhook.com/v1/monitors
Authorization: Bearer $DIFFHOOK_API_KEY
Content-Type: application/json

{
  "type": "html_css",
  "url": "https://competitor.example.com/store",
  "css_selector": ".product-grid",
  "include_html": true,
  "interval_seconds": 900,
  "deliveries": [
    {
      "type": "webhook",
      "url": "https://hook.eu2.make.com/abc123456789"
    }
  ]
}

Importable workflow

Copy a ready-made Make scenario

Blueprint includes the Custom webhook trigger, HMAC verification, a Router with a size filter, and a Google Sheets destination. Import, paste the signing secret, activate.

View the Make blueprint on GitHub

FAQ

Make.com web scraping — common questions

Why use DiffHook instead of Make.com's HTTP + scheduler?
Make bills by operations. A scenario that polls a URL every five minutes consumes operations whether the page changed or not — plus you still have to maintain the Data store and the "did it change" comparison by hand. DiffHook replaces all of that with one webhook trigger that only fires on real changes, so the scenario's operation count matches the number of actual events.
Can DiffHook scrape JavaScript-rendered pages for Make?
Yes. Switch type to html_rendered and render.engine to playwright or puppeteer. DiffHook handles the headless-browser run and waits for the page to settle before snapshotting. Make receives the post-render diff — the rendering cost lives in DiffHook, not your Make plan.
Do I need a Code module to verify the webhook?
No. Make's built-in functions include sha256HMAC, which is enough to recompute the signature in a Set variable module and compare it in a Filter. The Make blueprint on GitHub shows the exact configuration, and it works on every Make.com plan.
What's the data shape?
Flat JSON, Make-friendly. Top-level keys: monitor_id, event, url, selector, extracted_text, current_value, previous_value, current_html (when include_html is on), detected_at, delivery_id. Make automatically surfaces each key as a named field, no JSON parser module needed.
Can a single scenario handle multiple scraped pages?
Yes. Point several DiffHook monitors at the same Make webhook URL, then use a Router with filters on monitor_id or url to split the scenario by source. This keeps the operation cost to one per genuine event, regardless of how many monitors feed it.

Related workflows

Also great with DiffHook

n8n web scraping

Prefer self-hosted automation? Same monitor config, n8n webhook as the destination.

Zapier web scraping

Same scraping pattern for Zapier — Catch Hook instead of Make's Custom webhook.

n8n + Playwright

JS-rendered scraping into n8n workflows — useful for SPA sites.

n8n + Puppeteer

The other rendered engine — pick whichever gets past the target site's bot protection.

Replace a scraping script

Migrating from a cron + Python/Node scraper? See the managed-monitor comparison.

Monitor competitor websites

The competitive-intel pattern end-to-end — the Make scenario receives the diff cleanly.

Stop paying operations on empty polls

Webhook-first scraping for Make, HMAC-signed payloads, free tier. Each Make operation matches one real change.

Create free accountSee pricing