Make.com for Sales Teams: Build Automated Outbound Pipelines

Contains affiliate links. Disclosure.

Most outbound sales teams still run on spreadsheets, copy-paste, and manual follow-ups. A rep spends 2–3 hours a day on tasks that add zero revenue: exporting lead lists, writing templated emails, logging calls, and chasing cold threads. Make.com eliminates that overhead by connecting your prospect sourcing, enrichment, email delivery, and CRM into a single automated pipeline — no engineering required.

This guide builds a complete make.com sales automation scenario: Apify scrapes target company websites → Make enriches with data → Claude writes personalized cold emails → Gmail delivers multi-step sequences → incoming replies are routed to your CRM with AI-generated summaries.

Why Make.com wins for outbound sales automation

Most no-code automation tools treat data as static: trigger event → send one action. That model breaks immediately when you need conditional branching (replied vs. no reply), multi-step sequences with delays, or parallel enrichment from multiple APIs.

Make.com's visual scenario builder handles all of this natively. Each module in a scenario is a discrete action — HTTP request, data transform, AI prompt, CRM write — and modules connect visually with routers, filters, and iterators. The canvas reads like a flowchart of your sales process.

Three features make it the right choice for outbound pipelines:

Feature	Why it matters for sales
Multi-step sequences with delays	Send follow-up #2 exactly 3 days after follow-up #1, with no cron jobs
Router + filter branching	Route replied leads to one CRM path, unresponsive to another
3,000+ app connectors	Native modules for Gmail, HubSpot, Salesforce, Pipedrive, Airtable

Where Make.com isn't the best fit: If your team needs deep SDR-specific workflows with built-in deliverability tooling, dedicated sales engagement platforms like Apollo or Outreach are purpose-built. Make.com excels when you want a custom pipeline that crosses multiple tools your team already uses.

The full pipeline architecture

Here's what the complete outbound automation scenario looks like end-to-end:

[Schedule trigger]
       ↓
[Apify: scrape target companies]
       ↓
[HTTP: enrich with LinkedIn/Clearbit]
       ↓
[Claude/OpenAI: write personalized cold email]
       ↓
[Gmail: send email + schedule follow-ups]
       ↓
[Gmail: watch for replies]
       ↓
[Router: replied vs. no reply]
  ↓               ↓
[HubSpot:     [Gmail:
 create deal]  follow-up #2]

Each stage maps to one or more Make modules. Let's build each one.

Stage 1: Prospect sourcing with Apify

The first bottleneck in any outbound pipeline is list building. Buying lead lists gives you stale data. Manual research doesn't scale. The right approach is targeted scraping of public business directories — Google Maps, LinkedIn company pages, industry databases — directly into your pipeline.

Apify provides pre-built scrapers (called Actors) that run serverlessly and output clean JSON datasets. You trigger them directly from Make via the Apify module (available in Make's app library).

Setting up the Apify module in Make

1. In your Make scenario, add the Apify > Run an Actor module
2. Connect your Apify API token (from Apify Console → Settings → Integrations)
3. Select the Actor: apify/google-maps-scraper for local businesses, or curious_coder/linkedin-company-scraper for B2B targets
4. Pass input as JSON:

{
  "searchStringsArray": ["software companies in Austin TX"],
  "maxCrawledPlaces": 100,
  "language": "en"
}

5. Add a Apify > Get Dataset Items module after the run completes — this retrieves all scraped records as an array.

The output is a JSON array of company objects with fields like name, website, phone, address, and categories. Each item feeds into the next enrichment stage.

For more on the available Actors and how to connect them, see the Apify + Make.com integration guide.

Stage 2: Lead enrichment

Raw scraped data gives you company names and websites. A cold email that converts requires more: the right contact name, their role, a recent company trigger (new funding, job posting, product launch). Enrichment closes that gap.

Without enrichment, your email prompt has almost no signal to work with. With it, you can reference a prospect's industry, company size, recent news, or job openings — the difference between a generic blast and a message that feels researched.

Option A: Clearbit Enrichment via HTTP module

Use Make's HTTP > Make a request module to call Clearbit's enrichment API:

Method: GET
URL: https://company.clearbit.com/v2/companies/find?domain={{company.website}}
Headers:
  Authorization: Bearer {{clearbit_api_key}}

Map the response fields (name, metrics.employees, category.industry) to variables you'll use in the email prompt. Clearbit also returns tags (an array of technology categories) and description — both useful as personalization anchors.

Handle API errors gracefully: Add Make's Error Handler around the Clearbit module. When Clearbit can't find a domain (returns 404), route the lead to a fallback branch that attempts enrichment via a second source rather than dropping it entirely.

Option B: LinkedIn data from Apify

For B2B targeting, add a second Apify Actor call using curious_coder/linkedin-company-scraper with the company website as input. This returns employee headcount, recent posts, and company description — high-signal inputs for personalization.

Set the module to run only when Clearbit returns empty results, using a Make Router with a condition: {{clearbitResult.name}} is empty. This keeps your operations count low by only running the fallback when needed.

Option C: Manual job posting signal

A lightweight alternative: use Apify's apify/web-scraper to check the target company's careers page for open sales or growth roles. A company actively hiring SDRs is almost certainly scaling revenue — a strong buying signal. Include this in your prompt as {{hiringSignal}}.

The best Apify Actors for lead generation lists tested scraper options by use case if you want to compare alternatives.

Stage 3: AI-generated personalized emails

Generic cold emails get deleted. Personalized ones — referencing a specific funding round, a recent LinkedIn post, or an industry-specific pain point — get replies. Writing them manually at scale is impossible.

Make's OpenAI / Claude module solves this. Add the module after your enrichment step and pass a structured prompt:

You are a cold email copywriter for a B2B SaaS company.

Write a 3-sentence cold email to {{contact.firstName}} at {{company.name}}.

Context:
- Company industry: {{company.industry}}
- Company size: {{company.employees}} employees
- Recent signal: {{company.recentNews}}
- Our product: [Your product one-liner]

Requirements:
- Subject line under 50 characters
- Body: 3 sentences max
- End with a single low-friction CTA (15-minute call)
- No buzzwords, no "I hope this finds you well"

Return JSON:
{
  "subject": "...",
  "body": "..."
}

Map {{company.name}}, {{contact.firstName}}, and other enrichment fields directly from the previous modules. Make's variable system handles the substitution automatically.

Important: Always parse the JSON output using Make's JSON > Parse JSON module before mapping fields to the Gmail module. Passing raw text to an email sender breaks if the AI returns slightly different formatting.

Stage 4: Gmail multi-step sequences

Single emails don't convert. A typical outbound sequence is:

• Day 0: Initial cold email
• Day 3: Follow-up #1 (reference the first email, add one new value point)
• Day 7: Follow-up #2 (final ask — a quick no is fine)

Make handles this with scheduled triggers and data stores to track sequence state. The critical insight: never hard-code email content for follow-ups. Each follow-up should reference that no reply was received and escalate value. Use your AI module again for each follow-up, passing sequenceStage as context so the prompt can adjust tone accordingly.

Building the initial send

Add the Gmail > Send an Email module:

• To: {{contact.email}}
• Subject: {{aiOutput.subject}}
• Content: {{aiOutput.body}}
• Thread ID: Leave blank for new thread; capture the returned threadId for follow-ups

After sending, write the lead to a Make Data Store with fields:

• email, companyName, threadId, sequenceStage (set to 1), lastContactedAt

Set the Data Store record to expire after 30 days. Any lead that hasn't replied in 30 days exits the sequence automatically — you don't want infinite follow-up loops clogging your pipeline or damaging deliverability.

Scheduling follow-ups

Create a second scenario triggered by Schedule (every 24 hours):

1. Make Data Store > Search Records: Filter sequenceStage = 1 AND lastContactedAt < 3 days ago
2. Gmail > Get Email Thread: Check if a reply exists in the thread
3. Router:
   • If reply found → update sequenceStage = replied, route to CRM
   • If no reply → send follow-up #1, update lastContactedAt

Repeat the same logic for follow-up #2 using sequenceStage = 2.

Important on email deliverability: Sending 500 cold emails through a single Gmail account will trigger Google's spam filters. Use Google Workspace with proper SPF/DKIM configured, limit to 100 sends per day from one address, and add the Sleep module between sends (5-second minimum). If you need volume above that threshold, route sends through multiple Gmail accounts using Make's Iterator module to distribute the load.

Stage 5: Reply routing and CRM integration

When a prospect replies, you need two things to happen immediately: create a deal in your CRM and give the rep context before they respond. Timing matters — a reply that sits unrouted for 6 hours loses 40% of its conversion potential (the lead has already moved on mentally).

Detecting replies with Gmail Watch

Add a Gmail > Watch Emails module as a trigger in a separate scenario. Filter by is:reply in your sent email label. When triggered, it fires for every new reply.

Make the trigger check every 15 minutes (Make's minimum polling interval on paid plans). For true real-time routing, set up a Gmail push notification via Google Cloud Pub/Sub and use a Make webhook as the receiver — this gets reply latency under 30 seconds.

Claude-generated reply summary

Before creating the CRM record, add an AI summarization step:

Summarize this email reply in 2 sentences for a sales rep.
Focus on: expressed interest level, objections raised, next step requested.

Email content: {{email.body}}

This gives reps context before they open HubSpot. It also populates the deal description automatically, which cuts CRM data entry time per rep from ~8 minutes to zero.

HubSpot deal creation

Add the HubSpot > Create a Deal module:

• Deal Name: {{company.name}} — Inbound Reply
• Deal Stage: Appointment Scheduled
• Associated Contact: Create or find via email
• Description: {{claudeSummary}}

For Salesforce users, substitute the Salesforce > Create a Record module — the pattern is identical. Make also has native modules for Pipedrive, Close.io, and Copper if those are your CRM of choice.

Slack notification for hot leads

Add a Slack > Create a Message module after CRM creation, targeting your #sales-hot-leads channel. The message can include the company name, reply snippet, and a direct link to the HubSpot deal. This turns reply routing from a background automation into an active signal your team responds to immediately.

Measuring pipeline performance

Once your pipeline is live, you need to track what's working. Make's scenario execution logs show success/failure per run, but they don't give you sales funnel metrics. Instrument your Data Store from the start to capture the signals you'll need.

Add these fields to every lead record:

• sourceActor — which Apify scraper generated this lead
• enrichmentQuality — a 1–3 score based on how many fields returned non-empty
• emailSentAt, followUp1SentAt, followUp2SentAt
• repliedAt, dealCreatedAt

Once you have 200+ leads through the pipeline, pull the Data Store into a Google Sheet using Make's Google Sheets > Add a Row module (add this step after every status update). Then build a simple Looker Studio dashboard to visualize:

• Reply rate by lead source
• Time-to-reply by follow-up stage
• Drop-off between follow-up #1 and follow-up #2

This data tells you where to invest optimization effort. If follow-up #1 has a 4% reply rate but follow-up #2 drops to 0.5%, your day-7 email needs a rewrite — not your scraping strategy.

Make bills on operations — each module execution in a scenario counts as one operation. A single lead flowing through a 10-module pipeline consumes 10 operations.

Plan	Operations/month	Monthly price	Best for
Free	1,000	$0	Testing only
Core	10,000	$10.59	Solopreneurs
Pro	10,000+	$18.82	Small sales teams
Teams	10,000+	$34.12	Sales teams with shared workflows
Enterprise	Custom	Custom	Large orgs, SSO, audit logs

A pipeline processing 500 leads/month through 12 modules = 6,000 operations. The Pro plan handles this comfortably. Prices above are as of March 2026 — check Make.com pricing directly for current rates before committing to a plan.

Apify costs: Running Google Maps Scraper for 500 companies ≈ $1–2 on the Pay-As-You-Go plan. Apify's free tier includes $5/month in credits — enough to prototype the full pipeline at no cost.

Pricing verified June 2026. Plans change frequently — check the vendor’s official pricing page for current rates.

Make.com vs. alternatives for sales automation

Tool	Visual builder	Sales-specific features	Price for 10k ops/month
Make.com	✅ Yes	Moderate (via connectors)	~$10–19
Zapier	Limited	Moderate	~$20–49
n8n (self-hosted)	✅ Yes	Moderate	Free (hosting costs)
Apollo.io	❌ No	High (built-in sequences)	~$49/user
Outreach	❌ No	Very high	~$100/user

Make.com's edge over Zapier: multi-step branching, error handling, and significantly cheaper per-operation pricing. n8n is cheaper but requires self-hosting and technical setup. If you purely need sales sequences without data integration complexity, Apollo is purpose-built and worth considering.

Common errors and fixes

Error	Cause	Fix
Actor run timed out	Long-running Apify scrape	Increase timeout in Make's HTTP module or use async run + webhook callback
Gmail rate limit	Sending too many emails too fast	Add a Sleep module between emails (2–5 second delay)
JSON parse failed	AI returned non-JSON text	Add JSON.parse error handling or use a stricter prompt with respond only in JSON
HubSpot contact not found	Email not in CRM	Add a Create Contact step before Create Deal with error handling
Data store record missing	Race condition on sequence check	Use Make's Lock module to prevent concurrent writes

FAQ

Can Make.com automate sales?

Yes. Make.com connects to CRMs (HubSpot, Salesforce, Pipedrive), email providers (Gmail, Outlook), AI models (OpenAI, Claude), and data enrichment tools. You can automate prospect sourcing, personalized email generation, multi-step follow-up sequences, reply detection, and CRM deal creation — all without code.

How do I build an outbound pipeline with Make.com?

Start with a Schedule trigger → Apify Actor for lead sourcing → HTTP/enrichment API → AI email generation → Gmail send → Data Store for sequence tracking → scheduled follow-up checks → reply detection → CRM write. Each step maps to one or more Make modules connected visually on the scenario canvas.

Is no-code sales automation actually effective?

Yes, with caveats. No-code pipelines built in Make.com handle data volume and timing reliably. The personalization quality depends entirely on your enrichment data and prompt quality — garbage in, garbage out. Start with 50 leads, measure reply rates, iterate on the prompt, then scale.

What's the difference between Make.com and Zapier for sales?

Make.com supports complex multi-step branching, loops, error handling, and significantly cheaper operations pricing. Zapier is simpler to set up for basic two-step automations. For outbound sales pipelines with conditional logic (replied vs. not replied, enriched vs. failed), Make.com is the better choice.

Does Make.com integrate with Salesforce?

Yes. Make.com has a native Salesforce module with actions for creating records, updating contacts, searching leads, and triggering on new/updated records. You can build fully automated lead creation, deal staging, and activity logging without any Apex code.

---

Build your first pipeline: Start free on Make.com — the free tier includes 1,000 operations/month to test the full pipeline. Pair it with Apify's free tier ($5 in monthly credits) to source leads at zero upfront cost.