clay-alt-enrich-via-exa

---
name: clay-alt-enrich-via-exa
description: Enrich a B2B lead by looking up company info, LinkedIn URL, and likely contact via Exa MCP. Input is a domain (e.g. stripe.com) or company name. Output is strict JSON for ingestion by the Clay Alt waterfall orchestrator. Use as the first (and, in v1, only) provider in the Clay Alt Platform waterfall. Cheap (~$0.005/call). Works without any paid enrichment API subscriptions.
allowed-tools: mcp__exa__web_search_exa mcp__exa__crawling_exa Bash
---

# clay-alt-enrich-via-exa

Single-purpose enrichment provider for the Clay Alt Platform. Given a domain or company name, return a structured JSON record with the data Exa can surface via neural web search.

## When to use

- The waterfall orchestrator calls this skill for each lead with `status='scraped'`
- You want a cheap first-pass enrichment without paying for Apollo/Clearbit/RapidAPI
- You need company + LinkedIn + best-guess contact but don't need verified email

## When NOT to use

- Lead already has `company`, `linkedin_url`, and `first_name` populated (skip — already enriched)
- You need a verified email (Exa cannot verify; pattern-guesses only — use a paid verifier provider in v2)
- Company is a huge multinational (Exxon, Microsoft) — neural search returns too much noise; use an enterprise provider

## Input contract

The caller passes one of:
- `domain`: e.g. `"stripe.com"` (preferred — more precise)
- `company_name`: e.g. `"Stripe"` (used only if domain absent)

Additional optional hint: `title_target` (e.g. `"CEO"`, `"Head of Procurement"`) to bias the contact search.

## Output contract

**Print exactly one JSON object to stdout**, nothing else. No markdown fences. No explanation text. Schema:

```json
{
  "company": "Stripe",
  "domain": "stripe.com",
  "first_name": "Patrick",
  "last_name": "Collison",
  "title": "CEO",
  "email_guess": "patrick@stripe.com",
  "linkedin_url": "https://www.linkedin.com/in/patrickcollison",
  "provider_raw": { "exa_results": [...] },
  "notes": "short free-text on confidence / caveats"
}
```

Every field is nullable (null, not empty string) if Exa didn't surface that data.

## How

### Step 1: Normalize input
If `domain` is given, strip `http(s)://` and `www.`. If only `company_name`, try the domain first via `mcp__exa__web_search_exa` with query `"<company_name> official site"` and parse the first result's URL.

### Step 2: Pull company context
Call `mcp__exa__web_search_exa` with two queries (in one parallel tool call if possible):
- `"<domain> company overview"` — gets description, HQ, size
- `"site:linkedin.com/in CEO <company_name>"` (or `title_target` instead of CEO) — gets the LinkedIn profile URL of the decision-maker

### Step 3: Extract the contact
From the LinkedIn search result, parse the first hit's URL (should match `linkedin.com/in/<slug>`). Parse name from the result title (usually `"Name - Title - Company | LinkedIn"`).

### Step 4: Pattern-guess email
With the extracted `first_name` and `domain`, construct the guess as `first.last@<domain>` (lowercased, accents stripped). This is **not verified** — mark `email_guess`, never `email`. The routine's verify step decides whether to promote it.

### Step 5: Emit JSON
Exactly one JSON object to stdout. No preamble. No explanation. Caller will pipe this directly into `jq` and upsert into Supabase.

### Error handling

- If Exa returns zero relevant results, emit the JSON with null fields populated wherever possible and a `notes` explaining what was missed. Do NOT throw; the waterfall decides whether to fall through to the next provider.
- If an MCP tool errors, retry once. On second failure, emit minimal JSON with notes `"exa mcp unavailable"` and exit 0 (waterfall handles fallback).

## Cost awareness

Two Exa searches per lead ≈ $0.01. At 100 leads/day that's $30/month — well within the $100/mo Clay-alternative budget. Cache per-domain results in `leads.provider_raw` so re-runs on the same campaign don't double-bill.

## v2 expansion

When paid providers are added, this skill stays unchanged. The waterfall simply calls it first; on incomplete output, it falls through to `clay-alt-enrich-via-apollo`, `clay-alt-enrich-via-clearbit`, etc.