B2B identity resolution is not B2C identity resolution with a different label. The signals are different. The data you need back is different. The matching methods that matter are different. And if you pick an API designed for consumer ad-tech, you’ll spend months integrating something that was never built for your use case.
This guide is for developers evaluating B2B identity resolution APIs. We’ll cover how they work technically, what data they return, how to integrate them, and how to evaluate whether a given API is worth your time. No product tours. No “schedule a demo” dead ends. Just the technical details you need to make a decision.
B2B vs B2C Identity Resolution
Before evaluating any API, you need to understand why B2B identity resolution is its own category. The differences aren’t cosmetic - they affect every architectural decision.
| Dimension | B2B Identity Resolution | B2C Identity Resolution |
|---|---|---|
| Primary signal | Website visit, IP address, email hash | Cookies, device IDs, ad impressions |
| Data returned | Name, email, phone, job title, company, seniority | Demographics, interests, purchase history |
| Matching method | Deterministic (verified identifiers) | Probabilistic (statistical inference) |
| Identity graph | Professional profiles, business emails, LinkedIn | Consumer profiles, social accounts, device graphs |
| Primary use case | Sales outreach, lead scoring, ABM | Ad targeting, personalization, attribution |
| Pricing model | Per-identified-visitor or per-query | Per-impression or platform fee |
| Accuracy requirement | Very high (wrong person = wasted sales call) | Moderate (wrong segment = wasted ad impression) |
| Typical buyer | Sales/marketing ops, growth engineering | Ad ops, media buying, product analytics |
The fundamental difference: in B2C, you’re matching devices to audience segments for ad delivery. Getting it 80% right is fine because the cost of a mismatched ad impression is fractions of a cent. In B2B, you’re matching anonymous website visitors to real business decision-makers for sales outreach. Getting it wrong means your SDR sends a personalized email to someone who never visited your site. That’s not a wasted impression - it’s a damaged relationship.
This is why deterministic matching matters more in B2B. You need to be right, not just close.
How B2B Identity Resolution APIs Work
Every B2B identity resolution API follows the same four-step process under the hood. The implementation details vary, but the architecture is consistent.
Step 1: Data Collection
A lightweight JavaScript pixel or tag deployed on your website captures signals from every visitor session. These typically include:
- IP address (used for initial company-level matching and geolocation)
- User agent string (browser type, OS, device characteristics)
- HTTP referrer (where the visitor came from)
- Page URLs visited (browsing pattern within your site)
- Visit timestamps (session timing and frequency)
- Screen resolution and viewport (device fingerprinting signals)
- Cookie/local storage identifiers (session continuity)
The pixel is designed to be non-blocking and lightweight - typically under 5KB. It fires asynchronously and shouldn’t impact page load performance. The best implementations handle this transparently. With Leadpipe, you create a pixel through the API and embed a single script tag. The pixel management endpoints handle the rest.
// Leadpipe pixel - one line in your HTML
<script src="https://tag.leadpipe.com/your-pixel-id.js" async></script>Step 2: Matching
When signals arrive from the pixel, the API matches them against an identity graph - a massive database that maps relationships between identifiers and person records.
For deterministic matching, the system looks for exact overlaps between the incoming signals and verified identifiers in the graph. An IP address might link to a known email hash. A cookie might link to a previous authenticated session. A device fingerprint might match a known device-person relationship.
The quality of this step depends entirely on the identity graph. Leadpipe’s graph contains 4.44 billion person profiles built from its own data sources - not resold from a third party. This matters because providers who all license the same identity graph will all return the same data (and have the same blind spots). A proprietary graph provides differentiated coverage.
Step 3: Resolution
When the matching system finds a confident match, it resolves the anonymous signal to a known person record. This is where B2B identity resolution diverges sharply from B2C. Instead of returning an audience segment or a device graph, the API returns an actual person:
- Full name
- Work email and personal email
- Phone number (direct and mobile)
- LinkedIn profile URL
- Job title, department, seniority level
- Company name, domain, industry, employee count, revenue range
This is person-level identification, not company-level. Company-level tools (like older reverse IP lookup services) can tell you “someone from Acme Corp visited your pricing page.” Person-level tools tell you “Jane Rodriguez, VP of Marketing at Acme Corp, visited your pricing page at 2:47 PM, spent 4 minutes reading it, and previously visited your comparison page three times this week.”
Step 4: Enrichment
After resolving the person, the best APIs add contextual data that makes the identification actionable:
- Firmographic data: Company details beyond just the name - industry classification, employee count ranges, revenue estimates, technology stack
- Intent signals: What topics this person has been researching across the web. Leadpipe’s Orbit product tracks 20,735 intent topics at the person level - not company-level “surge” signals, but individual research behavior
- Behavioral data: Pages viewed, visit frequency, time on site, referral source - everything the pixel captured during the session
This enrichment layer is what separates identity resolution from basic reverse IP lookup. A reverse IP lookup gives you a company name. Identity resolution gives you a person, their contact details, their company context, and their buying intent.
What a Good B2B Identity Resolution API Returns
When you query Leadpipe’s Data API for a resolved visitor, you get back 100+ data points - the most comprehensive identity response available from any self-serve API. Here’s what that looks like organized by category:
Person Fields
| Field | Example | Notes |
|---|---|---|
| First name | Jane | Verified against identity graph |
| Last name | Rodriguez | |
| Personal email | jane.r@gmail.com | When available |
| Work email | jane@acmecorp.com | Primary outreach channel |
| Phone (direct) | +1-555-0142 | Direct line, not switchboard |
| Phone (mobile) | +1-555-0198 | |
| Photo | URL to profile image | When available |
| Age | 38 | Estimated |
| Gender | Female | |
| Income range | $150K-$200K | Estimated |
| Net worth range | $500K-$1M | Estimated |
| Marital status | Married | When available |
| Children | Yes | When available |
| Homeowner | Yes | When available |
| LinkedIn URL | linkedin.com/in/janerodriguez | Profile link |
| Facebook URL | facebook.com/janerodriguez | When available |
| Other social profiles | Additional social links | When available |
| Job title | VP of Marketing | Current title from graph |
| Headline | ”Marketing leader scaling B2B SaaS” | Professional headline |
| Department | Marketing | Normalized |
| Seniority | VP | Normalized: C-Suite, VP, Director, Manager, IC |
| Full work history | Previous roles and companies | When available |
Company Fields
| Field | Example | Notes |
|---|---|---|
| Company name | Acme Corp | |
| Domain | acmecorp.com | |
| Industry | SaaS / Software | |
| Employee count | 200-500 | Range |
| Revenue range | $10M-$50M | Estimated |
| Company LinkedIn | linkedin.com/company/acmecorp | |
| NAICS code | 511210 | Industry classification |
| SIC code | 7372 | Industry classification |
| City, State, Country | San Francisco, CA, US | HQ location |
Digital Identifier Fields
| Field | Example | Notes |
|---|---|---|
| HEM (SHA256) | a1b2c3d4… | Hashed email for ad platform matching |
| HEM (SHA1) | e5f6a7b8… | Hashed email variant |
| HEM (MD5) | c9d0e1f2… | Hashed email variant |
| Cookies | Session identifiers | For cross-session linking |
| Device IDs | Mobile and desktop identifiers | When available |
Behavioral Fields
| Field | Example | Notes |
|---|---|---|
| Pages viewed | [“/pricing”, “/vs-competitor”, “/demo”] | Full URL list |
| Session count | 3 | Total visits in window |
| First seen | 2026-03-01T14:22:00Z | ISO 8601 |
| Last seen | 2026-03-10T09:15:00Z | |
| Referral source | google / organic | UTM-aware |
| Time on site | 247 seconds | Per session |
Intent Fields (Orbit)
| Field | Example | Notes |
|---|---|---|
| Intent topics | [“CRM software”, “HubSpot alternatives”] | From 20,735 available topics |
| Intent strength | High / Medium / Low | Per topic |
| Research timeline | Last 30 days | Observation window |
Not every field is populated for every visitor. Match rates and field coverage vary by data availability. But 100+ data points is the depth Leadpipe delivers - the most comprehensive profile available from any self-serve identity resolution API. If a provider returns fewer than 20 fields, they’re either reselling a thin data source or doing company-level-only resolution.
API Architecture Patterns
B2B identity resolution APIs expose data through three main architectural patterns. Each has tradeoffs that affect how you integrate them.
Pattern 1: Webhook (Push)
The API pushes resolved visitor data to your endpoint in real-time. When a visitor is identified, your webhook URL receives a POST request with the full visitor record.
Pros: Real-time delivery. No polling overhead. Easy to integrate with event-driven architectures, message queues, and AI agent workflows.
Cons: You need a publicly accessible endpoint. Retry logic matters (what happens if your endpoint is down?). Ordering isn’t guaranteed.
Best for: Real-time sales alerts, AI agent triggers, CRM auto-population.
Leadpipe supports webhook delivery with configurable endpoints per pixel. You set up the webhook URL through the Data API and receive structured JSON payloads as visitors are identified.
Pattern 2: Polling (Pull)
You periodically query the API for new identified visitors. The API stores results, and you fetch them on your schedule.
Pros: Simple integration. No public endpoint needed. You control the timing and batch size.
Cons: Not real-time (latency depends on polling frequency). Wastes API calls when there’s no new data. Can hit rate limits if you poll too aggressively.
Best for: Batch processing, daily reports, systems without webhook support.
Leadpipe’s GET /v1/data endpoint supports this pattern with query parameters for date ranges, pagination, and filtering.
Pattern 3: Batch
You submit a batch of signals (IP addresses, email hashes) and get back resolved results in bulk. Typically asynchronous - you submit the batch, get a job ID, and poll for completion.
Pros: Efficient for large volumes. Lower per-record cost. Good for backfill and historical analysis.
Cons: Not real-time. More complex integration. Job management overhead.
Best for: Migrating historical data, large-scale enrichment runs, data warehouse integration.
Which Pattern to Use
For most B2B teams building on identity resolution, start with webhooks. They give you real-time data delivery with minimal integration complexity. Add polling as a fallback for reliability. Use batch only when you need to process historical data or run large enrichment jobs. Leadpipe also supports flat file/CSV exports for teams that need to import data into spreadsheets, data warehouses, or tools that don’t support API integration.
If you’re building an AI agent that reacts to visitor identifications, webhooks are the only viable pattern - your agent needs to respond in real-time, not check a queue every 5 minutes.
Authentication Patterns
Three authentication patterns dominate identity resolution APIs. Understanding them matters for security architecture and SDK design.
API Key (Header-Based)
The simplest pattern. You include an API key in a request header on every call.
curl -H "X-API-Key: sk_your_key_here" \
https://api.aws53.cloud/v1/dataLeadpipe uses this pattern with X-API-Key headers and sk_ prefixed keys. It’s straightforward, stateless, and works well for server-to-server communication. The key risk is key exposure in client-side code - always call identity APIs from your backend, never from browser JavaScript.
Rate limits: Leadpipe allows 200 requests/minute authenticated, 2 requests/minute unauthenticated. Plan your polling frequency accordingly.
OAuth 2.0
Enterprise APIs (LiveRamp, Experian) typically use OAuth 2.0 with client credentials flow. You exchange a client ID + secret for an access token, then use the token for API calls.
More complex but supports scoped permissions, token rotation, and delegation. Overkill for most B2B identity use cases unless you need fine-grained access control.
JWT (Token-Based)
Some CDPs (mParticle) use JWT tokens for API authentication. You generate a signed JWT from your credentials and include it in the Authorization header.
Similar tradeoffs to OAuth - more complexity, more flexibility. Useful when you need to embed identity in token claims for downstream services.
Recommendation: For B2B identity resolution, API key auth is the right choice for most teams. It’s simple, well-understood, and the security model is straightforward: keep the key on your server, rotate it periodically, scope it to the minimum necessary permissions.
Code Examples: Leadpipe SDK
Here’s what integration actually looks like with Leadpipe’s TypeScript SDK. These examples cover the three most common workflows.
Install and Initialize
npm install @leadpipe/clientimport { LeadpipeClient } from '@leadpipe/client';
const client = new LeadpipeClient({
apiKey: process.env.LEADPIPE_API_KEY, // sk_...
});Create a Pixel
Before you can identify visitors, you need a tracking pixel on your site.
const pixel = await client.pixels.create({
name: 'Main Website',
domain: 'yoursite.com',
webhookUrl: 'https://yourapp.com/api/leadpipe-webhook',
});
// pixel.id -> use this in your script tag
// <script src="https://tag.leadpipe.com/{pixel.id}.js" async></script>Query Identified Visitors
Pull identified visitors with filtering. This is the polling pattern.
const visitors = await client.data.query({
startDate: '2026-03-01',
endDate: '2026-03-10',
limit: 50,
});
for (const visitor of visitors.data) {
console.log(`${visitor.firstName} ${visitor.lastName}`);
console.log(` Email: ${visitor.workEmail}`);
console.log(` Company: ${visitor.companyName} (${visitor.employeeCount})`);
console.log(` Title: ${visitor.jobTitle}`);
console.log(` Pages: ${visitor.pagesViewed.join(', ')}`);
}Build an Intent Audience
Use the Orbit API to find people researching specific topics, not just people visiting your site.
// Discover available intent topics
const topics = await client.orbit.topics.search({
query: 'CRM software',
});
// Build an audience around a topic
const audience = await client.orbit.audiences.create({
name: 'CRM Researchers',
topics: [topics.data[0].id],
filters: {
seniority: ['VP', 'Director', 'C-Suite'],
employeeCount: '200-1000',
},
});
// Export the audience for outreach
const exportJob = await client.orbit.audiences.export({
audienceId: audience.id,
format: 'csv',
});These three workflows - pixel setup, visitor querying, and intent audience building - cover 90% of what developers do with B2B identity resolution APIs. The key thing to notice is how few API calls each requires. If an identity resolution API needs more than 5-6 calls to get you from zero to identified visitors, the API design has problems.
For a more complete walkthrough, see Leadpipe API in 5 Minutes.
Try Leadpipe free with 500 leads ->
Matching Methods: Deterministic vs Probabilistic for B2B
This matters more than most developers realize. The matching method determines both the accuracy and coverage of your identity resolution.
Deterministic Matching
Requires an exact, verified match between two identifiers. Examples: the same email hash appears in the incoming signal and in the identity graph. The same phone number links a website cookie to a known person record. The same device ID maps to a previous authenticated session.
Accuracy: Very high (95%+ when the match exists). If a deterministic system says “this visitor is Jane Rodriguez,” it’s almost certainly right because the match is based on a verified identifier overlap.
Coverage: Lower than probabilistic. If the visitor’s signals don’t have any exact overlaps with the identity graph, the system returns nothing rather than guessing.
Leadpipe uses deterministic matching exclusively. The 30-40% match rate reflects this - the system only returns identifications when it has high confidence. The 60-70% of visitors who aren’t matched simply don’t appear in your results, which is better than appearing with wrong data.
Probabilistic Matching
Uses statistical models to infer likely matches based on patterns. Example: this device fingerprint is 87% likely to be the same person who used a similar device from the same IP range last week.
Accuracy: Moderate (60-85% depending on the model and thresholds). The system is making educated guesses based on behavioral patterns and statistical correlations.
Coverage: Higher than deterministic. The system can produce a match for more visitors because it doesn’t require exact identifier overlap.
Why Deterministic Wins for B2B
In B2B, the cost of a false positive is high. If your identity resolution API incorrectly identifies a visitor, you get a cascade of bad outcomes:
- Your SDR sends a personalized email to the wrong person
- That person has no idea what you’re talking about
- Your domain reputation takes a hit
- Your sales team loses trust in the data
This is fundamentally different from ad-tech, where a probabilistic match that’s 80% right still delivers positive ROI on ad spend. In B2B outreach, 80% accuracy means 1 in 5 emails goes to a stranger.
For a deeper technical comparison, read Deterministic vs Probabilistic Matching Explained.
Evaluation Checklist: 10 Criteria for B2B Identity APIs
Use this checklist when evaluating any B2B identity resolution API. Score each criterion 0-2 (0 = doesn’t meet, 1 = partially meets, 2 = fully meets).
1. Matching Methodology Transparency
Does the provider clearly state whether they use deterministic, probabilistic, or hybrid matching? Do they publish accuracy benchmarks? If they won’t tell you how matching works, that’s a red flag.
2. Identity Graph Ownership
Does the provider own their identity graph, or license it from a third party? Providers who all license the same graph return the same data. Proprietary graphs (Leadpipe, FullContact, LiveRamp) provide differentiated results.
3. Person-Level Resolution
Does the API return individual person records (name, email, phone), or only company-level data (company name, domain)? Company-level is table stakes in 2026. Person-level is what you actually need.
4. Data Freshness
How often is the identity graph updated? Daily, weekly, monthly? Stale data means wrong job titles, outdated emails, and missed contacts. Ask about the data refresh cycle.
5. Self-Serve Access
Can you sign up, get an API key, and start querying today? Or do you need to “talk to sales,” sign an NDA, and wait 6 weeks for access? For most B2B teams, self-serve isn’t a nice-to-have - it’s a requirement. Leadpipe is the only truly self-serve identity resolution API - sign up, get an API key, and query data in minutes. No sales call. No partnership agreement. FullContact advertises pricing from $99/mo, but access requires contacting their sales team.
6. API Design Quality
How many endpoints? Is the API RESTful? Is the documentation complete? Are there SDKs in your language? A well-designed API with clear documentation saves weeks of integration time. Leadpipe’s 23 endpoints with a TypeScript SDK represent the standard you should expect.
7. Real-Time Delivery
Does the API support webhooks or streaming for real-time visitor identification? Batch-only APIs introduce latency that kills time-sensitive use cases like sales alerts and AI agent workflows.
8. Intent Data
Does the API include buying intent signals, or only static identity data? In 2026, knowing who someone is without knowing what they’re actively researching is only half the picture. Leadpipe’s Orbit product tracks 20,735 topics at the person level.
9. Pricing Transparency
Is pricing published on the website? Can you estimate your monthly cost before talking to anyone? Or is it “custom pricing” (translation: it’s expensive and they want to price based on your perceived ability to pay)? Leadpipe publishes its full pricing range: $147/mo Starter (500 IDs, $0.29/ID), $299/mo Growth, $1,279/mo Agency (20,000 IDs, $0.064/ID), and ~$8,000/mo high-volume (1M+ IDs, ~$0.008/ID). Compare that to enterprise providers where you can’t even get a ballpark without a 4-week sales process.
10. Platform Embeddability
Can you embed the identity resolution into your own product? Does the API support multi-tenant architectures? If you’re building a platform, this matters enormously. Leadpipe’s pixel system supports per-tenant isolation with a single API key.
FAQ
What’s a realistic match rate for B2B identity resolution?
For deterministic visitor identification (resolving anonymous website visitors to real people), expect 30-40% with a strong identity graph. That means on a site with 10,000 monthly visitors, you’ll identify 3,000-4,000 people. That sounds lower than the 85%+ rates that enrichment tools claim, but the comparison is misleading - enrichment starts with a known identifier, identification starts with nothing. Independent tests show Leadpipe identifies 240-300% more visitors than competing visitor identification tools.
How is B2B identity resolution different from reverse IP lookup?
Reverse IP lookup maps an IP address to a company name. That’s company-level identification - you know “someone from Acme Corp” visited, but not who. B2B identity resolution goes further: it resolves the anonymous visitor to an individual person with contact details. The technical difference is that reverse IP uses a single signal (IP address) while identity resolution uses multiple signals matched against an identity graph.
Do I need to worry about compliance?
Yes. In the US, CCPA governs the use of personal information for California residents. Leadpipe is CCPA compliant. In the EU, GDPR is stricter - Leadpipe provides company-level data only for EU visitors, not person-level. Most B2B identity resolution APIs handle compliance at the platform level, but you should understand the regulatory landscape for your specific geography and use case. See the compliance overview for details.
Can I use a B2B identity resolution API for account-based marketing (ABM)?
Absolutely. In fact, this is one of the strongest use cases. You deploy the pixel on your website, identify visitors from target accounts, see which pages they’re viewing, and route that data to your ABM platform or sales team. The person-level data (not just company-level) lets you know exactly which decision-makers at target accounts are engaging with your content.
How long does integration typically take?
For Leadpipe, the only truly self-serve identity resolution API: minutes to hours. You sign up, get an API key, create a pixel, and embed a script tag. Visitors start being identified immediately. For enterprise APIs (LiveRamp, Experian): weeks to months. You negotiate a contract, complete data use agreements, get implementation support, and go through compliance reviews. The integration complexity should match your actual technical requirements - don’t buy an enterprise solution if you need a 10-minute integration.
The Bottom Line
B2B identity resolution is a distinct technical category with its own requirements. The signals are different from B2C (website visits, not cookie syncs). The data you need back is different (person records, not audience segments). The accuracy bar is higher (wrong person = wasted sales call, not wasted ad impression).
When evaluating APIs, focus on three things: matching methodology (deterministic for B2B), data depth (100+ data points per person, not 10), and integration simplicity (self-serve with SDK, not 6-week enterprise onboarding).
Most B2B teams don’t need a $200K CDP with 45 matching algorithms. They need an API that takes an anonymous website visit and gives them a real person to talk to. That’s what B2B identity resolution does.
See it for yourself. Leadpipe gives you 500 free identified visitors - full person records with 100+ data points and intent data, delivered through REST API, webhooks, flat file exports, TypeScript SDK, and MCP server. Set up takes 5 minutes. No sales call. No annual contract.
Start your free trial - 500 identified leads →
Related Articles
- Visitor Identification API: Complete Developer Guide
- What Is Identity Resolution and Why Does It Matter?
- Deterministic vs Probabilistic Matching Explained
- How Identity Graphs Work
- Webhook Payload Reference: Every Visitor Data Field
- Add Identity Resolution to Your SaaS in 10 Minutes
- Person-Level Intent Data: How It Works
