Proxycurl Webhook Replacement: Real-Time Profile Updates in 2026

Proxycurl Webhook Replacement: Real-Time Profile Updates in 2026

TL;DR. No 2026 LinkedIn data provider ships a 1:1 replacement for Proxycurl's profile-update webhooks. Three patterns now cover the use case: sentinel-field polling (lowest effort, highest latency), event-driven hooks on a curated watchlist (middle ground), and hybrid cache invalidation with TTL bands (lowest steady-state cost). Most production teams in 2026 run pattern 3.

Why Proxycurl webhooks mattered

Proxycurl's webhook product was narrow but well-loved. Teams subscribed a profile URL to a webhook endpoint, and Proxycurl posted back when one of a small set of fields changed: current company, current title, location, or headline. The polling work, the diffing, the queueing all sat on Proxycurl's side. Subscribers paid a flat per-event fee and built downstream workflows on the assumption that the event firehose was complete.

The shutdown took that model away in one weekend. Every webhook URL went 404 on July 17, 2025. Teams whose CRM-enrichment, job-change-alert, or recruiting pipelines depended on that firehose discovered the same thing at the same time: there was no other provider doing exactly this.

The reason no provider rebuilt it 1:1 is structural, not technical. Proxycurl's webhook product was the part of their architecture closest to LinkedIn's terms of service. Running a profile-watch service at the scale Proxycurl ran it required continuous deep crawling of profiles you were not currently looking at, which is the surface LinkedIn's legal team had spent four years preparing to hit. Every 2026 provider that survived the post-hiQ enforcement window built their architecture explicitly to not look like that.

That leaves three patterns for teams that still need fresh profile state.

The three real-time patterns in 2026

Pattern	Latency to detect change	Cost shape	Eng effort	Best for
1. Sentinel-field polling	24 to 72 hours	Linear in watchlist size	Low	Small watchlists, batch CRM jobs
2. Event-driven hooks (LinkFetch)	4 to 12 hours	Per-event flat	Medium	Recruiting, job-change alerts
3. Hybrid cache invalidation with TTL bands	30 min to 24 hours, configurable	Sublinear at scale	High	High-volume enrichment APIs

Three notes on the table before we walk through each:

• Latency is detection latency, not data freshness. Once an event fires, the data behind it is current. The numbers above are how long until you find out a change happened.
• Cost shapes assume the 2026 LinkFetch pricing model (compared here). Pattern 1 is cheapest at low volume, pattern 3 wins at high volume.
• None of the three match Proxycurl's old "subscribe and forget" UX. All three require the consuming team to own at least the watchlist definition.

Pattern 1: Sentinel-field polling

The simplest pattern, and the one most teams reach for first. You maintain a watchlist of profile URLs and poll each on a fixed cadence (typically daily). Diff against your stored snapshot, fire your own internal event when a sentinel field changes.

async def daily_poll(watchlist: list[str]) -> list[ChangeEvent]:
    events = []
    for url in watchlist:
        current = await linkfetch.profiles.get(url)
        prior = cache.get(url)
        if prior and sentinel_diff(prior, current):
            events.append(ChangeEvent(url, current, prior))
        cache.set(url, current, ttl=86400)
    return events

def sentinel_diff(prior: Profile, current: Profile) -> bool:
    return (
        prior.current_company_id != current.current_company_id
        or prior.current_title != current.current_title
        or prior.location_country != current.location_country
    )

The math: 10,000-profile watchlist polled daily costs 10,000 credits per day, or roughly 300,000 credits a month.

Pattern 1 works for watchlists under 2,500 profiles. Above that, the credit math gets uncomfortable and pattern 3 starts to dominate.

Pattern 2: Event-driven hooks via LinkFetch

LinkFetch ships its own profile-watch product, modeled after Proxycurl's but with two structural differences worth understanding before you migrate.

First, LinkFetch's watch product is opt-in per-profile, not per-domain or per-company. You declare exactly which profiles you want to watch, and you can change the set at any time, but the system will not surface changes on profiles you have not explicitly subscribed.

Second, the event firehose is not complete. LinkFetch posts events on changes detected during the user-principal data-access flow, which means freshness depends on whether one of LinkFetch's principals happened to load that profile recently. For high-traffic profiles (founders, recruiters, well-known engineers), detection latency averages 4 hours. For long-tail profiles, it can stretch to 24+ hours.

Subscribe to a watchlist like this:

curl -X POST https://api.linkfetch.com/v1/watch \
  -H "Authorization: Bearer $LINKFETCH_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "profile_urls": ["https://linkedin.com/in/jane-doe", ...],
    "webhook_url": "https://your-app.com/hooks/linkedin",
    "fields": ["current_company", "current_title", "location"]
  }'

The webhook payload mirrors a subset of Proxycurl's old schema, which makes the migration from a Proxycurl-shaped consumer adapter close to a one-line change.

Cost shape: you pay per delivered event, not per poll. The volume of fired events is two orders of magntiude smaller than the polling volume, so the all-in math favors pattern 2 above ~5,000 profiles.

Pattern 3: Hybrid cache invalidation with TTL bands

The pattern most production teams settle on after six months of running pattern 1 or 2. The insight: not every profile in a watchlist needs the same freshness. A CEO at a Fortune 500 needs different freshness than a junior engineer at a Series A.

Hybrid invalidation works by assigning each profile to a TTL band based on a heuristic score, then polling each band at a different cadence. The score is whatever the consuming team cares about (sales-priority, role-seniority, recent-engagement). What matters is the structure, not the input.

TTL_BANDS = {
    "hot": 30 * 60,      # 30 min, VIPs and hot pipeline accounts
    "warm": 6 * 3600,    # 6 hr, active sales opportunities
    "cool": 24 * 3600,   # 24 hr, broader watchlist
    "cold": 7 * 86400,   # 7 days, long-tail enrichment
}

def assign_band(profile_meta: dict) -> str:
    score = compute_score(profile_meta)
    if score >= 0.85: return "hot"
    if score >= 0.55: return "warm"
    if score >= 0.25: return "cool"
    return "cold"

A typical 10K-profile watchlist tiers as roughly 200 hot, 800 warm, 3,000 cool, 6,000 cold. The credit cost for that tiering, run through LinkFetch with daily-equivalent freshness on the hot band:

Band	Profiles	Polls/day	Daily credits
Hot	200	48	9,600
Warm	800	4	3,200
Cool	3,000	1	3,000
Cold	6,000	0.14	840
Total	10,000		~16,640

Compared to pattern 1's flat 10,000 credits/day, the hot band alone costs more. But pattern 3 also delivers near-real-time detection on the 200 profiles that actually matter to revenue, which pattern 1 does not at any cost short of polling everything every 30 minutes.

The engineering effort is higher because you need a scoring function and a band re-evaluation pass. Most teams write that as a weekly batch job over the watchlist metadata. Once the scoring stabilizes, the cron is the kind of thing nobody touches for nine months.

Migration checklist

If you are leaving Proxycurl's webhook product behind, in any order:

1. Audit which downstream consumers actually depend on real-time. Half of teams discover that their "real-time" workflow tolerates 24-hour latency, which collapses the decision to pattern 1.
2. Inventory the watchlist. Profile URLs, current TTL assumptions, downstream consumers. This is the artifact you bring into the migration conversation.
3. Pick a pattern based on watchlist size and freshness need, not on engineering preference. Pattern 3 looks clever, but a 500-profile watchlist will run pattern 1 cheaper and simpler for years.
4. Build a Proxycurl-shaped consumer adapter so the downstream contract does not change. LinkFetch's webhook payload aligns with a subset of Proxycurl's, and the field-mapping cheatsheet covers the gaps.
5. Run pattern 1 in shadow mode for two weeks even if you plan to land on pattern 2 or 3. The shadow data tells you whether your latency assumptions held under real load.

FAQ

Can I get exactly Proxycurl's old webhook behavior from any 2026 provider?

No. The architectural constraint that took Proxycurl down also rules out any 2026 provider running the same model at the same scale. The closest commercial offering is LinkFetch's event-driven webhook product, which covers about 70% of the original use case (changes detected within 4 to 12 hours instead of near-real-time, watchlist-bounded instead of open-ended).

Why is sentinel-field polling cheaper than the webhook product at small scale?

Because the polling product charges a flat credit-per-profile-poll fee and the webhook product charges per-fired-event with a watchlist-size minimum. For a 500-profile watchlist where maybe 8 change a month, the polling cost (~15,000 credits/month) lands under the webhook product's floor. The crossover point is around 5,000 profiles for most use cases.

Does pattern 3 work with non-LinkFetch providers?

Yes, in principle. Any provider that bills per-call lets you implement TTL banding on your side. Coresignal and Bright Data both support this pattern, with different cost shapes. The two provider-specific gotchas are Coresignal's quarterly minimum commit (which makes the math worse below 50K profiles) and Bright Data's per-region surcharge (which kicks in around Q3 of any TTL band that includes EU profiles).

How do I handle profile deletions?

All three patterns surface deletions as a 404 on the next poll or watch refresh. The cleanest pattern is to treat 404 as a special event type in your downstream consumer (not as an error), keep the last-known-state in your cache for 30 days, and flag the record for a human review. LinkedIn profile deletions are rare and usually reversible inside that 30-day window, so eager deletion of downstream state tends to cause more pain than it solves.

What about company-level webhooks for headcount changes?

LinkFetch ships a parallel product for company-level events (headcount delta, leadership changes, location changes). The pricing and freshness story is similar to the profile webhook but the watchlist sizes are typically smaller (low hundreds, not tens of thousands), which makes the pattern 2 cost structure dominant for almost every team using it.

---

Last updated: 2026-06-08. Written by the LinkFetch team.