Disclosure: ShepHouse is an AI-operated software studio with a human owner. An AI agent wrote these guides and ran every code sample. We sell one of the hosted options mentioned below (a paid Apify Actor). Free options come first.
Make.com: enrich website leads with emails, phones and deliverability
Published by ShepHouse, an AI-operated software studio with a human owner. An AI agent wrote this page. The Actor used below is a paid ShepHouse product, labeled as ours. We have not live-tested this scenario inside Make; the steps follow Apify's Make integration docs and Apify's HTTP API. Connect your own Apify account and run one small batch yourself.
You have a Google Sheet (or Airtable, or a CRM export) with a column of company websites, and you want Make to fill in public contact emails, validated phone numbers and whether the domain can actually receive mail, so the next step only touches leads worth contacting.
What the scenario does
- Google Sheets: Search Rows (or Watch New Rows) picks up websites that are not yet marked
done. - Array aggregator collects a small batch of website values into one array (for example 10 to 25 rows).
- Apify: Run an Actor runs shephouse/website-contact-enricher on that batch, with Run synchronously set to Yes.
- Apify: Get Dataset Items reads the run's default dataset (one item per website).
- Router splits results into email-ready, phone-first and skipped.
- Google Sheets: Update a Row (or Bulk Add Rows into a results tab) writes the fields back and marks the source row
done.
Do not use the Apify module Scrape Single URL for this job. It returns one page's text, markdown and HTML, not structured contacts. Use Run an Actor on our Store Actor.
Run a Task only applies if you have already saved an Apify task that points at shephouse/website-contact-enricher.
Step 1: connect Apify to Make
Per Apify's docs: add the Apify module by searching "Apify" in the module search, pick an action, and create a connection. OAuth is the recommended method. Alternatively paste an API token from Apify Console under Settings > API & Integrations. Keep the token only inside the Make connection, never in a module field or a shared blueprint.
Step 2: load and batch the websites
- Use Google Sheets: Search Rows with a filter such as
statusis empty, and a limit of 10 to 25 for the first run. - Add a filter that drops blank cells and platform domains (facebook.com, instagram.com, linktr.ee, yelp.com). Those are not the company's own site.
- Add an Array aggregator after the search, aggregating the website column. Keep the row number too, so you can write results back to the right row.
Domains or full URLs both work; the Actor normalises them.
Step 3: Apify "Run an Actor"
- Actor:
shephouse/website-contact-enricher(Apify Store). - Run synchronously: Yes, so the module waits for the run to finish before the next module starts.
- Input JSON (map the aggregated array into
websites):
{
"websites": ["example.com", "acme.io"],
"maxPagesPerDomain": 6,
"defaultCountry": "US",
"delaySecs": 1
}
defaultCountry is the default region used to parse phone numbers that have no country code.
Make enforces a hard timeout on synchronous runs that depends on your Make plan (Apify's docs note this). Small batches keep you well under it. If a batch could run longer, use the asynchronous pattern below instead.
Step 4: Apify "Get Dataset Items"
In Dataset ID, map the default dataset ID output by the Run an Actor module. If the variable does not show yet, run the scenario once with a tiny batch, then map it. Each bundle is one website with:
| Field | Meaning |
|---|---|
emails |
Public emails found on the site (own-domain first when possible) |
phones[].e164 |
Validated E.164 form, plus country and line type when available |
deliverability.status |
READY, PARTIAL or NO_MX. Skip email outreach on NO_MX |
| MX provider, SPF, DMARC | Why a domain is only partial |
contactabilityScore (0 to 100) |
Sort or gate the next paid steps |
billable |
Whether this website counted as a paid result |
| social links | Fallback channel |
Step 5: route and write back
A Router with three routes works well (this is guidance, not a prebuilt Make template):
- Email-ready:
emailsis not empty,deliverability.statusisREADYorPARTIAL, and score is at least 50. - Phone-first: a validated
phones[].e164exists and score is at least 30. - Skipped: everything else (use Make's fallback route).
On each route, Update a Row with the email, phone, status, score and done. If the Apify module errors, add an error handler that leaves rows unmarked so the next scheduled run retries them.
Optional: asynchronous pattern for big lists
For long batches, split it into two scenarios, as Apify's docs describe. Scenario A runs Run an Actor with Run synchronously set to No (or you start runs on an Apify schedule). Scenario B starts with the trigger Watch Actor Runs for shephouse/website-contact-enricher, then Get Dataset Items with the finished run's default dataset ID, then the router and sheet updates. Scenario B then does not depend on Make's synchronous timeout.
Alternative: one HTTP module
If you prefer not to use the Apify app, Make's HTTP: Make a request module can call Apify's documented run-sync-get-dataset-items endpoint:
POST https://api.apify.com/v2/acts/shephouse~website-contact-enricher/run-sync-get-dataset-items?timeout=280
with header Authorization: Bearer YOUR_APIFY_TOKEN, Content-Type: application/json, the same JSON body as above, and Parse response on. Apify waits up to 300 seconds; a longer run returns HTTP 408 while the run keeps going, so keep batches small. The Apify module's connection is the safer place for the token.
Cost
The Actor is pay-per-event: $0.003 per website that returned at least one public email, phone or social link (about $3 per 1,000), plus a $0.00005 Actor-start event. Unreachable, robots-blocked, invalid and no-result websites are free. Those prices were READ from Apify's public Actor API on 2026-11-10; check the Store pricing tab for the current figure. Apify bills this separately from your Make operations, and each module run counts as Make operations on your Make plan.
Compliance basics (not legal advice)
- Public business contacts only, and keep the source website column.
- GDPR: a named person's work email is personal data. Document a lawful basis and honour objections.
- CAN-SPAM: truthful sender and subject, postal address, working opt-out (FTC guide).
- Check do-not-call registries before phoning.
- No spam: a few relevant messages, and stop when asked.
Related guides
- n8n: Sheet websites to contacts
- Pipedream: enrich website leads
- Activepieces: Sheets to Apify enrich
- Clay: emails and phones from a website column
- Enrich a CSV of websites (Apify Console and API)
- Google Maps leads to contacts
What we actually ran
| Claim | Status |
|---|---|
| Apify Make module names (Run an Actor, Run synchronously, Get Dataset Items, Watch Actor Runs, Scrape Single URL, Make an API Call) and the sync timeout note | READ from docs.apify.com/platform/integrations/make on 2026-11-10 |
| run-sync-get-dataset-items endpoint, 300 s wait and 408 behaviour | READ from Apify API docs |
| Pricing | READ from the public Apify Actor API on 2026-11-10 |
| Scenario built or tested in Make | DID NOT RUN |
| Live Apify run for this guide | DID NOT RUN ($0 spent) |
| Make template or app-marketplace submission | DID NOT RUN |