High-Intent Visitors

Export identified visitors who viewed your pricing or product pages in the last 24 hours

Use Case

  • Daily lead list for sales outreach
  • Identify resolved visitors showing buying signals (pricing pages, demo pages, contact pages)
  • Filter by page URL patterns and export unique contacts

Prerequisites

  • Organization API key + secret pair (Authentication). Create one at https://app.delivr.ai/{org_id}/settings/api-keys.
  • Pixel ID from your dashboard or the On-Domain Events API

How URL Filtering Works

The visited page URL is stored inside the event_data field as a JSON string. Match it on the server with like, which is a case-sensitive substring match. See Filter on the page URL or a custom parameter.

event_data:like:/pricing                         # URL contains /pricing
event_data:like:/pricing|event_data:like:/demo   # /pricing or /demo (OR with `|`)

Put every page condition in filter, and do not send distinct with it. The API applies filter first, and then distinct keeps each person's earliest event that matches filter. event_data also holds the referrer, so that earliest match can be a home page view reached from /pricing. Your url check drops that row, and the person's later /pricing view never comes back. Instead, select hem, check url in code, and then keep one row per hem.

{
  "event_type": "page_view",
  "event_data": "{\"url\":\"https://yoursite.com/pricing\",\"title\":\"Pricing - YourSite\",...}",
  "first_name": "jane",
  "last_name": "smith",
  "company_name": "acme corp"
}

Steps

1. Set Up Your Time Range

Events require a time range in milliseconds (Unix epoch).

# Last 24 hours in milliseconds
END_MS=$(python3 -c "import time; print(int(time.time()*1000))")
START_MS=$(python3 -c "import time; print(int((time.time()-86400)*1000))")

2. Fetch Resolved Page View Events

Fetch resolved page views that match /pricing. A person can appear more than once, so check url and then dedupe by hem.

curl "https://api.delivr.ai/api/v3/events/resolution_full_profile?source=pixel&pixel_id=YOUR_PIXEL_ID&start_ms=$START_MS&end_ms=$END_MS&filter=resolved%3Aeq%3Atrue%2Cevent_type%3Aeq%3Apage_view%2Cevent_data%3Alike%3A%2Fpricing&select=hem,first_name,last_name,current_business_email,company_name,job_title,seniority_level,event_data,timestamp&limit=100" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "X-Api-Secret: YOUR_API_SECRET"

Filter: resolved:eq:true,event_type:eq:page_view,event_data:like:/pricing. URL-encode : as %3A, , as %2C, / as %2F and | as %7C in curl.

Expected Response

{
  "pixel_id": "8a755c42-b2b1-...",
  "start_ms": 1706745600000,
  "end_ms": 1706832000000,
  "limit": 100,
  "offset": 0,
  "rows": [
    {
      "hem": "5f2b...",
      "first_name": "jane",
      "last_name": "smith",
      "current_business_email": "[email protected]",
      "company_name": "acme corp",
      "job_title": "vp of marketing",
      "seniority_level": "vp",
      "timestamp": "2026-01-15T14:30:00Z",
      "event_data": "{\"url\":\"https://yoursite.com/pricing\",\"title\":\"Pricing\"}"
    }
  ],
  "meta": { "files_scanned": 29, "took_ms": 145 }
}

Python Example: Pricing Page Lead List

Fetch resolved views of any high-intent page in one filter, drop referrer-only matches, then keep each person's first matching view.

import json
import time
import requests

API_KEY = "your_api_key"
API_SECRET = "your_api_secret"
PIXEL_ID = "your_pixel_id"

HEADERS = {
    "X-Api-Key": API_KEY,
    "X-Api-Secret": API_SECRET,
}

# Last 24 hours
end_ms = int(time.time() * 1000)
start_ms = end_ms - (24 * 60 * 60 * 1000)

# URL patterns to match. One OR clause per pattern, applied on the server.
HIGH_INTENT_PATTERNS = ["/pricing", "/demo", "/contact", "/get-started"]
PAGE_FILTER = "|".join(f"event_data:like:{p}" for p in HIGH_INTENT_PATTERNS)
FILTER = f"resolved:eq:true,event_type:eq:page_view,{PAGE_FILTER}"

all_rows = []
offset = 0
limit = 100

while True:
    resp = requests.get(
        "https://api.delivr.ai/api/v3/events/resolution_full_profile",
        headers=HEADERS,
        params={
            "source": "pixel",
            "pixel_id": PIXEL_ID,
            "start_ms": start_ms,
            "end_ms": end_ms,
            "limit": limit,
            "offset": offset,
            "filter": FILTER,
            "select": "hem,first_name,last_name,current_business_email,company_name,job_title,seniority_level,event_data,timestamp",
        },
    )
    resp.raise_for_status()
    rows = resp.json().get("rows", [])
    all_rows.extend(rows)

    if len(rows) < limit:
        break
    offset += limit

# event_data also holds the referrer, so keep rows whose own url matched,
# then keep each person's first matching view
leads_by_hem = {}
for row in sorted(all_rows, key=lambda r: r.get("timestamp", "")):
    event_data = json.loads(row.get("event_data") or "{}")
    url = event_data.get("url", "")
    if row["hem"] not in leads_by_hem and any(pattern in url for pattern in HIGH_INTENT_PATTERNS):
        leads_by_hem[row["hem"]] = {
            "name": f"{row.get('first_name', '')} {row.get('last_name', '')}".strip(),
            "email": row.get("current_business_email", ""),
            "company": row.get("company_name", ""),
            "job_title": row.get("job_title", ""),
            "seniority": row.get("seniority_level", ""),
            "page": url,
            "timestamp": row.get("timestamp", ""),
        }
leads = list(leads_by_hem.values())

print(f"Found {len(leads)} high-intent visitors")
for lead in leads:
    print(f"  {lead['name']} ({lead['company']}) - {lead['page']}")

Variations

Deduplicate by Company

One row per unique company instead of one row per person. Select company_domain and key the dedupe on it instead of hem. Do not send distinct=company_domain, for the same referrer reason.

"select": "company_domain,company_name,company_industry,first_name,last_name,job_title,event_data,timestamp",
"has_valuable_data": "true",

# In the dedupe loop
key = row.get("company_domain")

Filter by Seniority

Add a seniority filter to surface decision-makers only.

Enrichment fields like seniority_level support the like (case-sensitive substring, so match the stored case) and not_null operators, which the API applies for you:

# Server-side: only rows that carry a seniority value at all
"filter": "resolved:eq:true,event_type:eq:page_view,seniority_level:not_null",

# Server-side: a single seniority value
"filter": "resolved:eq:true,event_type:eq:page_view,seniority_level:like:director",

To match a set of seniority values, join one like clause per value with | (OR) in the same group:

"filter": f"{FILTER},seniority_level:like:vp|seniority_level:like:director|seniority_level:like:cxo",

Notes

  • The Events API has a 25-hour maximum time window per request. For longer ranges, make multiple requests in 24-hour chunks.
  • resolved:eq:true filters for events where the visitor was identified. Without this filter, you will also get anonymous events.
  • Filter page URLs with event_data:like:<path> in filter. Do not add distinct, because it keeps each person's earliest match, which can be a referrer-only row.
  • event_data also holds the referrer, so a like match can come from the referrer alone. Check url in the returned event_data, and then dedupe by hem in code.
  • A like value cannot contain , or |, which separate clauses. AND with ,, OR with |.
  • event_data is returned as a JSON string in the response. Use json.loads() or JSON.parse() before accessing fields.

Next Steps


Did this page help you?