---
title: "Leadpipe API in 5 Minutes: Identity Data Made Simple"
description: "5 data endpoints, 18 intent endpoints, one API key. The fastest way to add visitor identification and intent data to any product. Code examples included."
canonical_url: "https://www.leadpipe.com/blog/leadpipe-api-in-5-minutes-identity-data-made-simple/"
source_url: "https://www.leadpipe.com/blog/leadpipe-api-in-5-minutes-identity-data-made-simple/"
md_url: "https://www.leadpipe.com/blog/leadpipe-api-in-5-minutes-identity-data-made-simple.md"
content_type: "article"
pubDate: "2026-03-27T00:00:00.000Z"
last_updated: "2026-08-31T00:00:00.000Z"
---

# Leadpipe API in 5 Minutes: Identity Data Made Simple

In this guide

5 data endpoints, 18 intent endpoints, one API key. The fastest way to add visitor identification and intent data to any product. Code examples included.

Most identity resolution APIs require a six-month enterprise contract, a dedicated integration team, and $300K+ annually just for API access. LiveRamp wants a “strategic partnership.” ZoomInfo gates their API behind six-figure deals. 6sense makes you sit through weeks of demos before you see a single endpoint.

Leadpipe requires one HTTP header.

Here’s everything the API can do – and how to be live in 5 minutes.

---

## The API at a Glance

**23 endpoints. One API key. That’s it.**

No SDK to install. No OAuth flow to implement. No token refresh logic. No client secret rotation. A single `X-API-Key` header on every request, and you have access to the entire surface.

Here’s what you’re working with:

| API Group | Endpoints | What It Does |
| --- | --- | --- |
| **Data API** | 5 | Create/manage pixels, query identified visitors, check account health |
| **Intent API** | 18 | Search 20,000+ intent topics, build audiences, export person-level buyer intent |
| **Webhooks** | 2 triggers | Real-time push of identified visitor data to your endpoint |

**Base URL:** `https://api.aws53.cloud`

**Rate limit:** 200 requests/minute (authenticated)

**Response format:** JSON

That’s the entire API. If you’ve integrated Stripe or Twilio before, the pattern will feel instantly familiar. Let’s walk through each piece.

---

## Authentication

One header. That’s it.

```
curl -H "X-API-Key: sk_your_key" \
  https://api.aws53.cloud/v1/data/account
```

Your key looks like `sk_live_abc123...`. You get it from **Dashboard > Settings > API Keys > Create**. Takes about 30 seconds.

No OAuth flows. No token refresh. No client secrets. No HMAC signing. Every request is stateless – send the header, get the data.

> **Security note:** Treat your API key like a database password. Store it in environment variables, never in client-side code. If you’re building a [multi-tenant platform](/blog/multi-tenant-visitor-identification-for-saas-platforms/), your key stays on your backend – your clients never see it.

Want the full authentication context? The [complete developer guide](/blog/visitor-identification-api-complete-developer-guide/) covers key rotation, security patterns, and multi-environment setups.

---

## The Data API (5 Endpoints)

The Data API handles everything related to [visitor identification](/blog/top-10-visitor-identification-softwares/): creating pixels, managing them, querying identified visitors, and monitoring account health. Five endpoints, zero complexity.

### 1. Create a Pixel

**`POST /v1/data/pixels`** – Creates a new tracking pixel for a domain.

#### curl

```
curl -X POST https://api.aws53.cloud/v1/data/pixels \
  -H "X-API-Key: sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"domain": "yoursite.com", "name": "Main Website"}'
```

#### Python

```
import requests

resp = requests.post(
    "https://api.aws53.cloud/v1/data/pixels",
    headers={"X-API-Key": "sk_your_key"},
    json={"domain": "yoursite.com", "name": "Main Website"}
)

pixel = resp.json()
# Returns: id, domain, name, status, code (JS snippet), createdAt
```

#### JavaScript

```
const res = 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: "yoursite.com", name: "Main Website" })
});

const pixel = await res.json();
// pixel.code contains the <script> tag to install
```

The response includes a `code` field – that’s the JavaScript snippet. Paste it in the `<head>` of your site and visitors start getting identified immediately. One API call, one pixel, done.

If you’re building a platform where each of your clients needs their own pixel, this is the endpoint you’ll call in your onboarding flow. Create a pixel per client, store the ID, and you get per-client data isolation out of the box. The [SaaS integration tutorial](/blog/add-identity-resolution-to-your-saas-in-10-minutes/) walks through this exact pattern.

### 2. List Pixels

**`GET /v1/data/pixels`** – Returns all your pixels with their status.

```
curl -H "X-API-Key: sk_your_key" \
  https://api.aws53.cloud/v1/data/pixels
```

Each pixel comes back with its domain, name, status (active/paused), and creation date. If you’re managing pixels for multiple clients – like an [agency or SaaS platform](/blog/visitor-identification-api-oem-platforms/) – this is how you audit what’s running across your entire portfolio.

```
resp = requests.get(
    "https://api.aws53.cloud/v1/data/pixels",
    headers={"X-API-Key": "sk_your_key"}
)

for pixel in resp.json()["data"]:
    print(f"{pixel['name']} ({pixel['domain']}) - {pixel['status']}")
```

### 3. Update a Pixel

**`PATCH /v1/data/pixels/{id}`** – Pause, activate, or configure a pixel.

```
curl -X PATCH https://api.aws53.cloud/v1/data/pixels/pixel_abc123 \
  -H "X-API-Key: sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"status": "paused", "excludedPaths": ["/admin/*", "/internal/*"]}'
```

The `excludedPaths` field is worth highlighting. You can specify URL patterns that the pixel should ignore – admin panels, internal tools, logged-in user areas. This keeps your identification credits focused on actual prospects, not your own team browsing the site.

### 4. Query Visitors

**`GET /v1/data`** – The main event. Pull identified visitor data.

#### curl

```
curl -H "X-API-Key: sk_your_key" \
  "https://api.aws53.cloud/v1/data?timeframe=7d&domain=yoursite.com"
```

#### Python

```
resp = requests.get(
    "https://api.aws53.cloud/v1/data",
    headers={"X-API-Key": "sk_your_key"},
    params={"timeframe": "7d", "domain": "yoursite.com"}
)

visitors = resp.json()
for visitor in visitors["data"]:
    print(f"{visitor['name']} - {visitor['email']} - {visitor['company']}")
```

#### JavaScript

```
const res = await fetch(
  "https://api.aws53.cloud/v1/data?timeframe=7d&domain=yoursite.com",
  { headers: { "X-API-Key": "sk_your_key" } }
);

const { data: visitors } = await res.json();
visitors.forEach(v => console.log(v.name, v.email, v.company));
```

Returns up to 50 results per page. Each record includes the full person profile: name, business email, personal email, phone, LinkedIn URL, job title, company, pages viewed, visit duration, referrer, and timestamps.

This is [person-level identification](/blog/person-level-intent-data-how-it-works/), not the company-only IP reverse lookup that most tools provide. You’re getting the actual human who visited, matched through [deterministic matching](/blog/deterministic-vs-probabilistic-matching-explained/) against Leadpipe’s own identity graph.

### 5. Account Health

**`GET /v1/data/account`** – Check credits, pixel count, intent slots, and health status.

```
curl -H "X-API-Key: sk_your_key" \
  https://api.aws53.cloud/v1/data/account
```

Returns a `healthy` boolean, remaining credits, active pixel count, and intent data slots. Build this into your monitoring. If `healthy` returns `false`, something needs attention – expired credits, inactive pixels, or configuration issues.

---

## The Intent API (18 Endpoints)

The [Intent API](/blog/leadpipe-intent-api-20000-topics/) gives you person-level buyer intent across **20,000+ topics**. Not company-level signals. Not “Acme Corp is researching CRM.” Actual people, with names, emails, and intent scores – filtered by your exact ICP.

The 18 endpoints break into four groups:

### Discover Topics

| Endpoint | Method | What It Does |
| --- | --- | --- |
| `/v1/site-topics` | POST | Match a website URL to relevant topics |
| `/v1/intent/topics/inventory` | GET | Browse the full 20K+ topic taxonomy |
| `/v1/intent/topics/inventory/facets` | GET | Get distinct values with counts (industries, categories) |
| `/v1/intent/topics/search` | GET | Autocomplete search for topics |

### Analyze Trends

| Endpoint | Method | What It Does |
| --- | --- | --- |
| `/v1/intent/topics/{id}/trend` | GET | Daily audience size trend for a topic |
| `/v1/intent/topics/compare` | POST | Compare up to 10 topics side by side |
| `/v1/intent/topics/movers` | GET | Top growing and declining topics |

### Build Audiences

| Endpoint | Method | What It Does |
| --- | --- | --- |
| `/v1/intent/audience/filters` | GET | Available ICP filters (seniority, industry, size, etc.) |
| `/v1/intent/topics/audience/preview` | POST | Preview count + sample records before committing |
| `/v1/intent/topics/audience` | POST | Full audience query with all ICP filters |
| `/v1/intent/audiences` | POST | Save an audience for daily refresh |
| `/v1/intent/audiences` | GET | List saved audiences |
| `/v1/intent/audiences/{id}` | GET | Get a specific audience |
| `/v1/intent/audiences/{id}` | PATCH | Update audience config |
| `/v1/intent/audiences/{id}` | DELETE | Delete an audience |

### Export Data

| Endpoint | Method | What It Does |
| --- | --- | --- |
| `/v1/intent/audiences/{id}/export` | POST | Generate a CSV with signed download URL (24h expiry) |
| `/v1/intent/audiences/{id}/runs` | GET | Daily run history with row counts |
| `/v1/intent/audiences/{id}/stats` | GET | Fill rate statistics across data fields |

### The 4-Call Workflow

Here’s the entire intent data workflow in four API calls. From topic search to CSV export in under a minute.

**Step 1: Find topics**

```
curl -H "X-API-Key: sk_your_key" \
  "https://api.aws53.cloud/v1/intent/topics/search?q=CRM&type=b2b"
```

Returns a list of matching topics with IDs, names, and categories. Pick the ones that align with your product.

**Step 2: Preview the audience**

```
curl -X POST https://api.aws53.cloud/v1/intent/topics/audience/preview \
  -H "X-API-Key: sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "topicIds": [1234],
    "filters": {
      "seniority": ["VP", "Director"],
      "employeeRange": ["50-200", "201-500"]
    }
  }'
```

Returns the total count of matching people plus a sample of records. Check if the audience size and quality match what you need before saving.

**Step 3: Save the audience**

```
curl -X POST https://api.aws53.cloud/v1/intent/audiences \
  -H "X-API-Key: sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "CRM Buyers - VP+",
    "config": {
      "topicIds": [1234],
      "filters": {
        "seniority": ["VP", "Director"],
        "employeeRange": ["50-200", "201-500"]
      }
    }
  }'
```

Once saved, Leadpipe materializes fresh results **daily**. New people researching your topics get added automatically. You’re not working with a static list – it’s a living audience.

**Step 4: Export to CSV**

```
curl -X POST https://api.aws53.cloud/v1/intent/audiences/{audience_id}/export \
  -H "X-API-Key: sk_your_key"
```

Returns a signed download URL valid for 24 hours. The CSV includes every field: name, email, phone, LinkedIn, company, job title, intent score, and the specific topics each person is researching.

You can also check how your exports are performing over time:

```
# Check daily run history
curl -H "X-API-Key: sk_your_key" \
  "https://api.aws53.cloud/v1/intent/audiences/{audience_id}/runs"

# Check fill rates across data fields
curl -H "X-API-Key: sk_your_key" \
  "https://api.aws53.cloud/v1/intent/audiences/{audience_id}/stats"
```

The `/runs` endpoint returns each day’s date, row count, and status – useful for monitoring whether your audience is growing or shrinking. The `/stats` endpoint shows fill rates across data fields (email, phone, LinkedIn, etc.) so you know what coverage to expect.

> **That’s four API calls to go from “I want people researching CRM” to a downloadable CSV of VPs and Directors who are actively in-market.** No sales calls. No six-figure contract. No onboarding team. For the full 18-endpoint deep dive with ICP filter documentation, see the [Intent API guide](/blog/leadpipe-intent-api-20000-topics/).

---

## Webhooks

The API handles pull. Webhooks handle push. If you want real-time visitor data streamed to your backend the moment someone is identified, webhooks are how you do it.

Leadpipe supports **two webhook triggers:**

| Trigger | When It Fires | Best For |
| --- | --- | --- |
| **First Match** | Once per visitor, on first identification | CRM updates, outreach triggers, lead routing |
| **Every Update** | On every page view for identified visitors | Behavioral tracking, scoring, [AI agent feeds](/blog/how-to-feed-visitor-data-into-ai-agent/) |

### What the Payload Includes

Every webhook POST delivers structured JSON with:

- **Person data:** Full name, business email, personal email, phone, LinkedIn URL, job title
- **Company data:** Company name, domain, industry, employee count
- **Behavioral data:** Page URL, visit duration, referrer, session timestamp
- **Metadata:** Pixel ID, visitor ID, match confidence

Here’s what a webhook payload looks like in practice:

```
{
  "event": "visitor.identified",
  "visitor": {
    "name": "Sarah Chen",
    "email": "sarah.chen@acmecorp.com",
    "personalEmail": "sarahc@gmail.com",
    "phone": "+14155550142",
    "linkedin": "linkedin.com/in/sarahchen",
    "jobTitle": "VP of Marketing",
    "company": {
      "name": "Acme Corp",
      "domain": "acmecorp.com",
      "industry": "SaaS",
      "employees": "201-500"
    }
  },
  "session": {
    "pageUrl": "https://yoursite.com/pricing",
    "duration": 247,
    "referrer": "https://google.com",
    "timestamp": "2026-04-01T14:23:11Z"
  }
}
```

Set up your webhook endpoint in the dashboard under **Settings > Webhooks**, or configure it programmatically when creating a pixel. The [webhook payload reference](/blog/webhook-payload-reference-every-visitor-data-field/) documents every field in detail.

### Which Trigger Should You Use?

**Use First Match** if you care about knowing *who* visited. This is the right trigger for CRM syncing, Slack notifications, lead routing, and outreach automation. One visitor, one webhook, one action. Most teams start here.

**Use Every Update** if you care about *behavior*. This fires on every page view for identified visitors, so you can build page-view timelines, scoring models, and real-time dashboards. If you’re powering an [AI SDR](/blog/how-to-choose-data-provider-for-ai-sdr/) that adjusts its messaging based on which pages a prospect just viewed, this is the trigger you want.

You can enable both simultaneously. First Match handles the initial outreach trigger. Every Update feeds your behavioral analytics. They work on the same data, just at different frequencies.

**The key insight:** Your backend doesn’t need to poll. Data gets pushed the moment someone is identified. Event-driven, not batch-processed. This is what makes it possible to [feed visitor data into AI agents](/blog/how-to-feed-visitor-data-into-ai-agent/) that act in real time – the [data layer AI sales agents are missing](/blog/the-data-layer-ai-sales-agents-are-missing/).

---

## Leadpipe API vs. Enterprise Alternatives

Here’s where the industry stands. Most providers treat API access as a premium feature reserved for enterprise contracts. Leadpipe treats it as the default.

|  | **Leadpipe** | **LiveRamp** | **ZoomInfo** | **6sense** |
| --- | --- | --- | --- | --- |
| **Self-serve signup** | Yes | No | No | No |
| **API access** | All plans | Enterprise only | Enterprise only | Enterprise only |
| **Time to first API call** | Minutes | Months | Weeks | Months |
| **Authentication** | 1 header | OAuth + contracts | OAuth + contracts | OAuth + contracts |
| **Pricing** | $147/mo+ | $300K+/yr | $100K+/yr | $25K+/yr |
| **Documentation** | Public | Gated | Gated | Gated |
| **Person-level data** | Yes | Yes | Limited | No |
| **Intent data** | 20K+ topics | No | Limited | Yes (company only) |
| **Webhooks** | Real-time | No | Limited | Limited |

The difference isn’t just price. It’s access model.

You can sign up for Leadpipe, generate an API key, and make your first call in the time it takes to schedule a demo with the alternatives. There’s no procurement process. No NDAs to sign. No “let me loop in my enterprise team” emails. No minimum annual commitment.

Month-to-month billing, starting at **$147/month with a free trial of 500 identified leads** – no credit card required. Cancel anytime. Scale up or down as your needs change.

And there’s a philosophical difference worth noting: Leadpipe builds its [own identity graph](/blog/what-is-identity-resolution/). Most competitors resell the same third-party graphs to each other, which is why match rates tend to converge around the same mediocre numbers. Leadpipe’s proprietary graph is what delivers the **30-40%+ match rates** and **240-300% more leads** in [identity-quality evaluation method](/blog/visitor-identification-accuracy-independent-test-results/).

For a deeper cost breakdown across the visitor identification market, see the [pricing comparison guide](/blog/visitor-identification-pricing/).

---

## What You Can Build

The API is a building block. Here’s what developers and teams are building on top of it:

- **AI sales agent** that acts on real-time visitor data – [Feed Visitor Data Into Your AI Agent](/blog/how-to-feed-visitor-data-into-ai-agent/)
- **Custom AI SDR** with personalized outreach triggered by page visits – [Build a Custom AI SDR](/blog/build-custom-ai-sdr-with-leadpipe-and-openai/)
- **Multi-tenant SaaS feature** that gives each of your clients visitor identification – [Multi-Tenant Visitor Identification](/blog/multi-tenant-visitor-identification-for-saas-platforms/)
- **Clay enrichment pipeline** with Leadpipe as the first waterfall step – [Add Visitor ID to Clay Waterfall](/blog/how-to-add-visitor-identification-to-clay-waterfall/)
- **White-label agency tool** with your branding on the dashboard – [White-Label Visitor Identification](/blog/white-label-visitor-identification/)
- **RevOps data pipeline** feeding CRM, marketing automation, and analytics – [Leadpipe for RevOps](/blog/leadpipe-for-revops-programmatic-data-for-your-stack/)

Every one of these patterns starts with the same foundation: an API key and the endpoints covered in this guide. The [identity resolution for platforms guide](/blog/identity-resolution-for-platforms-build-vs-buy-vs-embed/) walks through the build-vs-buy decision if you’re evaluating whether to build identification yourself or embed an existing solution.

---

## Get Started

**[Sign up free – 500 identified leads, no credit card.](https://app.leadpipe.com)**

Grab your API key from the dashboard, make your first call, and see identified visitor data flowing back in minutes. Not weeks. Not after a sales cycle. Today.

If you want the deep-dive developer reference, the [complete API developer guide](/blog/visitor-identification-api-complete-developer-guide/) covers every endpoint, every parameter, every edge case. If you want a step-by-step tutorial for SaaS platforms, start with [Add Identity Resolution to Your SaaS in 10 Minutes](/blog/add-identity-resolution-to-your-saas-in-10-minutes/).

**[Start building with the Leadpipe API.](https://dashboard.leadpipe.com/auth/signup)**

---

## FAQ

### How long does it take to start seeing identified visitors?

Minutes. Create your account, generate an API key, create a pixel via API, install the script tag on your site, and visitor data starts flowing as soon as you get traffic. The [pixel install](/blog/how-to-easily-identify-anonymous-website-visitors/) itself is a two-minute copy-paste job.

### What’s the match rate?

**30-40%+ depending on traffic quality.** Leadpipe uses its own [deterministic identity graph](/blog/deterministic-vs-probabilistic-matching-explained/) – not a resold third-party graph. In head-to-head tests, that translates to **240-300%+ more identified leads** than competing tools. The [identity-quality evaluation method](/blog/visitor-identification-accuracy-independent-test-results/) have the full breakdown.

### Is there an SDK or do I use raw HTTP?

Raw HTTP. The API is a standard REST interface that works with any language that can make HTTP requests – curl, Python, JavaScript, Go, Ruby, Java, whatever you use. No proprietary SDK to install, no dependency to maintain, no version conflicts. The code examples in this guide work as-is.

### What does API access cost?

All Leadpipe plans include API access. Plans start at **$147/month** for 500 identifications. Agency/white-label plans start at **$1,979/month** for 20,000 identifications. There’s a **free trial with 500 identified leads**, no credit card required. Month-to-month billing with no annual contracts. Full pricing details in the [pricing guide](/blog/visitor-identification-pricing/).

---

## Related Articles

- [Top 5 B2B Website Visitor Identification Software](/blog/b2b-website-visitor-identification-software/)
- [Cross-Domain Visitor Identification](/blog/multi-domain-visitor-tracking/)
- [5 Best B2C Visitor Identification Tools](/blog/5-best-b2c-website-visitor-identification-tools/)
- [Visitor Identification API: Complete Developer Guide](/blog/visitor-identification-api-complete-developer-guide/)
- [Add Identity Resolution to Your SaaS in 10 Minutes](/blog/add-identity-resolution-to-your-saas-in-10-minutes/)
- [Identity Resolution for Platforms: Build vs. Buy vs. Embed](/blog/identity-resolution-for-platforms-build-vs-buy-vs-embed/)
- [Feed Real-Time Visitor Data Into Your AI Agent](/blog/how-to-feed-visitor-data-into-ai-agent/)
- [Leadpipe Intent API: 20,000 Topics, Person-Level](/blog/leadpipe-intent-api-20000-topics/)
- [Webhook Payload Reference: Every Visitor Data Field](/blog/webhook-payload-reference-every-visitor-data-field/)
- [Identity Data as a Service: API-First Visitor Identification](/blog/identity-data-as-a-service-api-first-visitor-identification/)