Skip to main content

Make.com + Apify: Automate Web Scraping Workflows Without Code

· 6 min read
Yassine El Haddad
Yassine El Haddad
Software Developer & Automation Specialist

I build production AI agents, web scrapers, and automation pipelines. Most of what I publish here comes from the actual problems they run into: proxies that get banned, anti-bot stacks that fingerprint your client, RAG that drifts when the underlying data moves. Stack: Python, TypeScript, Go, FastAPI, LangChain, Crawlee, Playwright, deployed on AWS, GCP, and Cloudflare.

Most teams can already scrape data. The bottleneck is getting the output into business workflows reliably. Make orchestrates Apify Actors: run on schedule, fetch datasets, transform records, and route to Sheets, CRM, or Slack. This guide covers setup, modules, run modes, and three complete pipelines you can copy.

What the integration supports​

Make's Apify modules include:

ModulePurpose
Run an ActorDirect actor invocation
Run a TaskPreconfigured, repeatable runs
Get Dataset ItemsFetch results after run
Watch Actor RunsEvent-driven trigger
Watch Task RunsEvent-driven trigger
Scrape Single URLQuick one-off extraction
Make an API CallCustom Apify API usage

Minimum viable pipeline​

  1. Trigger: schedule or upstream event
  2. Run Apify Actor/Task
  3. Wait for completion (or use Watch Runs trigger)
  4. Fetch dataset items
  5. Iterate + transform records
  6. Send to destination (Sheets, CRM, Slack, DB)

Step-by-step setup​

Step 1: Connect Apify in Make​

  • Add Apify module in a new scenario
  • Authenticate with Apify API token
  • Test with a simple Run Actor call (e.g., Web Scraper)

Step 2: Choose run mode​

ModeUse when
Run an ActorDirect invocation; dynamic inputs
Run a TaskRepeatable config; easier governance

For production, Tasks are often easier to manage.

Set the Actor ID in username~actor-name form, for example apify/google-maps-scraper, and pass input as JSON with upstream fields mapped straight in:

{
  "searchStringsArray": ["{{1.search_query}}"],
  "maxCrawledPlacesPerSearch": 50
}

Step 3: Sync vs async run modes​

Make applies a 40-second timeout per module. That limit is what decides which mode you need:

ModeBehaviourUse when
Sync (wait for finish)Make blocks until the Actor completesThe run reliably finishes inside 40 seconds
AsyncMake starts the Actor and returns a run ID immediatelyAnything longer, which covers most real scrapes

For async runs you need a completion signal. Two options:

Polling means adding a Wait module, then Check Actor Run, and looping until the status is SUCCEEDED. Pushing means letting Apify tell Make when it is done: in Apify Console, open your Actor, go to Settings then Webhooks, set the event to ACTOR.RUN.SUCCEEDED, and point the URL at your Make webhook. In Make, use Webhooks then Custom Webhook as the scenario trigger.

Pushing costs fewer operations than polling and reacts immediately, so prefer it for anything that runs longer than a couple of minutes.

Step 4: Retrieve results​

After run completion, use Get Dataset Items with the dataset ID from the previous module ({{run.defaultDatasetId}}).

  • Start with small output limits while testing
  • Validate schema before mapping to destinations

Step 5: Transform and route​

Use iterators and filters to:

  • Keep only required fields
  • Normalize text, date, price values
  • Split records by destination rules

Step 6: Deliver to business tools​

Common destinations:

  • Google Sheets for quick ops visibility
  • HubSpot or Salesforce for lead workflows
  • Slack for alerts
  • A database for downstream analytics

Pipeline 1: Google Maps leads → CRM​

[Schedule: Every Monday 9 AM]
  → [Apify: Run Google Maps Scraper]
  → [Iterator: Loop through each business]
  → [Filter: Exclude already-added leads]
  → [HubSpot: Create Contact]
  → [Slack: Notify sales team]
  1. Trigger: schedule it for Monday 9 AM
  2. Apify: Run an Actor: Google Maps Scraper, with input {"searchStringsArray": ["plumbers Chicago"], "maxCrawledPlacesPerSearch": 100}
  3. Iterator: splits the dataset array into individual items
  4. Filter: item.phone != null AND item.website != null
  5. HubSpot: Create/Update Contact: map {{item.title}}, {{item.phone}}, {{item.website}}, and google_maps_rating = {{item.totalScore}}
  6. Slack: Post message to #sales-leads

Pipeline 2: Price monitor → Slack alert​

[Schedule: Daily 8 AM]
  → [Apify: Run price monitor Actor]
  → [Iterator: Each product]
  → [Filter: price < previous_price * 0.95]
  → [Slack: Send price drop alert]

The filter condition is {{item.price}} < {{item.previous_price}} * 0.95, and the Slack message reads "Price drop: {{item.product}} is now ${{item.price}} (was ${{item.previous_price}}) at {{item.url}}".

Pipeline 3: Competitive research → Google Docs​

For a weekly intelligence digest:

[Schedule: Friday 5 PM]
  → [Apify: Run competitor website scraper]
  → [HTTP: Send content to Claude API]
  → [Google Docs: Append to weekly report]

The Claude step is a plain HTTP module:

{
  "model": "claude-sonnet-4-5",
  "messages": [{"role": "user", "content": "Summarize key product changes from this competitor page: {{content}}"}],
  "max_tokens": 500
}

Quality controls​

ControlPurpose
Duplicate checkBefore write modules
Required fieldsReject rows missing domain, contact, location
Confidence flagsFor enrichment outputs
Run metadataStore run_id, source actor, timestamp

What this costs in Make operations​

Each Actor run typically consumes 5–20 Make operations: the start call, any polling steps, and one operation per item processed downstream. Filtering before your write modules is the cheapest way to bring that number down, because a row rejected by a filter stops consuming operations in every module after it.

For current plan limits and credit maths, see the Make.com pricing guide.

Start your Make + Apify scenario.

Next step

Once your pipeline is stable, add one AI classification step for prioritization. Build in Make →

Apify Affiliate Banner 728x90Apify Affiliate Banner 728x90Apify Affiliate Banner 300x50Apify Affiliate Banner 300x50
Frequently Asked Questions

Yes. Use Run Actor or Run Task modules. Process results in the same scenario with Get Dataset Items and iterators.

Make applies a 40-second timeout per module, so a sync Run an Actor call fails on anything slower. Switch to async mode and either poll with a Wait plus Check Actor Run loop, or push completion to Make with an Apify ACTOR.RUN.SUCCEEDED webhook.

Use Get Dataset Items, then iterate and map only the fields your destination needs. Filter before heavy processing.

Typically 5–20: the start call, any polling steps, and one operation per item processed downstream. Filtering before your write modules is the biggest single saving.

Any Actor with dataset output. Popular: Google Maps, SERP, LinkedIn, e-commerce, job listings. Browse apify.com/store.

Related Guides
Firecrawl vs ApifyCompare data extraction options.n8n + Apify Integration GuideSame integrations using n8n instead of Make.

Common mistakes and fixes

Make's Apify module can't find my Actor.

Ensure you've entered the correct Actor ID in the format 'username~actor-name'. Find it in the Apify Console URL or Actor settings. The module lists public Actors in the dropdown but custom Actors need manual entry.

Make scenario times out waiting for the Apify Actor to complete.

Make.com has a 40-second timeout per module. For long-running Actors, use the 'Run an Actor' module in async mode and then poll with a 'Wait' + 'Check Actor Run' loop, or use Apify webhooks to push completion to Make.

Dataset items don't appear in the Make data inspector.

Run the scenario once manually with actual data to 'teach' Make the dataset structure. The first run always returns a structure sample, and subsequent runs map fields correctly.

The Actor runs but no rows reach the next module.

Verify the dataset reference is the one the run actually wrote to, and check the Actor's output structure, because an Actor that writes to a named dataset will not populate defaultDatasetId.

Mapping errors when writing to the destination.

Normalize the schema before the write module. Coerce types and fill missing keys with explicit nulls so every bundle presents the same shape.

Operation cost grows faster than expected.

Filter earlier. Every row a filter rejects stops consuming operations in every module after it, so moving a filter up one position compounds across the whole scenario.