Leadpipe + Intercom: Identify and Engage Visitors in Real Time

Your best-fit buyer is on your pricing page right now. Intercom’s Messenger is sitting in the corner, ready to chat. But Intercom has no idea who she is, where she works, or that she has already read three of your comparison pages this week — so the best it can offer is a generic “Hi there, how can we help?”

Leadpipe closes that blind spot: it identifies anonymous B2B visitors by name, verified work email, company, and title, then writes that context into Intercom so your team greets the people who matter instead of guessing. No form fill, no “please enter your email” friction first.

This guide covers the full setup — the webhook, the field mapping, how to surface context in the Inbox, how to route hot accounts to sales, and how to run proactive messages that feel helpful instead of creepy. It also covers the part most “identify and chat” pitches skip: what actually ties a server-side match to a live chat session, and what doesn’t.

What connecting Leadpipe and Intercom actually does

Leadpipe identifies a visitor on your site using deterministic matching against its own proprietary identity graph. When there is a verified match, it hands you a structured record: name, work email, company, title, LinkedIn, and the exact pages viewed. When there isn’t a match, it returns nothing — you never get a statistical guess dressed up as a person.

Push that record into Intercom and three things change at once.

Without the integration	With Leadpipe → Intercom
Messenger opens with “Hi there” for everyone	Agents see name, company, title, and pages before they reply
Most B2B sessions sit in Intercom as anonymous leads	Fit visitors become enriched contacts with real firmographics
Sales learns about a hot account days later in analytics	Target-account chats route to the right rep in seconds
Proactive messages fire on blunt rules (URL + time on page)	Proactive messages can key on who the visitor is, not just where they are

In one sentence: Leadpipe turns Intercom from a reactive chat widget into a channel that already knows the account, the role, and the buying context before a single message is typed.

How identity actually flows into Intercom (the honest version)

This is where most integration guides overpromise, so let’s be precise about the plumbing.

Intercom splits contacts into two roles: leads (unidentified, no verified email) and users (identified). Every contact can carry standard fields plus custom data attributes you define. Those attributes are what Leadpipe fills in.

There are two reliable patterns, and one honest limitation.

Pattern A — enrich the contact record (works every time). When Leadpipe identifies a visitor, a webhook creates or updates an Intercom contact and its custom attributes. The context now lives on the profile permanently, ready for the moment that person opens a chat, replies to an email, or gets targeted by an outbound campaign. This is the pattern to build first.
Pattern B — enrich the live session (advanced). If the visitor is already a known or returning contact in your Messenger, you can attach Leadpipe data to the current session with the Messenger JavaScript API, so real-time rules fire while they’re on the page.
The limitation to respect. A brand-new, fully anonymous Messenger session is not automatically tied to a Leadpipe match — Intercom’s Messenger visitor and Leadpipe’s server-side identification are two different identities until something bridges them (an email in the Messenger, a shared user ID, or a return visit as a known contact). Leadpipe does not silently start chats with strangers, and you should not build a flow that pretends it can.

A note that matters for a global chat tool: Leadpipe resolves visitors to the person level for US traffic. Outside the US, coverage is lower and more often company-level, and consent and regional privacy rules are the starting point — see person-level vs company-level identification for the full picture.

Step 1 — Point a Leadpipe webhook at Intercom

Leadpipe fires a webhook the instant a visitor is identified. You’ll aim it at either an automation tool (Zapier or Make) or your own middleware.

In Leadpipe:

Go to Settings → Integrations → Webhooks.
Click Add Webhook and paste your destination URL.
Set the trigger to First Match — one clean event per identified visitor, so Intercom doesn’t collect a new record on every page view.
Save and send a test event.

The payload includes the fields you’ll map next: email, first_name, last_name, company_name, company_domain, job_title, linkedin_url, page_url, pages_viewed, and visit_duration. If you’d rather pull identifications on your own schedule, the visitor identification API exposes the same data.

Step 2 — Map Leadpipe fields to Intercom attributes

Before you connect anything, define your custom data attributes in Settings → Data → People so Intercom has somewhere to put the values. Prefix them (lp_) so they’re easy to filter on later.

Leadpipe field	Intercom destination	Type
`email`	Email	Standard (dedupe key)
`first_name` + `last_name`	Name	Standard
`company_name`	`lp_company`	Custom attribute
`company_domain`	`lp_company_domain`	Custom attribute
`job_title`	`lp_job_title`	Custom attribute
`linkedin_url`	`lp_linkedin`	Custom attribute
`page_url`	`lp_last_page`	Custom attribute
`pages_viewed`	`lp_pages_viewed`	Custom attribute (text)
`visit_duration`	`lp_visit_seconds`	Custom attribute (number)
derived	`lp_intent` (High / Medium / Low)	Custom attribute
derived	`Leadpipe`, `Target Account`	Tags

The lp_intent and tag columns are where the value compounds. A visitor who spent four minutes on /pricing from a domain on your target list should land as lp_intent = High and carry a Target Account tag — that single attribute drives your routing and your proactive rules downstream.

If you don’t want to write code, connect the webhook to a “Create or Update Contact” action in Make or Zapier, map the columns above, and you’re done. For teams that want full control, here’s the direct-API version.

import express from 'express';

const app = express();
app.use(express.json());

const API = 'https://api.intercom.io';
const headers = {
  Authorization: `Bearer ${process.env.INTERCOM_ACCESS_TOKEN}`,
  'Content-Type': 'application/json',
  'Intercom-Version': '2.11',
};

app.post('/leadpipe-webhook', async (req, res) => {
  const v = req.body;

  // Only push business contacts into Intercom
  const personal = ['gmail.com', 'yahoo.com', 'hotmail.com', 'outlook.com'];
  const domain = v.email?.split('@')[1]?.toLowerCase();
  if (!domain || personal.includes(domain)) {
    return res.status(200).json({ skipped: true });
  }

  const body = {
    role: 'user',
    email: v.email,
    name: `${v.first_name ?? ''} ${v.last_name ?? ''}`.trim(),
    custom_attributes: {
      lp_company: v.company_name,
      lp_company_domain: v.company_domain,
      lp_job_title: v.job_title,
      lp_linkedin: v.linkedin_url,
      lp_last_page: v.page_url,
      lp_pages_viewed: (v.pages_viewed || []).join(', '),
      lp_visit_seconds: v.visit_duration,
    },
  };

  // Find-or-update by email so you never create duplicates
  const search = await fetch(`${API}/contacts/search`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      query: { field: 'email', operator: '=', value: v.email },
    }),
  }).then((r) => r.json());

  const existing = search.data?.[0];
  const url = existing ? `${API}/contacts/${existing.id}` : `${API}/contacts`;
  const method = existing ? 'PUT' : 'POST';

  await fetch(url, { method, headers, body: JSON.stringify(body) });
  res.status(200).json({ success: true, updated: Boolean(existing) });
});

app.listen(3000);

The search-then-write step is what keeps your workspace clean. Intercom will happily create duplicate contacts if you skip it; always look up the email first.

Step 3 — Give your agents context in the Inbox

Custom data attributes render in the conversation sidebar. Once lp_company, lp_job_title, lp_last_page, and lp_pages_viewed are populated, an agent opening a chat sees the whole story instead of a nameless visitor.

Compare the two openings a rep can now write:

Before: “Hi there — how can I help?”
After: “Hi Sarah — saw you were comparing our Team and Business plans. Happy to walk through the differences for a 40-person data team like yours.”

Same product, same agent, completely different conversation. That difference is the entire point of the integration, and it’s why context in the Inbox matters more than any automation you layer on top.

Try Leadpipe free with 500 leads →

Step 4 — Route hot accounts to sales

Not every identified chat deserves the same treatment. Use the lp_intent attribute and your tags to route with Intercom’s Workflows and assignment rules:

Target-account conversations (tagged Target Account) skip the general queue and assign straight to the named account owner.
High-intent contacts (lp_intent = High) get a priority SLA and a nudge in your sales channel.
Everyone else stays in the standard support flow.

Intercom is one destination, not the only one. Fire the same Leadpipe webhook to your other tools in parallel so nobody has to live inside the Messenger to catch a signal.

Destination	Best at	When it fires
Intercom	On-site engagement plus agent context in live chat	When the visitor is (or becomes) a known contact
Slack / Teams	Instant human alert so a rep acts now	Every qualified identification
CRM (Salesforce / HubSpot)	System of record, routing, reporting	Every qualified identification
Make / Zapier	The plumbing that fans one webhook out to all of the above	On every webhook event

For the account-monitoring side — knowing when a named account is on your site even if they never open a chat — pair this with tracking target-account visits and your pricing-page playbook.

Step 5 — Proactive messages that help instead of lurk

Intercom’s outbound chats, banners, and posts can be targeted by audience rules — including the custom attributes you just wrote. That means you can trigger a proactive message on who someone is and what they read, not just a raw URL and a timer.

Strong, tasteful uses:

Returning known contact on pricing. A contact you’ve already matched comes back to /pricing. Fire a chat offering to book time — they’re in a buying window.
High-intent role match. When lp_job_title contains a buyer title and lp_intent = High, surface a “want a 15-minute walkthrough?” banner.
Account-based welcome. For contacts tagged Target Account, route them to a named rep’s calendar instead of a generic queue.

The line you don’t cross: never reveal how you know who they are, and never open with details a stranger would find unsettling. Lead with relevance, not surveillance. The same discipline that makes personalized outbound work applies here — reference the topic they cared about, not the fact that you fingerprinted them. For the messages that follow the chat, wire identified contacts into a warm outbound sequence and your lead-nurturing flows.

In one sentence: Trigger Intercom’s proactive messages off Leadpipe’s identity and intent attributes, target known and returning contacts, and keep the copy about their problem rather than your data.

Common mistakes to avoid

Alerting on personal emails. Gmail and Yahoo visitors rarely justify a proactive chat. Filter them out before they reach Intercom, exactly as the code sample does.
Skipping the find-or-update step. Without an email lookup, return visits pile up as duplicate contacts and your lp_intent attribute overwrites itself into nonsense.
Treating a server-side match as a live session. Build Pattern A first. Only reach for the Messenger JavaScript bridge once you have a real way to tie identity to the session.
Sending everything to one Inbox. Route by intent and account. A firehose gets muted the same way a noisy Slack channel does.
Ignoring intent scoring. Feed lp_visit_seconds and page paths into behavior-based lead scoring so “high intent” means something consistent across your team.

FAQ

Does Leadpipe automatically start a chat with anonymous visitors in Intercom?

No — and any tool that claims it can with a brand-new anonymous session is glossing over how identity works. Leadpipe identifies visitors server-side and writes them into Intercom as enriched contacts. Real-time proactive messages fire reliably for known and returning contacts, or once the visitor identifies themselves in the Messenger. That honesty is the difference between a durable setup and one that breaks the first time someone audits it.

Do I need a developer, or can I connect Leadpipe and Intercom with no code?

No code is required. Route the Leadpipe webhook into a “Create or Update Contact” action in Make or Zapier, map the fields from the table above, and you’re live in about 20 minutes. Use the direct Intercom Contacts API only if you want custom deduplication logic, high volume, or to combine the write with other steps in one service.

How does the Leadpipe and Intercom integration handle non-US and EU visitors?

Coverage is strongest in the US, where Leadpipe resolves visitors to the person level. Outside the US it is lower and more often company-level, and you should run identification alongside your consent and regional privacy obligations rather than around them — Leadpipe does not claim to override GDPR. Set your Intercom proactive rules to respect the same consent states you already honor in the Messenger.

How accurate is the match feeding into Intercom?

Because matching is deterministic, Intercom only receives a contact when there is a verified match — no probabilistic guesses inflating your workspace. In independent testing, Leadpipe’s matches were accurate roughly 82% of the time, which is why the contacts your agents open are worth trusting. See the product overview for how the identity graph is built.

Start greeting your best visitors with context

Intercom already sits on your highest-intent pages. The only thing missing is knowing who’s on the other side of the Messenger — and that’s exactly what Leadpipe adds. Wire up the webhook, map the attributes, route the hot accounts, and your team stops typing “Hi there” to people it should already recognize.

Try Leadpipe free — 500 identified leads, no credit card required.