Use Gluedly with Flowise

Treat Gluedly as the ingestion source for Flowise: map the page once, then let a webhook push fresh rows into your chatflow whenever a scrape stores data. Flowise should not scrape HTML itself.

Why teams use this integration

• Simplify your flow by moving web parsing upstream into Gluedly.
• Use webhooks for near-real-time flow triggers.
• Keep low-code AI workflows maintainable as source sites evolve.

Recommended setup

1. In Gluedly, create a page, map the fields your flow needs (title, markdown, url, …), and confirm a successful scrape.
2. In Flowise, publish an HTTPS endpoint that can receive a POST (Webhook trigger or Prediction API URL for your chatflow).
3. In Gluedly, open the page’s Webhooks screen, paste the Flowise URL, subscribe to data.created, and store the signing secret.
4. In the Flowise graph, read payload.data.rows and pass markdown/JSON into your LLM, retriever, or tool nodes.
5. Use Gluedly’s manual webhook test, then run a real scrape and confirm the flow executes on data.created.

1. Prepare Flowise to receive webhooks

Flowise is the consumer. Gluedly POSTs JSON when scraped rows are stored. Your chatflow needs a publicly reachable HTTPS URL that accepts application/json.

Typical options: a Webhook / API trigger node at the start of the chatflow, or the Flowise Prediction HTTP API for that chatflow. Use a tunnel (e.g. ngrok) only for local development.

1. Create or open the chatflow that should run when new Gluedly data arrives.
2. Add a webhook-capable entry node (or note the Prediction API path for this chatflow).
3. Copy the full HTTPS URL Gluedly should call (include any chatflow id path Flowise requires).
4. Plan how the first nodes will read the Gluedly envelope: event, payload.page_id, and payload.data.rows.

2. Create the webhook in Gluedly

Webhooks are per page. Open the mapped page → Webhooks. You need a paid/active plan (same gate as API keys).

Gluedly signs every delivery. The signing secret is shown once when you create the webhook—save it in Flowise env, a secrets store, or a small verification middleware in front of Flowise.

1. Go to My sites → open the page → Webhooks.
2. Set Endpoint URL to your Flowise HTTPS URL.
3. Under Events, select data.created (new scraped row stored). That is the usual “source” trigger for Flowise.
4. Save the webhook and copy the signing secret immediately—it is not shown again.
5. Optional: also subscribe to data.changed if the flow should re-run when watched fields update (configure field watches on the webhook).

3. Headers and signature verification

Each delivery is a POST with Content-Type: application/json plus X-Webhook-Id, X-Webhook-Event, and X-Webhook-Signature.

X-Webhook-Event is data.created for new rows. The signature is sha256= followed by HMAC-SHA256 of the raw body using your signing secret.

If Flowise cannot verify HMAC natively, put a tiny HTTPS proxy in front that checks the signature and forwards the JSON, or verify inside a custom Function/Code node that has access to the raw body and secret.

1. Expect Content-Type: application/json.
2. Branch on X-Webhook-Event (or body.event)—handle data.created for the happy path; ignore webhook.ping in production logic or use it only for connectivity checks.
3. Verify X-Webhook-Signature against HMAC-SHA256(raw body, signing secret) before trusting the payload.

4. Use payload.data.rows inside Flowise

For data.created, payload.data matches the API scrape snapshot: ok, rows, match_counts, warnings. Your mapped field names appear as keys on each row.

Prefer a markdown (or text) field for prompt context, and keep structured fields for tools or metadata. Do not re-parse HTML in Flowise.

1. Parse the JSON body and read payload.data.rows (array).
2. Map or join row.markdown (or your text fields) into the prompt / document loader input.
3. Pass that context into LLM, retrieval, or agent nodes as you would any other Flowise source.

5. Test end-to-end

Gluedly can send a manual webhook.ping (connectivity only—it does not include scrape rows). Use it to confirm Flowise accepts the POST and returns 2xx.

Then run a real scrape on the page. When a row is stored, Gluedly POSTs data.created with the snapshot in payload.data. Watch Flowise execution logs and your downstream LLM/retriever.

1. On the webhook row in Gluedly, run the manual test and confirm Flowise receives webhook.ping.
2. Run Now (or wait for schedule) so Gluedly stores a new data row.
3. Confirm Flowise ran on data.created and that prompt/retriever input contains your mapped fields.

Example webhook payload

Example data.created body Gluedly POSTs to your Flowise URL (field names inside rows follow your page mapping):

{
  "id": "delivery-uuid",
  "event": "data.created",
  "payload": {
    "page_id": 123,
    "data_id": 1001,
    "created_at": "2026-07-27T12:00:00+00:00",
    "data": {
      "ok": true,
      "rows": [
        {
          "title": "Example listing",
          "url": "https://example.com/item/1",
          "markdown": "Clean markdown for your Flowise prompt or retriever"
        }
      ],
      "match_counts": { "title": 1, "url": 1, "markdown": 1 },
      "warnings": []
    }
  }
}

Related guides