# Lead Enrichment Autopilot: Fill In Missing Contact Details

> **Version 2.0.0 · Last updated 2026-10-22 · Difficulty: Intermediate · Setup time: 30–60 minutes (plus run time)**

You have a list of contacts you already know about (say, 1,000 rows in a spreadsheet) and many are missing a company domain, a job title, an email or a phone number. Your clone cleans the list, researches the gaps on the public web, marks every value with its source URL and how much to trust it, and hands you back the same list with new columns added. It can optionally write the results into Salesforce or HubSpot, filling empty fields only.

---

## 1. Overview and value

Contact lists decay. People change jobs, rows get imported with blank columns, and someone pastes a company name where the domain should be. Filling the gaps by hand takes a person several minutes per row.

The Lead Enrichment Autopilot is for **enriching contacts you already have**. It is not a lead-generation tool: it won't go looking for new people to add to your list. `Clone-Lead-Generation-Skill` finds NEW leads and doesn't enrich an existing list (see section 10).

When you hand it a list, your clone:

- reads your **Google Sheet or Excel workbook** (or a CRM list you export into one) and maps the columns,
- **cleans** the data (trims, normalizes, dedupes, derives company domains, flags gaps),
- picks the **strongest identifier** for each row (work email, LinkedIn URL, name + domain, or name + company),
- runs a **test batch of 10–25 rows** and shows you the results and a **credits and time estimate** before going further,
- after your "yes", fills the empty fields with **web research** (firmographics, titles, LinkedIn URLs, plus best-guess emails and phones, always marked **UNVERIFIED** with a source URL and a confidence score),
- gives every value a **confidence score (0–100)**,
- optionally scores each row against your **ideal customer profile** (A/B/C tier),
- **appends** new columns (value, source, confidence, date) and never overwrites your originals,
- sends low-confidence and unmatched rows to a **Needs Review** tab,
- processes the rest **in batches** with a progress update after each one,
- optionally **writes back to Salesforce or HubSpot** (empty fields only) and optionally builds a **repeatable pipeline script** with `Clone_Code`.

> **Not included:** third-party data providers and email or phone verification. Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.
>
> `Clone-Lead-Generation-Skill` finds NEW leads. It doesn't enrich an existing list.

**What you get:**

| Benefit | What it looks like |
|---|---|
| Fewer blank fields | Company domains, firmographics, public titles and LinkedIn URLs filled where they can be found; best-guess emails and phones clearly marked |
| Trust you can see | Every enriched value has a source URL and a 0–100 confidence column |
| No data loss | Original columns are never changed; new columns are added to the right |
| No surprise usage | A test batch and a credits and time estimate come first, and the run stops at `{CREDIT_BUDGET}` |
| Less repeated work | Duplicates are skipped and a lookup cache stops the clone researching the same person or domain twice |
| Prioritized list (optional) | A fit score and A/B/C tier so the best contacts get worked first |

## 2. Who it's for

- **Sales reps and SDRs** with a conference list, event export or old account list that's missing domains, titles and contact details.
- **Marketing ops** cleaning a list before importing it into Salesforce or HubSpot.
- **RevOps** running a periodic data-quality pass on contacts (re-enrich every 90 days).
- **Founders and small teams** who want a tidier list without a data subscription.

It works with Salesforce or HubSpot (or no CRM at all), and with Google Sheets or Excel. The examples assume a B2B contact list.

## 3. How it works

```
 ┌─────────────────────────────────────────────────────────────────────┐
 │  You share {SOURCE_SHEET} (Google Sheet or Excel workbook)          │
 │  and tell the clone which fields to fill: {FIELDS_TO_FILL}          │
 └──────────────────────────────────┬──────────────────────────────────┘
                                    │
                                    ▼
 ┌─────────────────────────────────────────────────────────────────────┐
 │  "Lead Enrichment" skill                                            │
 │                                                                     │
 │  1. Intake           ──►  read the list, map columns (source        │
 │                           untouched)                                │
 │  2. Data hygiene     ──►  normalize, dedupe, validate, derive       │
 │                           domains, flag gaps                        │
 │  3. Match key        ──►  work email > LinkedIn URL >               │
 │                           name + domain > name + company            │
 │        ┌────────────────────────────────────────────────────┐       │
 │        │ TEST BATCH (10–25 rows) + credits and time         │       │
 │        │ estimate ──► you approve ("yes") before full run   │       │
 │        └────────────────────────────────────────────────────┘       │
 │  4. Web research     ──►  cache ► web research (clone), every       │
 │                           value with source URL, UNVERIFIED         │
 │  5. Score            ──►  confidence 0–100 per field                │
 │  6. ICP fit (opt.)   ──►  {ICP_RULES} ──► fit_score + A/B/C tier    │
 │  7. Write to file    ──►  append enr_* columns, never overwrite     │
 │  8. Review           ──►  conf < {CONFIDENCE_THRESHOLD} or no match │
 │                           ──► "Needs Review" tab                    │
 │  9. Delivery         ──►  updated Sheet / .xlsx · optional          │
 │                           Salesforce / HubSpot write-back (empty    │
 │                           fields only) · summary email              │
 │                                                                     │
 │  Runs in batches of {BATCH_SIZE} with a progress update per batch.  │
 │  Stops when {CREDIT_BUDGET} is reached.                             │
 └──────────────────────────────────┬──────────────────────────────────┘
                                    │
 ┌──────────────────────────────────┴──────────────────────────────────┐
 │  ∞ GOVERNANCE (always on): credits cap · {DO_NOT_CONTACT_LIST}      │
 │  honored · GDPR/CCPA · lookup cache · never overwrite ·             │
 │  re-enrich every 90 days                                            │
 └─────────────────────────────────────────────────────────────────────┘
```

### What web research can and can't do

| | **Web research by the clone** |
|---|---|
| Good for | Company domain, industry, size, HQ, public title, LinkedIn URL, company main phone |
| Emails | Best guess only, e.g. a pattern like `first.last@domain` inferred from public examples. Always **UNVERIFIED** |
| Phones | Public switchboard / company numbers; direct dials only if published on an official page |
| Trust | Every value has a source URL and a confidence score; guessed emails are capped low |
| Speed | A few rows per minute (it reads public pages) |
| Set up | Nothing extra |

Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

### Output: what gets added to your sheet

Your original columns stay exactly as they were. The clone adds columns to the right:

| Column | Meaning |
|---|---|
| `enr_<field>` | The enriched value, e.g. `enr_email`, `enr_phone`, `enr_title`, `enr_linkedin_url`, `enr_company_domain` |
| `enr_<field>_source` | Where it came from, e.g. `cache`, or `web: <source URL>` (emails and phones also say UNVERIFIED) |
| `enr_<field>_conf` | Confidence 0–100 |
| `enr_status` | `enriched` (all key fields at or above the threshold), `partial`, `needs_review`, `unmatched`, `duplicate`, `do_not_contact`, `skipped_budget` |
| `enr_date` | Date the row was enriched (used for the 90-day refresh) |
| `fit_score` / `fit_tier` (optional) | 0–100 ICP fit and A / B / C |

Plus these tabs: **Enriched Leads** (the full list with new columns), **Needs Review** (rows a person should check, with the reason), and **Run Summary** (counts, fill rates, credits and time used). A **Lookup Cache** tab stores every result so the same person or domain is never researched twice.

## 4. What the clone does (and what it never does)

**It does:**

1. **Reads** your list through `GoogleSheets-Operator` or `Microsoft_Excel` and works on a copy or new tabs.
2. **Cleans** names, emails, domains and phone numbers (phones in E.164 format, e.g. `+14155550123`).
3. **Skips** duplicates and anyone on `{DO_NOT_CONTACT_LIST}` (they are marked, not enriched).
4. **Estimates credits and time first.** It runs 10–25 rows, shows you fill rates and credits used, projects the total for the whole list, and waits for your "yes".
5. **Fills only empty fields.** If a row already has an email, it doesn't look for one.
6. **Labels everything.** Source URL, confidence and date on every value. Guessed emails and phones say UNVERIFIED.
7. **Reports progress** after each batch of `{BATCH_SIZE}` rows and stops cleanly at `{CREDIT_BUDGET}`.
8. **Optionally writes back** to Salesforce (`SalesforceContactOperator`, `SalesforceLeadOperator`, `SalesforceAccountOperator`) or HubSpot (`HubspotContactOperator`, `HubspotCompanyOperator`), empty fields only.
9. **Optionally builds a pipeline script** with `Clone_Code` that you can run yourself.

**It never:**

- overwrites a value that was already in your list or CRM,
- emails, calls or messages any contact on the list (this use case only fills data in),
- runs the full list without an approved credits and time estimate,
- asks for, accepts or stores API keys, passwords or tokens,
- enriches people on your do-not-contact or opt-out list,
- presents a guessed email or phone as verified,
- adds new people to your list.

**Honest limits:** the clone can't guarantee coverage. Fill rates depend on your list (work emails and LinkedIn URLs match far better than name + company) and the region. Web research alone will not give you reliable personal emails or mobile numbers.

## 5. Setup walkthrough

The quickest path: download **CLONE-INSTRUCTIONS.md** and give it to your clone. It will check what's connected, ask for your settings, show you a plan, and set up what it can after you approve.

**Step 0: Connect your accounts and switch the clone on (5 min)**
This is the most common blocker. Before anything else, connect your Google (or Microsoft 365) account so the clone can reach Sheets/Excel, and **make sure the clone is switched on / active** in the platform. A clone that's off or has no connected account can't see your sheet, and every step after this will fail.

**Step 1: Check requirements (5 min)**
Open **REQUIREMENTS.md** and run the pre-flight checklist. You need `GoogleSheets-Operator` or `Microsoft_Excel`, and web research.

**Step 2: Prepare the list (5–10 min)**
Make a **copy** of your list for the test. Make sure there's a header row and at least a name plus a company or email per row. Share the sheet with the clone (edit access). If your list lives in Salesforce or HubSpot, export it to a sheet first.

**Step 3: Hand the instructions to your clone (2 min)**
Paste or upload CLONE-INSTRUCTIONS.md and say: *"Please set up this use case for me. Show me a plan before changing anything."*

**Step 4: Review discovery and answer the placeholder questions (5–10 min)**
The clone reports what's connected and asks for the values in section 6.

**Step 5: Approve the plan (2 min)**
Say "yes" only when the list of things it will attach and create looks right.

**Step 6: Do your part (5–20 min)**
Share the sheet, give the clone your do-not-contact list, and (if you want write-back) connect Salesforce or HubSpot through the platform's sign-in screen.

**Step 7: Run the test batch (10–15 min)**
The clone enriches 10–25 rows on your copy, shows you the results and a credits and time estimate for the full list. Check a few values yourself.

**Step 8: Approve the full run**
Say "yes" to the estimate. The clone processes the rest in batches and reports after each one.

**Step 9 (optional): Schedule a refresh**
Ask the clone to create a scheduled task that re-enriches rows older than 90 days.

### Credits and time estimate

Use the **"Credits & time estimator"** linked on this card for a live calculation. Every number below is an **example you can edit**, not a quote. Your real credits per lookup depend on your plan and on how much reading each row needs.

```
unique rows        = total rows × (1 − duplicate rate) − do-not-contact rows
rows to look up    = unique rows × (1 − share already complete) × (1 − cache hit rate)
credits per run    ≈ rows to look up × fields per row × credits per field lookup
batches            = rows to look up ÷ batch size (rounded up)
time               ≈ rows to look up ÷ rows researched per minute
```

Example inputs (edit them in the estimator):

| Input | Example value |
|---|---|
| Total rows | 1,000 |
| Duplicates | 10% (so 900 unique rows) |
| Already complete | 10% (so 810 rows to look up) |
| Cache hits (first run) | 0% |
| Fields to fill per row | 3 |
| Credits per field lookup | 1 (example only) |
| Rows researched per minute | about 4 |
| Batch size | 50 (so 17 batches) |
| **Example result** | **about 2,430 credits and about 3.5 hours** |

The test batch gives you your real fill rate and credits per row; the clone re-runs this math with them before asking for approval.

## 6. Placeholders to decide

| Placeholder | What it means | Example / default |
|---|---|---|
| `{SOURCE_SHEET}` | The list to enrich: Google Sheet link or Excel workbook | "Q3 Event Contacts" Google Sheet, tab "Leads" |
| `{FIELDS_TO_FILL}` | Which fields to fill when empty | Default: company domain, title, LinkedIn URL, email, phone |
| `{CREDIT_BUDGET}` | Max credits per run; the run stops here | 2,500 credits |
| `{CONFIDENCE_THRESHOLD}` | Below this, a value goes to Needs Review | Default: 60 |
| `{ICP_RULES}` | (Optional) Rules for fit score and tier | Software or Financial Services, 50–5,000 employees, Director+; A ≥ 75, B ≥ 50 |
| `{DO_NOT_CONTACT_LIST}` | Emails/domains never to enrich (opt-outs, deletion requests, competitors) | "Suppression" tab or CRM do-not-contact flag |
| `{BATCH_SIZE}` | Rows per batch in the full run | Default: 50 |
| `{CRM_SYNC}` | Write results back to a CRM afterwards? | `no` (default), `salesforce` or `hubspot` |
| `{SUMMARY_RECIPIENTS}` | (Optional) Who gets the run summary email | you@yourcompany.com |

Tip: start with `{CRM_SYNC} = no`. Review the sheet first, then write back once you trust the output.

## 7. What to expect

- **Test batch:** 10–25 rows in roughly 5–15 minutes, then a short report: fields filled, confidence spread, credits used, projected credits and time for the full list.
- **Full run:** batches of `{BATCH_SIZE}`. Web research is the slow part (often a few rows per minute). A 1,000-row list typically takes a few hours.
- **After each batch:** a progress message, e.g. "Batch 4/17 done: 200/810 rows, 71% domains filled, 600 credits used of 2,500."
- **At the end:** the Enriched Leads, Needs Review and Run Summary tabs, plus an optional summary email to `{SUMMARY_RECIPIENTS}`.
- **Your part:** spend 10–20 minutes on the Needs Review tab. Approve, fix or reject each row.
- **Every 90 days (optional):** a scheduled refresh re-checks rows whose `enr_date` is older than 90 days.

## 8. Customizing

**Fields.** Add firmographics (industry, employee count, HQ city, revenue band) or person data (seniority, department) to `{FIELDS_TO_FILL}`. Web research is good at firmographics.

**Confidence threshold.** Raise `{CONFIDENCE_THRESHOLD}` to 70 if you want only well-sourced values written back. Lower it to 50 if you only need research context.

**ICP scoring.** Rewrite `{ICP_RULES}` in plain words: points per rule, tier cut-offs. Turn scoring off if you don't need it.

**Output location.** New tabs in the same sheet (default), a new file, or (only if you ask) new columns in the original tab, always to the right of your data.

**CRM write-back.** Choose Salesforce or HubSpot. By default only firmographics, titles and LinkedIn URLs are written; guessed emails and phones are written only if you explicitly say so.

**Build a repeatable pipeline (`Clone_Code`).** If you enrich lists often, ask the clone to use **Clone_Code** (its coding skill) to build a small script you can run yourself: read a list, apply the same hygiene, match key and confidence rules, and write the same output columns. Keep any keys out of the code and out of chat.

## 9. Known gotchas

- **Connect your accounts and switch the clone on first.** The most common onboarding blocker. If your Google (or Microsoft) account isn't connected, or the clone isn't switched on / active, it can't open the sheet and setup stalls.
- **This enriches existing contacts. It does not find new leads.** `Clone-Lead-Generation-Skill` finds new people that match a profile; it does not fill in blanks on your list. If you want new prospects, use it first, then run this use case on its output.
- **Web results aren't verified.** Pattern-guessed emails (`first.last@domain`) can bounce. They are always marked UNVERIFIED. Don't load them into a sending tool without verifying them elsewhere.
- **Verified email/phone data needs a paid data provider.** If your org adds an operator for one, add it as an extra step. It isn't required for this use case.
- **Respect do-not-contact and privacy laws.** Under GDPR, CCPA/CPRA and similar laws you need a lawful basis (often legitimate interest, documented) to process personal data, should collect only what you need, and must honor opt-outs and deletion requests. Keep `{DO_NOT_CONTACT_LIST}` current. This is not legal advice; check with your privacy lead.
- **Batch large lists.** Running thousands of rows at once makes mistakes expensive. Batches of 50 with a progress check are safer.
- **Share the sheet with the clone.** "Permission denied" almost always means the sheet isn't shared with the clone's account (edit access needed to add tabs).
- **Duplicate rows.** The same person often appears twice with different spellings. Duplicates are marked `enr_status = duplicate` and not researched, but check the hygiene results in the test batch.
- **Phone formats.** Phones are normalized to E.164 (`+` country code + number). Rows with no country can't be normalized reliably; set a default country if your list is single-country.
- **Use the cache.** The Lookup Cache tab stops repeated research for the same person or domain. Don't delete it between runs.
- **Personal emails.** A gmail.com or outlook.com address doesn't tell you the company. The clone won't derive a company domain from it.
- **Similar names.** Web research can match the wrong person with the same name. Name + company matches are the weakest and get low confidence.
- **Use exact skill/operator names** from your catalog. The clone checks them during discovery.
- **Read the skill before you save it.** You're responsible for what your clone does.

## 10. FAQ

**I have 1,000 contacts and want emails and phone numbers added. Is this the right use case?**
Partly. It fills company domains, firmographics, public titles and LinkedIn URLs reasonably well, and adds best-guess emails and company phone numbers marked UNVERIFIED. Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

**Will it find new leads for me?**
No. `Clone-Lead-Generation-Skill` finds NEW leads and doesn't enrich an existing list. This use case only fills in missing details for contacts already on your list.

**Will it overwrite what's already in my sheet or CRM?**
No. It only fills empty fields, and writes them to new `enr_*` columns. CRM write-back (if turned on) only fills empty CRM fields.

**Will it email the contacts?**
No. The only email it sends is the optional run summary to `{SUMMARY_RECIPIENTS}`.

**Does it work with Excel instead of Google Sheets?**
Yes. Use `Microsoft_Excel` (a workbook in OneDrive) or upload an .xlsx/.csv; the clone returns a workbook with the same tabs.

**Which CRMs work?**
Salesforce (`SalesforceContactOperator`, `SalesforceLeadOperator`, `SalesforceAccountOperator`) and HubSpot (`HubspotContactOperator`, `HubspotCompanyOperator`). See REQUIREMENTS.md for the concept mapping.

**How accurate is it?**
Each value carries a confidence score and a source URL so you can decide. Company data from an official site is usually reliable; guessed emails are not. Check the test batch yourself.

**How do I know what it used?**
The Run Summary tab lists lookups, credits and time. Use the "Credits & time estimator" on the card to plan a run.

## 11. Troubleshooting

| Symptom | Likely cause | Fix |
|---|---|---|
| Clone says it can't find or open the sheet | Account not connected, clone not switched on, or sheet not shared | Connect Google/Microsoft, switch the clone on, share the sheet with edit access |
| "Permission denied" when adding tabs | View-only sharing | Give the clone edit access, or ask for output as a new file |
| Columns mapped wrong | Unusual headers | Tell the clone the mapping, e.g. "Org = company" |
| Very low fill rate | Weak match keys (name + company only) | Add domains or LinkedIn URLs to the list |
| Lots of UNVERIFIED emails | Expected with web research only | Treat them as leads to check; verified data needs a paid data provider (optional extra step) |
| Credits ran out mid-run | `{CREDIT_BUDGET}` reached | Rows left are marked `skipped_budget`; raise the budget, then resume |
| Web research "unavailable" | Tool call failed twice | Retry later; the clone reports which rows were skipped |
| Same person researched twice | Cache tab deleted or rows not deduped | Keep the Lookup Cache tab; check hygiene settings |
| Phones look wrong | No country column, mixed formats | Set a default country; check E.164 output in the test batch |
| Contacts on opt-out list were enriched | `{DO_NOT_CONTACT_LIST}` not shared or incomplete | Share and update the list; clear those rows' enr_* values |
| CRM not updated | `{CRM_SYNC} = no`, or CRM connection read-only | Turn sync on and grant write access to the listed fields only |

---

**Version:** 2.0.0 · **Last updated:** 2026-10-22 · Part of the Clone Use Case Library.