Build visual automation scenarios in Make (formerly Integromat) that respond to PQ Intel buying signals in real time. Route leads, transform data, and connect to 1,000+ apps — all without code.
The PQ + Make integration enables visual, drag-and-drop automation scenarios triggered by PQ Intel buying signals. Using Make's Webhook module as the trigger, you can build complex multi-step scenarios that transform and route signal data to over 1,000 connected apps and services. Each PQ signal payload includes the prospect's name, company, signal platform, excerpt, ICP match score, and hot/warm classification — giving you everything you need to build intelligent automation.
Unlike traditional point-to-point integrations, Make's visual scenario builder lets you chain multiple modules together: parse incoming signal data with Text Parser, route by ICP score threshold with Router, aggregate daily signals with Array Aggregator, transform field values with Set Variable, and send the final payload to any of Make's 1,000+ app connectors. Every module updates in real time as you design, so you can see exactly how data flows through each step before activation.
Make scenarios support conditional branching, looping over arrays of signals, error handling routes, and scheduled or instant execution. This makes PQ + Make suitable for everything from simple lead logging to sophisticated multi-stage pipeline automation with enrichment, scoring re-calculation, and Slack or email alerting.
Log new leads to Airtable with signal context, send filtered daily email digests to stakeholders, post scored leads to Slack channels with conditional formatting, sync enriched signals to Google Sheets, create Asana tasks for follow-up, and chain multiple data transformation modules for complex logic. Because Make connects to 1,000+ apps, the only limit is your scenario design.
In Make, create a new scenario and add a Webhook module as the trigger. Click Add to generate a new webhook URL. Make will display a unique URL — copy this to your clipboard.
In PQ Intel, go to Settings > Integrations > Make. Paste your Make webhook URL, name the connection (e.g. "Lead Pipeline"), and click Save & Test. PQ sends a sample signal payload to verify the webhook is working.
Back in Make, the sample payload from PQ Intel populates the webhook module's output. Use Make's visual data mapper to connect PQ fields to your downstream modules — map prospect_name to Airtable's Name field, icp_score to a score column, signal_excerpt to a notes field. Add filters, routers, and transformers as needed.
Set your scenario's schedule (instant, every 15 minutes, or custom interval) and toggle it to On. Make will process each incoming PQ signal according to your scenario design. Use Make's history panel to monitor execution and debug any issues.
After the webhook trigger, add a Router module to branch your scenario based on ICP score thresholds, signal platform, or any payload field. Use Set Variable to rename or derive new fields (e.g. combine first_name and last_name into a full name). Add an Iterator if your webhook delivers an array of signals — it will process each item through the downstream pipeline individually. Chain these modules before your final action module to reshape the data exactly as your destination app expects.
Make's error handler module catches failures at any step. Drag an error handler route from the gear icon on any module and configure a fallback — for example, if the Airtable module fails, route the payload to a Google Sheet error log or send an alert to Slack. For critical pipelines, set up a separate rollback scenario that watches for failed webhook deliveries and retries with exponential backoff. This ensures no PQ Intel signal is ever lost due to a transient app error.
The table below maps every field delivered by the PQ Intel webhook to the Make modules you would typically use to handle, transform, or route that data.
| PQ Webhook Field | Type | Description | Recommended Make Module |
|---|---|---|---|
prospect_name |
string | Full name of the prospect detected | Webhook (trigger), Set Variable (rename), Text Parser (extract parts) |
company_name |
string | Company name associated with the prospect | Webhook (trigger), Router (filter by company), HTTP (enrich via Clearbit) |
signal_platform |
string | Source platform (e.g. LinkedIn, Reddit, Hacker News) | Router (branch by platform), Text Parser (normalize), Set Variable |
signal_excerpt |
string | Short excerpt of the signal content | Text Parser (extract keywords), Set Variable (truncate length), HTTP (send to GPT) |
signal_url |
url | Permalink to the original signal | Webhook (trigger), HTTP (fetch full content), Set Variable (embed in email) |
icp_score |
integer | ICP match score (0-100) | Router (branch by tier: hot/warm/cold), Set Variable (label), Filter |
classification |
string | Hot, warm, or exploratory label | Router (route to channel), Set Variable (tag), Text Parser |
signal_timestamp |
ISO 8601 | When the signal was detected | Set Variable (format date), Router (daily digest window), Text Parser |
profile_url |
url | PQ Intel profile link for the prospect | HTTP (fetch full profile), Set Variable (embed in notification) |
domain |
string | Prospect's company domain | Router (filter by domain list), HTTP (enrich via Apollo), Set Variable |
title |
string | Prospect's job title (when available) | Router (filter by seniority), Text Parser (normalize), Set Variable |
Webhook — Receives the PQ Intel payload as the scenario trigger. Router — Branches the flow based on field values (e.g. ICP score > 80). Text Parser — Extracts, replaces, or transforms text fields. Array Aggregator — Collects multiple signals into a single bundle (e.g. daily digest). HTTP — Makes outbound API calls to third-party services for enrichment. Set Variable — Creates or modifies variables in the data flow.
Every PQ Intel signal automatically creates a new record in your Airtable base with prospect name, company, signal source, ICP score, and a direct link back to the full PQ profile. Use Airtable's views, filters, and interfaces to manage your pipeline alongside other team data.
Use Make's filter and aggregation modules to collect all signals detected in a 24-hour window, format them into a structured HTML email, and send a daily digest to your team. Filter by minimum ICP score, specific platforms, or signal type to reduce noise and deliver only the most relevant leads.
Route PQ Intel signals to different Slack channels based on ICP score thresholds using Make's Router module. Hot leads (≥ 80) go to #urgent-leads with an @channel mention and formatted badge, warm leads go to #leads-review, and exploratory signals log to a private tracking channel.
If PQ Intel signals are not reaching Make, verify that the webhook URL pasted into PQ Intel's integration settings exactly matches the URL generated by Make's Webhook module. A single character mismatch (including trailing slashes) will prevent delivery. Re-copy the URL from Make and re-save in PQ Intel, then use the Test button in PQ to send a sample payload. Also confirm your Make scenario is toggled On — a stopped scenario discards incoming webhook data.
When the webhook trigger fires but subsequent modules receive empty or partial data, check your webhook response settings in Make. Open the Webhook module settings and ensure "Get response headers" is enabled if your downstream modules need response data. Also verify that each module's mapping references the correct webhook output path — Make uses dot-notation like data.prospect_name. Run each module individually using the right-click "Run this module only" option to isolate where the data chain breaks.
Make scenarios stop automatically when a module fails unless error handlers are configured. Open the Scenario history panel (clock icon in the bottom toolbar) to inspect the execution log for the failed run. Red-highlighted modules show the exact error message — common causes include invalid API keys in downstream apps, rate-limit responses, or data format mismatches. Right-click the failed module and select "Run this module only" with sample data to reproduce and debug the issue in isolation.
If Make is unable to connect to your destination app (Airtable, Google Sheets, Slack, etc.), verify that the connection credentials in Make are still valid. Navigate to Make's Connections page and locate your app connection — expired OAuth tokens or revoked API keys are the most common cause. Re-authenticate the connection, then test it independently before re-attaching it to your PQ scenario. For HTTP modules, ensure your header configuration matches the destination API's specification exactly, including Authorization: Bearer <token> format and any required custom headers.
Connect PQ Intel to Make in under 60 seconds. Build drag-and-drop scenarios that route, transform, and deliver buying signals to your entire tech stack.
See plans & pricing → Free 14-day trial on Growth. No credit card required.PQ Intel sends data to Make via a webhook URL — it never reads data from Make or your connected apps. The webhook URL is write-only, making it a secure trigger mechanism with no exposed read permissions.
All webhook payloads are encrypted with TLS 1.3 in transit. PQ Intel stores your webhook URL encrypted at rest using AES-256. No signal payloads are cached or stored after delivery.
There is no cap on how many signals PQ Intel can send to your Make scenarios. Your Make plan's operation limits apply independently — PQ Intel does not gate, throttle, or limit webhook delivery based on your subscription tier.
You can configure each PQ + Make connection to only send signals that match specific ICP profiles, score thresholds, or platform sources. This ensures your Make scenarios only process signals that are relevant to that particular automation.