Most identity resolution providers require six-month enterprise contracts, a dedicated integration team, and a budget north of $100K before you can make your first API call. LiveRamp starts at $300K+/year. ZoomInfo enterprise contracts run $100K+. Oracle Data Cloud doesn’t even publish pricing — you need a “strategic partnership.”
What if you could add visitor identification to your SaaS product with 5 API calls and 10 minutes?
This isn’t a sales pitch disguised as a tutorial. This is a step-by-step developer quickstart with working code in JavaScript and Python. By the end, your platform will know who visits each of your clients’ websites — names, emails, job titles, companies, LinkedIn profiles — delivered via webhook in real time.
I’ve watched developers spend weeks evaluating visitor identification tools, negotiating contracts, and sitting through demo calls — only to discover the provider doesn’t even offer API access at their pricing tier. That’s not how this should work.
Let’s build it.
Table of Contents
- What You’ll Build
- Prerequisites
- Step 1: Get Your API Key (1 Minute)
- Step 2: Create a Pixel via API (2 Minutes)
- Step 3: Install the Pixel (2 Minutes)
- Step 4: Set Up Your Webhook Receiver (3 Minutes)
- Step 5: Query Visitor Data via API (2 Minutes)
- Bonus: Check Account Health
- Scaling to Multi-Tenant
- What You Can Build Next
- The Cost Comparison
What You’ll Build
Here’s the architecture. Five components, zero complexity:
┌─────────────────────────────────────────────────────────────────┐
│ IDENTITY RESOLUTION IN YOUR SAAS │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. YOUR SAAS BACKEND │
│ │ │
│ ├── POST /v1/data/pixels → Create pixel for client │
│ │ │
│ 2. CLIENT'S WEBSITE │
│ │ │
│ ├── <script> pixel installed in <head> │
│ │ │
│ 3. LEADPIPE IDENTITY GRAPH │
│ │ │
│ ├── Resolves anonymous visitor → person + company │
│ │ │
│ 4. WEBHOOK → YOUR BACKEND │
│ │ │
│ ├── POST /webhook/leadpipe → Receive identified visitor │
│ │ │
│ 5. YOUR PRODUCT │
│ │ │
│ └── Display visitor data to your users │
│ │
└─────────────────────────────────────────────────────────────────┘The end result: Every time someone visits your client’s website, Leadpipe identifies them and pushes structured data to your backend. Your product shows the data. Your users see who’s on their site. You didn’t build an identity graph — you just plugged into one.
What kind of data are we talking about? Full names, business emails, personal emails, phone numbers, LinkedIn profile URLs, job titles, company names, company domains, pages viewed, visit durations, and return visit tracking. Person-level and company-level, not the company-only IP-reverse-lookup data that most tools provide.
This is the same pattern that AI SDR platforms and sales tools use to power visitor-aware features. The difference is you’re going to do it in 10 minutes instead of 10 months.
Prerequisites
You need three things:
-
A Leadpipe account with an API key. Sign up free — you get 500 identified leads, no credit card required. API key comes from Dashboard > Settings > API Keys.
-
Node.js or Python. Any recent version works. The examples use
fetch(Node 18+) andrequests(Python 3.x). -
A domain to test with. Your own site, a staging environment, or a client’s domain you have permission to instrument.
That’s it. No SDK to install, no OAuth dance, no client libraries. It’s a REST API with an API key. If you can make HTTP requests, you can build this.
Step 1: Get Your API Key (1 Minute)
Open the Leadpipe dashboard. Navigate to Settings > API Keys > Create.
Your key will look like this:
sk_live_abc123...Authentication is a single header on every request:
X-API-Key: sk_your_keyBase URL for all endpoints:
https://api.aws53.cloudNo tokens to refresh. No OAuth scopes. No session management. Every request is stateless — send the header, get the data. If you’ve ever integrated Stripe, Twilio, or SendGrid, this will feel familiar.
Security note: Treat your API key like a password. Store it in environment variables, never in client-side code. If you’re building a multi-tenant platform, your key stays on your backend — clients never see it.
Step 2: Create a Pixel via API (2 Minutes)
A pixel is a lightweight JavaScript snippet that runs on your client’s website to collect visit data. In the Leadpipe model, each client gets their own pixel. This gives you per-client data isolation out of the box.
Here’s how to create one programmatically.
JavaScript
const response = await fetch('https://api.aws53.cloud/v1/data/pixels', {
method: 'POST',
headers: {
'X-API-Key': 'sk_your_key',
'Content-Type': 'application/json'
},
body: JSON.stringify({
domain: 'client-website.com',
name: 'Client A'
})
});
const pixel = await response.json();
console.log(pixel);
// Response:
// {
// id: "uuid-1234-5678",
// domain: "client-website.com",
// name: "Client A",
// status: "active",
// code: "<script>...</script>",
// createdAt: "2026-04-01T12:00:00Z"
// }Python
import requests
resp = requests.post(
'https://api.aws53.cloud/v1/data/pixels',
headers={
'X-API-Key': 'sk_your_key',
'Content-Type': 'application/json'
},
json={
'domain': 'client-website.com',
'name': 'Client A'
}
)
pixel = resp.json()
print(pixel)The key field in the response is code. That’s the JavaScript snippet your client needs to install. You can display it in your product’s UI, email it to the client, or inject it programmatically if you control their site (e.g., through a tag manager or platform embed).
One API call. One pixel. One client isolated. That’s all it takes.
A note on naming conventions: Use the name field to store something meaningful — your internal client ID, the client’s company name, or a project identifier. When you’re managing 50 or 200 pixels, you’ll be glad you established a naming convention from day one.
Step 3: Install the Pixel (2 Minutes)
The pixel.code value from Step 2 is a self-contained <script> tag. It needs to go in the <head> of the client’s website.
Option A: Client installs it manually
Give your client the snippet and tell them to paste it before the closing </head> tag:
<head>
<!-- ... other tags ... -->
<!-- Leadpipe Visitor Identification -->
<script>
// The exact code from pixel.code goes here
</script>
</head>This is the same two-minute process described in our complete setup guide. It works with any website — WordPress, Shopify, Next.js, static HTML, whatever.
Option B: You inject it programmatically
If your platform controls the client’s site (like a website builder or marketing tool), inject the pixel code directly:
// In your platform's page renderer or tag manager
function installPixelForClient(clientId) {
const pixelCode = getPixelCodeFromDB(clientId); // The code from Step 2
const script = document.createElement('script');
script.innerHTML = pixelCode;
document.head.appendChild(script);
}Either way, once the pixel is live, Leadpipe starts collecting visit data immediately. Identifications typically begin within the first few visits, with match rates of 30-40%+ depending on traffic quality.
Step 4: Set Up Your Webhook Receiver (3 Minutes)
This is where the magic happens. When Leadpipe identifies a visitor, it sends a POST request to your webhook endpoint with structured person, company, and behavioral data.
Build the endpoint
// Express.js webhook receiver
const express = require('express');
const app = express();
app.use(express.json());
app.post('/webhook/leadpipe', (req, res) => {
const visitor = req.body;
// visitor includes: email, first_name, last_name, company_name,
// company_domain, job_title, linkedin_url, page_url, visit_duration
console.log(
`Identified: ${visitor.first_name} ${visitor.last_name} ` +
`from ${visitor.company_name}`
);
// Save to your database
await db.visitors.insert({
email: visitor.email,
name: `${visitor.first_name} ${visitor.last_name}`,
company: visitor.company_name,
title: visitor.job_title,
page: visitor.page_url,
duration: visitor.visit_duration,
identifiedAt: new Date()
});
// Trigger your product's workflows
notifyUser(visitor);
updateDashboard(visitor);
res.status(200).send('OK');
});
app.listen(3000);Python equivalent
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route('/webhook/leadpipe', methods=['POST'])
def handle_webhook():
visitor = request.json
print(f"Identified: {visitor['first_name']} {visitor['last_name']} "
f"from {visitor['company_name']}")
# Save to your database, trigger workflows, notify users
save_visitor(visitor)
notify_user(visitor)
return jsonify({'status': 'ok'}), 200Configure the webhook in Leadpipe
- Go to your Leadpipe dashboard
- Navigate to Integrations > Webhooks > Add
- Paste your endpoint URL (e.g.,
https://api.yourplatform.com/webhook/leadpipe) - Set the trigger mode:
- First Match — fires once per visitor the first time they’re identified (best for lead capture and CRM creation)
- Every Update — fires whenever new data is appended to a known visitor (best for behavioral tracking and return visit alerts)
Which trigger mode should you use? If your product focuses on initial lead capture — surfacing new prospects to your users — start with First Match. If you’re building engagement scoring, return visit tracking, or page-level behavioral analysis, use Every Update. Many production integrations use both: First Match to create the contact record, Every Update to append behavioral data over time.
Webhook data fields
Here’s every field you’ll receive in the webhook payload:
| Field | Type | Example |
|---|---|---|
email | string | jane@acme.com |
first_name | string | Jane |
last_name | string | Smith |
company_name | string | Acme Corp |
company_domain | string | acme.com |
job_title | string | VP Marketing |
linkedin_url | string | linkedin.com/in/janesmith |
page_url | string | /pricing |
visit_duration | number | 180 (seconds) |
What can you do with this data? Feed it into AI sales agents for real-time outreach. Push it to your CRM. Display it in your product’s dashboard. Build lead scoring models. Trigger automations based on which pages they viewed. The webhook is the bridge between raw identification and whatever your product does with it.
For a deeper reference on all available webhook fields and payload structures, see the Webhook Payload Reference.
Soft CTA: Not ready to build yet? Just want to see the data? Try Leadpipe free with 500 leads —> No credit card, no contract. See who’s visiting your site before you write a single line of integration code.
Step 5: Query Visitor Data via API (2 Minutes)
Webhooks give you real-time push. The REST API gives you pull — historical queries, search, filtering, and pagination.
Get recent visitors
const response = await fetch(
'https://api.aws53.cloud/v1/data?timeframe=7d&page=1',
{
headers: { 'X-API-Key': 'sk_your_key' }
}
);
const visitors = await response.json();
// Returns up to 50 identified visitors per pagePython
resp = requests.get(
'https://api.aws53.cloud/v1/data',
headers={'X-API-Key': 'sk_your_key'},
params={'timeframe': '7d', 'page': 1}
)
visitors = resp.json()Look up a single visitor’s journey
const response = await fetch(
'https://api.aws53.cloud/v1/data?email=jane@acme.com&timeframe=30d',
{
headers: { 'X-API-Key': 'sk_your_key' }
}
);
const journey = await response.json();
// Every page view, visit duration, and return visit for this personQuery parameters
| Parameter | Options | Description |
|---|---|---|
email | any email | Filter to a single visitor’s history |
page | 1, 2, 3… | Pagination (50 results per page) |
timeframe | 24h, 7d, 14d, 30d, 90d, all | Time window for results |
domain | any domain | Filter by client website |
The domain parameter is critical for multi-tenant setups. It lets you query visitors for a specific client without pulling data from all your pixels. We’ll cover this more in the Scaling to Multi-Tenant section.
Bonus: Check Account Health
Good infrastructure monitors itself. This endpoint tells you everything about your account status in a single call:
JavaScript
const response = await fetch('https://api.aws53.cloud/v1/data/account', {
headers: { 'X-API-Key': 'sk_your_key' }
});
const health = await response.json();
console.log(health);
// Response:
// {
// organization: { name: "Your Platform", status: "active" },
// credits: {
// used: 312,
// limit: 500,
// remaining: 188,
// percentUsed: 62.4,
// resetsAt: "2026-05-01T00:00:00Z"
// },
// pixels: { total: 5, active: 4, paused: 1 },
// healthy: true
// }Python
resp = requests.get(
'https://api.aws53.cloud/v1/data/account',
headers={'X-API-Key': 'sk_your_key'}
)
health = resp.json()
print(f"Credits remaining: {health['credits']['remaining']}")
print(f"Active pixels: {health['pixels']['active']}")Build automated monitoring with this. Set up alerts when credits hit 80%. Track pixel health across clients. Surface usage data in your product’s admin panel. If healthy returns false, something needs attention.
Here’s a practical example — a cron job that checks health daily and alerts you before you run out of credits:
// Daily health check (run via cron)
async function checkAccountHealth() {
const response = await fetch('https://api.aws53.cloud/v1/data/account', {
headers: { 'X-API-Key': process.env.LEADPIPE_API_KEY }
});
const health = await response.json();
if (health.credits.percentUsed > 80) {
await sendSlackAlert(
`Leadpipe credits at ${health.credits.percentUsed}% - ` +
`${health.credits.remaining} remaining. Resets ${health.credits.resetsAt}`
);
}
if (!health.healthy) {
await sendSlackAlert('Leadpipe account health check FAILED - investigate immediately');
}
}This kind of proactive monitoring is the difference between a production integration and a weekend project. When you’re responsible for delivering visitor data to your clients, you need to know the moment something goes wrong — not when a customer complains.
Scaling to Multi-Tenant
You’ve built the integration for one client. Scaling to hundreds follows the same pattern:
One API key. Many pixels. Per-client isolation.
Your Platform (1 API Key)
├── Pixel: client-a.com (Client A)
├── Pixel: client-b.com (Client B)
├── Pixel: client-c.com (Client C)
└── Pixel: client-d.com (Client D)The pattern
-
When a new client signs up — call
POST /v1/data/pixelsto create their pixel. Store the pixel ID and code in your database alongside the client record. -
When a client installs the pixel — serve them the
codevalue from their pixel record. Track installation status in your product. -
When a webhook fires — route it to the correct client based on the domain in the payload. Update that client’s visitor data in your database.
-
When a user queries their visitors — call
GET /v1/data?domain=client-domain.comto fetch only that client’s identified visitors.
// Multi-tenant visitor query
async function getVisitorsForClient(clientDomain, timeframe = '7d') {
const response = await fetch(
`https://api.aws53.cloud/v1/data?domain=${clientDomain}&timeframe=${timeframe}&page=1`,
{
headers: { 'X-API-Key': process.env.LEADPIPE_API_KEY }
}
);
return response.json();
}
// Usage
const acmeVisitors = await getVisitorsForClient('acme.com', '30d');
const widgetcoVisitors = await getVisitorsForClient('widgetco.io', '7d');This is the exact architecture behind white-label visitor identification setups for agencies and platforms. No separate accounts, no per-client API keys, no complex permissions layer. The pixel is the isolation boundary.
For a deep dive on multi-tenant patterns, data routing, and webhook management at scale, read Multi-Tenant Visitor Identification for SaaS Platforms.
What You Can Build Next
You’ve got the foundation. Here’s where it gets interesting.
Intent data
Leadpipe’s Orbit API tracks buyer intent across 20,000+ topics. This means you can identify not just who visits your client’s website, but who’s actively researching related topics across the internet — even if they’ve never visited. Filter by ICP criteria (industry, company size, seniority) and build targeted audiences.
This turns your platform from “see who visited” into “see who’s ready to buy.” Read more in our Intent API guide.
ICP filtering and audience building
Combine visitor identification with firmographic filters to surface only the visitors that match your clients’ ideal customer profiles. Skip the noise. Deliver qualified leads, not raw traffic data.
CRM and sales tool integrations
Leadpipe connects natively to HubSpot, Salesforce, Pipedrive, Slack, and 200+ tools via Zapier. If your product already integrates with these tools, you can layer visitor identity data on top of existing workflows. See Leadpipe + Clay + HubSpot for one popular configuration.
AI agent data feeds
If you’re building an AI SDR or sales agent, real-time webhook data is exactly what the agent needs to personalize outreach. The visitor just viewed /pricing? The agent knows. They came back for the third time this week? The agent adapts. This is the data layer AI agents are missing. For a technical breakdown of why every AI agent needs programmatic access to identity data, see Why Every AI Agent Needs an Identity API.
CSV export and batch processing
Pull visitor data via the API, transform it, and export to CSV for clients who prefer spreadsheets. Or batch-process identifications nightly into a data warehouse for reporting and analytics.
Suppression and exclusion lists
Leadpipe supports suppression lists (exclude specific contacts from identification) and exclusion lists (skip certain pages from tracking). If you’re building a product where clients need CCPA-compliant opt-out handling or want to exclude internal traffic, these features are built in — no custom logic required on your side.
The Cost Comparison
Let’s put numbers on this. Here’s what it actually costs to add identity resolution to your product:
| Provider | Annual Cost | What You Get |
|---|---|---|
| LiveRamp | $300K+ | Enterprise contract, 6+ month integration, company-level data |
| ZoomInfo | $100K+ | Enterprise contract, intent signals, mostly company-level for visitor ID |
| Oracle Data Cloud | $200K+ | Custom pricing, long sales cycle, requires “strategic partnership” |
| Leadpipe | $1,764/yr ($147/mo) | Full REST API, person-level identification, real-time webhooks, 500 IDs/mo |
| Leadpipe Agency | $15,348/yr ($1,279/mo) | 20,000 IDs/mo, white-label dashboard, multi-tenant API |
That’s not a typo. Leadpipe’s Starter plan costs less per year than one month of most enterprise identity resolution contracts.
Month-to-month billing. No annual commitments. No enterprise sales cycle. Cancel anytime.
And the data quality isn’t a compromise. In a third-party accuracy audit, Leadpipe scored 8.7 out of 10 on identification accuracy versus 5.2 for RB2B and 4.0 for Warmly. The difference: Leadpipe builds its own proprietary identity graph using deterministic matching, while most competitors resell the same third-party data sources.
The pricing difference matters because it changes the economics of your product. If identity resolution costs $300K/year, you need enterprise customers to justify it. If it costs $147-$1,279/month, you can offer visitor identification as a feature to SMBs, mid-market companies, or even as a freemium hook. The infrastructure cost no longer dictates your go-to-market.
For a complete breakdown of build vs. buy vs. embed economics, read Identity Resolution for Platforms: Build vs. Buy vs. Embed.
Recap: The Full API Surface
Here’s every endpoint you used in this tutorial, plus the ones you’ll need as you scale:
| Endpoint | Method | What It Does |
|---|---|---|
/v1/data/pixels | POST | Create a new pixel for a client |
/v1/data/pixels | GET | List all your pixels |
/v1/data | GET | Query identified visitors (with filters) |
/v1/data/account | GET | Check account health, credits, pixel status |
Four endpoints. That covers pixel management, visitor queries, and account monitoring. Webhooks handle real-time delivery without polling.
For the full endpoint reference with every parameter and response schema, see the Visitor Identification API: Complete Developer Guide. For a faster five-minute overview, try Leadpipe API in 5 Minutes.
You Just Added Identity Resolution to Your SaaS
Let’s count what we did:
- Got an API key — 1 minute
- Created a pixel — 2 minutes (one API call)
- Installed it — 2 minutes (paste a script tag)
- Built a webhook receiver — 3 minutes (one POST endpoint)
- Queried visitor data — 2 minutes (one GET request)
Total: 10 minutes. Five API interactions. Zero enterprise contracts.
Your product now knows who visits each client’s website. Not company-level guesses. Person-level identifications — names, emails, job titles, LinkedIn profiles, company data, and behavioral signals like pages viewed and visit duration.
You didn’t build an identity graph. You didn’t spend six months negotiating a data licensing deal. You didn’t hire a dedicated integration team or sign a contract with a $100K minimum. You called an API.
Compare that to the alternative. Building your own identity resolution from scratch means licensing data from multiple providers, building matching algorithms, maintaining compliance infrastructure, and keeping the whole thing running at scale. We’ve seen teams burn 12-18 months and mid-six-figures trying — and still end up with match rates under 10%.
Or you could embed an existing solution. Five API calls. Ten minutes. Person-level data at 30-40%+ match rates. Starting at $147/month.
That’s what identity resolution looks like when it’s built as infrastructure instead of locked behind enterprise sales teams.
Start building now — 500 free leads, no credit card required —>
Related Articles
- Visitor Identification API: Complete Developer Guide
- Identity Resolution for Platforms: Build vs. Buy vs. Embed
- Multi-Tenant Visitor Identification for SaaS Platforms
- Webhook Payload Reference: Every Visitor Data Field
- Leadpipe API in 5 Minutes: Identity Data Made Simple
- Visitor Identification API for OEM Platforms
- How to Feed Visitor Data Into Your AI Agent
