How to Surface Product Qualified Leads with n8n

Most SaaS teams already sit on the strongest buying signal they'll ever get, and ignore it. A free user just hit 90% of their plan limit for the third week running. That's not a marketing lead. That's a n8n product qualified leads problem waiting for a workflow, because the account has shown intent the moment it stretched against a ceiling.

The catch is timing. A PQL is only hot while the friction is fresh. Wait for the Monday revenue review and the user has either upgraded on their own, churned, or forgotten why they cared. Speed-to-signal is the whole game, and that's exactly what an event-driven n8n pipeline is good at.

This walks through scoring product usage signals, routing the hot accounts to sales, and dropping everything else into a nurture lane — without paying for a dedicated PQL platform.

What you can automate

• Detect the exact moment a free user crosses a usage threshold (exports, seats, API calls)
• Score each account 0–100 on usage intensity and intent, not just job title
• Enrich the account with company data before sales ever sees it
• Route hot PQLs straight to a rep with a personalized opener
• Drop warm and cold accounts into a self-serve nurture sequence
• Dedupe so the same account never gets pinged twice in a week
• Log every scoring decision for a clean audit trail

Why most PQL guides stop short

The popular n8n PQL template on n8n.io (Score product-qualified leads with Amplitude, Claude & PDL) does the scoring part well: an Amplitude webhook fires on cohort entry, People Data Labs enriches, and Claude returns a 0–10 score with reasoning. Solid. But its own notes admit CRM creation, the warm and cold nurture paths, and multi-channel alerts are all "customization options," not built in. So you get a scorer, not a routing engine.

The widely-shared 2026 lead-gen guide (How to Automate Lead Generation with n8n) is worse for this job. It mentions product usage triggering exactly once, as a single throwaway example under "event-triggered sequences," then spends the rest of the post on firmographic scoring. PQLs aren't firmographic. That's the gap this post fills: the full loop from usage event to routed account, with the dedupe and the audit log that production actually needs.

Here's the opinionated part. Scoring a PQL on company size is a category error. A 12-person startup hammering your API is a better lead than a 5,000-seat enterprise whose one trial user logged in twice. Behavior beats firmographics for product-led motions, every time. Score the usage first, enrich second.

The PQL Pipeline

Trigger (usage event webhook)
  → Process (compute usage ratio + dedupe check)
    → Route (Switch: hot / warm / cold by score)
      → Action (CRM push + rep alert / nurture / log)

1. Collect the usage event

Your app emits an event when a user does something meaningful — exports a report, hits 90% of plan limit, invites a third teammate. Point it at an n8n n8n-nodes-base.webhook node. The webhook payload should carry the user ID, the metric, the current value, and the plan ceiling. Keep it small; enrichment happens later.

One trap worth naming. The Webhook node's default response timeout is 120 seconds. If your scoring path calls a slow enrichment API synchronously, the upstream caller can time out before n8n replies. Respond immediately with a 200, then do the heavy work after the response. n8n's "Respond Immediately" option on the webhook handles this cleanly.

2. Process and score the signal

A n8n-nodes-base.code node (v2, using jsCode) computes the usage ratio (currentValue / planCeiling) and a base behavioral score. That arithmetic doesn't need an LLM. The model's job is the part code can't do: reading intent from the pattern and drafting a human opener.

Feed the computed signal into the @n8n/n8n-nodes-langchain.openAi node (v2.1). Its output lands at $json.output[0].content[0].text — not the old n8n-nodes-base.openAi path that 2023 tutorials still reference, which breaks silently when you paste it in. Ask the model for a JSON object with a 0–100 score and a one-line reason. Then parse it with another Code node, because the model returns a string and the next node expects structured fields.

3. Route by score

A n8n-nodes-base.switch node splits the flow three ways. Score 80+ is hot: push to the CRM and ping a rep. 40–79 is warm: queue an automated nurture email. Below 40 is cold: log and wait for the next signal. Don't over-engineer the bands. Three lanes cover almost every product-led motion.

4. Act on hot accounts

For hot PQLs, an n8n-nodes-base.httpRequest node (v4.2) creates or updates the contact in HubSpot or Salesforce, stamping the score and the AI reason onto the record. A second branch fires a Slack or Telegram alert so a rep sees the account while the user is still in-product. That window is short. Usually minutes, not hours.

5. Log and dedupe

Before any of this fires, a dedupe gate checks whether the account already got an offer in the last seven days. Skip if so. Every decision (scored, routed, suppressed) appends a row to Google Sheets via n8n-nodes-base.googleSheets. That log is your audit trail and your model-tuning dataset.

Implementation patterns

Pattern 1: Immediate-response webhook. Respond 200 first, score after. Protects you from upstream timeouts when enrichment is slow.

Webhook (respond immediately)
  → Code: compute ratio
    → OpenAI: score + reason
      → continue async

Pattern 2: Threshold ladder. Don't fire on every event. Fire on crossings, when the account moves from below a band to above it. Store last-seen state in a Sheet or a n8n-nodes-base.set field so a user idling at 91% doesn't trigger daily.

Pattern 3: Enrich only the hot ones. Enrichment APIs cost money per call. Score on raw usage first, and only call People Data Labs or Clearbit for accounts that already crossed the hot threshold. Cuts enrichment spend by most of it.

n8n nodes you'll use most

Getting started

1. Add a Webhook node and set it to respond immediately. Copy the test URL.
2. Wire your app to POST a usage event (user ID, metric, value, ceiling) to that URL.
3. Add a Code node to compute the usage ratio and a base score.
4. Add the @n8n/n8n-nodes-langchain.openAi node; prompt it for a 0–100 score plus a one-line reason as JSON.
5. Parse the response with a second Code node, then split on a Switch.
6. On the hot branch, add an HTTP Request to your CRM and an alert node.
7. Append every run to Google Sheets, and gate the whole thing behind a 7-day dedupe check.

For a deeper look at the scoring half of this, the breakdown in n8n lead scoring automation covers prompt design and band tuning in detail.

The scoring logic here doubles as a self-serve conversion engine, not just a sales handoff. If you'd rather convert PQLs with an email than a rep, the approach in n8n CRM automation shows how to keep the CRM record and the nurture sequence in sync. And if your motion leans more sales-assist, the AI Lead Scoring & Email Routing template handles the routing fan-out once the score lands.