Leadpipe + Pipedrive: Visitor Data to Deals

Pipedrive is built around deals. Every contact, every activity, every email is tracked relative to a deal moving through your pipeline. But the pipeline only works if leads actually get into it. Right now, 97% of your website visitors are browsing, researching, and leaving without filling out a form. They never enter Pipedrive. They never enter your pipeline.

Leadpipe identifies those visitors - name, email, company, job title, pages viewed - and sends that data to Pipedrive in real time. No form fill required. This guide covers the full setup: webhook configuration, field mapping, when to create a Person vs. a Deal, and automation recipes that prioritize high-intent visitors.

How It Works

The integration follows a simple flow:

Website Visitor → Leadpipe Identifies → Webhook Fires → Pipedrive Record Created

Leadpipe’s real-time webhooks fire the moment a visitor is identified. You can route that data to Pipedrive through two paths:

Path	Setup Time	Best For
Zapier (Webhook → Pipedrive)	15 minutes	Most teams, no-code setup
Direct API (Webhook → Pipedrive API)	30-60 minutes	High volume, custom logic

Both paths achieve the same result. Zapier is faster to set up. The direct API gives you more control over filtering and deduplication.

What You’ll Need

Leadpipe account - Start free with 500 leads
Pipedrive account with API access (all plans include API)
Zapier account (if using the Zapier path)
~20 minutes for setup

Step 1: Set Up the Leadpipe Webhook

In Leadpipe, go to Settings > Integrations > Webhooks
Click Add Webhook
Choose trigger type:
- First Match - one webhook per visitor (recommended for creating new Pipedrive records)
- Every Update - fires on each page view from identified visitors (use for activity tracking)
Enter your destination URL (Zapier catch hook or your API endpoint)
Save and send a test event

Start with First Match. It gives you one clean payload per identified visitor, which maps perfectly to creating a new Person or Deal in Pipedrive.

Step 2: Field Mapping - Leadpipe to Pipedrive

Pipedrive uses People, Organizations, and Deals as its core objects. Here’s how Leadpipe data maps to each:

Person Fields

Leadpipe Field	Pipedrive Person Field	Notes
`email`	Email	Primary identifier
`first_name`	Name (first part)	Combine with last_name
`last_name`	Name (second part)	Combine with first_name
`phone`	Phone	When available
`linkedin_url`	LinkedIn (custom field)	Create as custom field
`job_title`	Job Title (custom field)	Create as custom field
`city`	Person address - City
`state`	Person address - State
`country`	Person address - Country

Organization Fields

Leadpipe Field	Pipedrive Organization Field	Notes
`company_name`	Name
`company_domain`	Address (or custom field)	Useful for enrichment lookups

Deal Custom Fields

Leadpipe Field	Pipedrive Deal Field	Notes
`page_url`	Last Page Viewed (custom)	High-intent signal
`visit_duration`	Visit Duration (custom)	Engagement indicator
`pages_viewed`	Pages Viewed (custom)	Full visitor journey

Creating Custom Fields in Pipedrive

Before connecting, create these custom fields:

Go to Settings > Data fields
Add to Person object:
- LinkedIn URL (Text)
- Job Title (Text)
Add to Deal object:
- Last Page Viewed (Text)
- Visit Duration (Numeric)
- Pages Viewed (Large text)
- Lead Source (Single option) - add “Leadpipe Visitor ID” as an option

Step 3: The Zapier Path

Create the Zap

Trigger: Webhooks by Zapier - Catch Hook

Create a new Zap in Zapier
Choose Webhooks by Zapier > Catch Hook as the trigger
Copy the generated URL
Paste it into Leadpipe’s webhook configuration
Send a test event from Leadpipe to capture sample data

Filter Step: Skip Low-Quality Visitors

Add a Filter to keep your Pipedrive clean:

Only continue if:
  email - Exists
  AND
  email - Does not contain - gmail.com, yahoo.com, hotmail.com, outlook.com
  AND
  visit_duration - Greater than - 20

This ensures only business visitors with meaningful engagement reach Pipedrive. Adjust the duration threshold based on your typical visit patterns.

Action: Pipedrive - Create Person

Select Pipedrive as the action app
Choose Create Person
Map fields:
- Name: {{first_name}} {{last_name}}
- Email: {{email}}
- Organization: {{company_name}} (Pipedrive will auto-create if it doesn’t exist)
- Phone: {{phone}}
- LinkedIn URL: {{linkedin_url}}
- Job Title: {{job_title}}

Action 2: Pipedrive - Create Deal (Optional)

If you want a deal created automatically:

Add another Pipedrive action: Create Deal
Map fields:
- Title: Leadpipe - {{company_name}}
- Person: Use the Person ID from the previous step
- Pipeline: Select your inbound pipeline
- Stage: Select your first stage (e.g., “New Lead”)
- Lead Source: “Leadpipe Visitor ID”
- Last Page Viewed: {{page_url}}
- Visit Duration: {{visit_duration}}

Person vs. Deal: When to Create Which

This is the most important decision in the integration. Pipedrive’s revenue model revolves around Deals, but not every identified visitor deserves a Deal immediately.

Create a Person Only When:

Visitor viewed blog content or documentation
Visit duration was under 60 seconds
Job title doesn’t match your ICP
You want to nurture before selling

Create a Person + Deal When:

Visitor viewed pricing, demo, or case study pages
Visit duration exceeded 90 seconds
Job title matches decision-maker roles
Company matches your target account list

Implementation in Zapier

Use Paths in Zapier to handle this logic:

Path A: High Intent (Create Person + Deal)

Conditions:
  page_url - Contains - /pricing, /demo, /case-studies
  OR
  visit_duration - Greater than - 90

Actions: Create Person → Create Deal (linked to Person)

Path B: Low Intent (Create Person Only)

Conditions:
  Default path (everything else)

Actions: Create Person only

This keeps your deal pipeline focused on visitors showing real buying signals while still capturing all identified visitors as contacts for future outreach.

Step 4: The Direct API Path

For teams with developer resources, Pipedrive’s REST API is straightforward. Here’s how to connect it directly to Leadpipe webhooks.

Sample Integration (Node.js)

const express = require('express');
const axios = require('axios');

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

const PIPEDRIVE_API_TOKEN = process.env.PIPEDRIVE_API_TOKEN;
const PIPEDRIVE_BASE = 'https://yourcompany.pipedrive.com/api/v1';

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

  // Skip personal emails
  const skipDomains = ['gmail.com', 'yahoo.com', 'hotmail.com'];
  if (skipDomains.includes(visitor.email?.split('@')[1])) {
    return res.status(200).json({ skipped: true });
  }

  try {
    // Search for existing person by email
    const search = await axios.get(
      `${PIPEDRIVE_BASE}/persons/search?term=${visitor.email}&api_token=${PIPEDRIVE_API_TOKEN}`
    );

    let personId;

    if (search.data.data?.items?.length > 0) {
      // Person exists - update
      personId = search.data.data.items[0].item.id;
      await axios.put(
        `${PIPEDRIVE_BASE}/persons/${personId}?api_token=${PIPEDRIVE_API_TOKEN}`,
        { name: `${visitor.first_name} ${visitor.last_name}` }
      );
    } else {
      // Create new person
      const person = await axios.post(
        `${PIPEDRIVE_BASE}/persons?api_token=${PIPEDRIVE_API_TOKEN}`,
        {
          name: `${visitor.first_name} ${visitor.last_name}`,
          email: [{ value: visitor.email, primary: true }],
          phone: visitor.phone ? [{ value: visitor.phone, primary: true }] : [],
          org_id: null, // Will be linked after org creation
          // Custom fields mapped by their hash keys
        }
      );
      personId = person.data.data.id;
    }

    // Create deal for high-intent visitors
    const highIntentPages = ['/pricing', '/demo', '/case-studies', '/contact'];
    const isHighIntent = highIntentPages.some(p => visitor.page_url?.includes(p))
      || visitor.visit_duration > 90;

    if (isHighIntent) {
      await axios.post(
        `${PIPEDRIVE_BASE}/deals?api_token=${PIPEDRIVE_API_TOKEN}`,
        {
          title: `Leadpipe - ${visitor.company_name || visitor.email}`,
          person_id: personId,
          stage_id: 1, // Your first pipeline stage
          // Custom fields for page_url, visit_duration
        }
      );
    }

    res.status(200).json({ success: true, personId });
  } catch (err) {
    console.error('Pipedrive error:', err.response?.data || err.message);
    res.status(500).json({ error: err.message });
  }
});

app.listen(3000);

The direct API approach lets you implement custom deduplication, conditional deal creation, and organization matching in a single request handler.

Activity Tracking with Every Update Webhooks

Once your base integration is running with First Match, you can add Every Update webhooks to track ongoing visitor behavior as Pipedrive Activities.

Why Track Activities

Pipedrive’s Activity view shows your reps everything happening with a deal. By logging return visits as Activities, reps can see:

When a prospect came back to your site
Which pages they viewed on return visits
How much time they spent (engagement depth)
Whether they viewed pricing after receiving your proposal

Setup

Create a second webhook in Leadpipe with Every Update trigger, pointing to a separate endpoint. On each webhook:

Look up the Person by email
If found, create an Activity:
- Subject: “Website visit - [page_url]”
- Type: “website_visit” (create custom activity type)
- Note: “Viewed [page_url] for [visit_duration] seconds”
- Person: Linked to existing Person
- Deal: Linked to open Deal (if one exists)

This gives your reps a timeline of visitor engagement directly in the deal view. When they see a prospect who received a proposal yesterday just spent 3 minutes on your pricing page today, that’s a signal to follow up immediately.

Filtering: Only Send ICP Visitors to Pipedrive

Sending every identified visitor to Pipedrive creates noise. Your reps will ignore it. Instead, filter for your Ideal Customer Profile before creating records.

Filter by Job Title

Only send visitors with titles that match your buyer personas:

Include titles containing:
  VP, Director, Head of, Manager, Chief, Founder, CEO, CTO, CMO, COO

Exclude titles containing:
  Intern, Student, Freelance, Consultant (if not your ICP)

Filter by Company Size

If Leadpipe returns company data, filter for your target company size. If not, use the company_domain to enrich with company size data through Clay before sending to Pipedrive.

Filter by Page Intent

Not all pages signal buying intent:

Page Type	Intent Level	Action
`/pricing`, `/demo`, `/contact`	High	Create Person + Deal
`/case-studies`, `/features`, `/integrations`	Medium	Create Person, assign to nurture
`/blog/*`, `/about`, `/careers`	Low	Create Person only (or skip)

Filter by Geography

If you only sell in specific regions, filter by country to avoid creating leads you can’t serve.

Pipedrive Automations for Visitor Leads

Pipedrive’s built-in Automations feature can trigger follow-up actions when Leadpipe creates records.

Automation 1: Assign to Rep Based on Territory

Trigger: Deal created with Lead Source = “Leadpipe Visitor ID” Condition: Person’s country = “US” Action: Assign deal to US sales rep

Automation 2: Send Follow-Up Email

Trigger: Deal created in pipeline stage “New Lead” Condition: Lead Source = “Leadpipe Visitor ID” Action: Send email template (personalized with visitor’s name and company)

Automation 3: Move Deal to Next Stage on Return Visit

Trigger: Activity created with type “website_visit” Condition: Deal exists in stage “New Lead” Action: Move deal to “Engaged” stage

Automation 4: Notify Rep of Pricing Page Visit

Trigger: Activity note contains “/pricing” Condition: Open deal exists Action: Send notification to deal owner

These automations turn passive data into active pipeline management. Your reps get notified about the right visitors at the right time, and deals progress through stages based on actual engagement.

Measuring Results

Once data is flowing, track these metrics in Pipedrive:

Metric	How to Measure	Target
Leads created/week	Filter deals by Lead Source	Depends on traffic
Conversion to qualified	Deals moving past stage 1	15-25%
Response time	Time from deal creation to first activity	Under 1 hour
Close rate vs. form fills	Compare by Lead Source	Track over 90 days
Revenue attributed	Won deals with Lead Source = Leadpipe	Track monthly

Build a Pipedrive dashboard (Insights > Dashboards) with these metrics to prove ROI and optimize your filtering thresholds over time.

Common Mistakes

Creating deals for every visitor. Your pipeline will be cluttered with low-intent visitors. Use filters and the Person vs. Deal logic described above.

Ignoring deduplication. Always search by email before creating a new Person. Return visitors and existing contacts will create duplicates otherwise.

No activity tracking. The initial record creation is only half the value. Every Update webhooks give you ongoing engagement data that reps need for timing their outreach.

Not setting Lead Source. Without tagging records as Leadpipe-sourced, you can’t measure ROI or compare channel performance in Pipedrive’s reporting.

Over-filtering. Start with loose filters and tighten over time. If you filter too aggressively, you’ll miss good leads. Watch your conversion rates at each filter threshold and adjust.

What’s Next

With Leadpipe data flowing into Pipedrive, consider extending the stack:

Add Clay enrichment between Leadpipe and Pipedrive for company revenue, employee count, and tech stack data
Set up parallel Slack alerts for instant team notification alongside Pipedrive record creation
Build Zapier automation recipes for multi-step workflows (identify → enrich → route → engage)
Connect your AI SDR to draft personalized outreach based on the visitor’s page journey

Try Leadpipe free with 500 leads -> and start filling your Pipedrive pipeline with visitors who are already researching your product.