← DomainGuard · integrations
Your domain findings,
in your own tools.
Every step in a claimed report's life — takedown packet sent, verification passed, a lookalike still live at recheck — is an event in one shared shape. Integrations deliver those events to the tools you already run, starting with n8n. Claim your free report, then open its Integrations page (the link is on every finding page) to create a subscription.
1 · n8n (start here)
Two ready-made workflows, built for self-hosted or cloud n8n:
Download the event-receiver workflow Download the polling workflow
- Import the receiver workflow into your n8n and activate it; copy its production Webhook URL.
- On your claimed report's Integrations page, add a Webhook subscription pointing at that URL. The signing secret is shown once — paste it into the workflow's “Verify signature” node.
- Use “Send test” on the subscription: a labelled test event lands in your n8n execution log within seconds.
- The polling workflow is the pull alternative: it reads GET /api/v1/events with your holder API key every 15 minutes.
2 · Webhooks — the delivery contract
Delivery is at-least-once: a retry after an ambiguous timeout resends the identical body, so dedupe on event_id. Attempts are bounded — 4 in total (immediate, then +60s, +300s, +900s) — every attempt is recorded on the Integrations page, and a permanently failed delivery raises a domainguard.integration.delivery_failed event on your report. Nothing is dropped silently.
Each POST carries X-Ingenious-Event, X-Ingenious-Delivery, X-Ingenious-Attempt and X-Ingenious-Signature: sha256=… — an HMAC-SHA256 over the event envelope (every field except the product-specific data object), canonicalized as sorted-keys compact JSON, so any JSON parser can recompute it exactly:
import hashlib, hmac, json
def canonical_envelope(body):
env = {k: v for k, v in body.items() if k != "data"}
return json.dumps(env, sort_keys=True, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
def verify(secret, body, signature_header):
expected = hmac.new(secret.encode(), canonical_envelope(body),
hashlib.sha256).hexdigest()
return hmac.compare_digest(
expected, signature_header.removeprefix("sha256="))
Route and authorize on the envelope; treat data as detail. Any 2xx response counts as delivered.
3 · GitHub / GitLab — issues, opened for you
Choose the GitHub or GitLab channel, name the repository (owner/repo) or project (id or path), and paste your own token scoped to create issues on that one project. Each matching event opens one issue with the evidence attached. Tokens are stored in this product's database so deliveries can be made, and are never shown again after saving.
4 · Slack / Teams — chat, where your team is
Create an incoming webhook in your own Slack workspace or a Teams workflow webhook, and paste its URL as the target. Those URLs are credentials in themselves — anyone holding one can post to the channel — so treat them like passwords. Events arrive as a short formatted message naming what changed and what to do.
5 · REST + MCP — pull it yourself
GET /api/v1/events, GET /api/v1/events/{id} and GET /api/v1/actions read your claimed report's events with the holder API key created on its Integrations page (sent as a Bearer token in the Authorization header, or as X-API-Key). POST /api/v1/integrations/deliver-due flushes queued retries. An MCP server (mcp_server.py, shipped with the product) exposes the same reads as tools — list_events, list_pending_actions, get_event — for agent runtimes.
What integrations never do
They never invent events: only real recorded activity is delivered (test pings are labelled Test fixture and live only in the delivery log). They never include another report's data — a subscription only ever receives its own claimed report's events, and events recorded before you claimed the report are never delivered retroactively. And they never hide a failure: four missed attempts and the failure itself becomes an event you can act on.