Automating Workflows with Apify and Make.com

Contains affiliate links. Disclosure.

Apify runs the scraper; Make.com routes the dataset into Sheets, CRMs, Slack, Airtable, or anywhere else with an HTTP module. This guide covers the native Apify modules, sync vs. async run patterns, and four worked workflows. Steps match the official Apify Make integration guide as of May 2026.

3-step Make.com integration flow

1. Trigger an Actor run (manual, schedule, or webhook).
2. Fetch results from the Actor’s dataset.
3. Deliver data to Sheets, CRM, Slack, or Airtable.

Create a free Make.com account →

Two Integration Patterns: Sync vs Async

Make supports two primary ways to run Apify Actors:

1. Synchronous (short runs): Run an Actor with “Run synchronously: Yes” → Get Dataset Items → destination. Use this for fast Actors. Make enforces a hard timeout on synchronous runs, so long-running scrapers should avoid this path.
2. Asynchronous (recommended for long runs): Watch Actor Runs (webhook trigger) → Get Dataset Items → destination. This is the most reliable option for long or variable-duration scrapes.

Prerequisites

• An Apify account (free plan is sufficient).
• A Make.com account (free plan is sufficient).
• A destination account (Google, HubSpot, Slack, Airtable, etc.).
• An Apify API token or OAuth connection (manage tokens at Settings → API & Integrations).

Apify Modules in Make (Quick Reference)

Triggers

• Watch Actor Runs
• Watch Task Runs

Actions

• Run an Actor
• Run a Task
• Scrape Single URL
• Make an API Call

Searches

• Get Dataset Items

Method 1: Synchronous (Short Runs)

Use this when your Actor completes quickly and you need results in a single Make execution:

1. Add Apify → Run an Actor and set Run synchronously: Yes.
2. Add Apify → Get Dataset Items and map the dataset ID from the Run Actor output.
3. Send the data to your destination (Sheets, CRM, Slack, etc.).

If a run can exceed Make's synchronous timeout, switch to the asynchronous pattern below.

Workflow 1: Apify → Google Sheets (Starter Tutorial)

This is the classic asynchronous workflow. Automatically scrape data with an Apify Actor and save the results to a Google Sheet.

Step 1: Set Up Your Apify Actor and Google Sheet

1. Choose an Actor: For this guide, we'll use the Google Maps Scraper. Run it once manually to scrape a few results (e.g., "cafes in London"). This gives us some data to work with.
2. Create a Google Sheet: Create a new, empty Google Sheet. Add column headers that match the data you expect from your scraper (e.g., Title, Address, Website, Phone).

Step 2: Create a New Scenario in Make.com

In your Make.com dashboard, click "Create a new scenario."

Step 3: The Trigger (Apify)

1. Search for and select Apify as the trigger module.
2. Connect your Apify account (OAuth recommended) or paste an API token.
3. Choose the "Watch Actor Runs" trigger.
4. Create a Webhook: Click "Add" to create a new webhook. Make will give you a unique URL. Copy this URL.
5. Add the Webhook to Apify: In the Apify Console, go to the Google Maps Scraper Actor you want to monitor. Go to the "Integrations" tab and click "Add webhook". Paste the URL from Make.com. For the "Event," choose "Run succeeded".
6. Now, every time this Actor finishes a run successfully, it will send a notification to your Make.com scenario.

What you'll see in Make

The Apify trigger module configuration shows a "Watch Actor Runs" event type and a Webhook section. Click "Add" to generate a unique webhook URL. Copy this URL and paste it into the Apify Console under your Actor's Integrations tab → Add webhook → set the event to "Run succeeded."

Step 4: The Action (Apify - Get Dataset Items)

The trigger only tells us that a run finished; it doesn't give us the data. We need another module to get the results.

1. Add another module to your scenario. Search for and select Apify.
2. Choose the "Get Dataset Items" action.
3. Configure the Module:
   • Dataset ID: Map the Dataset ID field from the Apify trigger module. This dynamically tells the module which dataset to read from.
   • Limit: Set a limit for how many results to retrieve (e.g., 1000).

Step 5: The Final Action (Google Sheets)

1. Add a final module to your scenario. Search for and select Google Sheets.
2. Choose the "Bulk Add Rows" action.
3. Configure the Module:
   • Connect your Google account.
   • Select the Spreadsheet and Sheet you created in Step 1.
   • Map the Fields: For each column in your Google Sheet, map the corresponding field from the Apify "Get Dataset Items" module. For example:
     • Title column → title field from Apify
     • Address column → address field from Apify
     • Website column → website field from Apify

What you'll see in Make

The Google Sheets "Bulk Add Rows" module shows a field mapping interface. Each column from your spreadsheet appears as a labeled field (e.g., "Title," "Address," "Website"), and you drag or select the corresponding data fields from the Apify "Get Dataset Items" module output to map them.

Step 6: Test and Activate

Run your scenario once in Make to ensure everything is mapped correctly. If it works, save the scenario and turn it on.

Workflow 2: Apify → HubSpot CRM

Push scraped leads directly into your HubSpot CRM as new contacts.

Setup

1. Trigger: Same Apify webhook trigger as above.
2. Fetch: Apify "Get Dataset Items" module.
3. Action: Add a HubSpot module → "Create a Contact."
4. Map Fields:
   • First Name → parse from the title field
   • Company → title field from Apify
   • Website → website field from Apify
   • Phone → phone field from Apify

Deduplication

Add a Router module before HubSpot to check if a contact already exists (search by email or website). This prevents duplicate entries in your CRM.

Workflow 3: Apify → Slack Notifications

Get real-time Slack alerts when your scrapers find interesting data.

Setup

1. Trigger: Apify webhook trigger.
2. Fetch: Apify "Get Dataset Items" module.
3. Filter: Add a Filter module to only pass items that meet your criteria (e.g., businesses with 4.5+ star rating).
4. Action: Add a Slack module → "Send a Message."
5. Message Template:

    New Lead Found!
   Name: {{title}}
   Website: {{website}}
   Rating: {{stars}} ⭐
   Phone: {{phone}}

Workflow 4: Apify → Airtable

Airtable is popular for teams that need a more structured database than Google Sheets.

Setup

1. Trigger: Apify webhook trigger.
2. Fetch: Apify "Get Dataset Items" module.
3. Action: Add an Airtable module → "Create a Record."
4. Map Fields: Map Apify fields to your Airtable columns.

Advantage over Google Sheets: Airtable supports linked records, attachments, and relational data, which suits complex lead management workflows.

Troubleshooting

Common Issues and Solutions

Issue	Cause	Solution
Synchronous run stops early	Make enforces a hard timeout on sync runs	Use the asynchronous Watch Actor Runs trigger or start the run outside Make and fetch results later.
Scenario times out	Large datasets cause Make.com to exceed its execution time limit	Reduce the limit on the "Get Dataset Items" module (e.g., 500). Split into multiple runs if needed.
Webhook not triggering	Incorrect URL or disabled webhook	Double-check the webhook URL in both Apify and Make.com. Ensure the Apify webhook event is "Run succeeded."
"Too many operations" error	Make.com free plan has a 1,000 operations/month limit	Each row processed counts as multiple operations. Upgrade your Make plan or reduce scraping frequency.
Duplicate records	Scenario runs multiple times for the same data	Add a deduplication step using a Router or Filter module to check for existing records before creating new ones.
Field mapping errors	Apify dataset field names don't match expectations	Run the Actor once and inspect the raw JSON output in Apify Console to see exact field names.

Debugging Tips

1. Use Make's "Run once" button: Test each module individually before activating the full scenario.
2. Check the Apify Console: Verify that the Actor run actually succeeded and the dataset contains data.
3. Enable error handling: In Make, add an Error Handler module to catch and log failures instead of stopping the entire scenario.

Cost Considerations

Running Apify + Make.com involves costs from both platforms:

Component	Free Tier	Paid Tier
Apify	$5/month in credits	From $29/month (Starter plan)
Make.com	See Make pricing	See Make pricing

Estimating total costs:

• Each Apify Actor run consumes platform credits based on Compute Units, and some Store Actors also have per-result or per-event pricing.
• Each Make.com scenario execution consumes operations. A simple 3-module scenario processing 100 items uses ~300 operations.
• For a weekly lead gen workflow processing 200 leads: ~$2-4/month Apify + ~800 Make operations/month (fits in free tier).

For detailed cost management tips, see our Apify Cost Optimization Guide.

Extend the pattern

The Apify → Make → destination pattern works for any Make-connected app: Mailchimp (email blasts on fresh scrape), Salesforce/HubSpot (lead creation), Notion/Monday (task rows), WordPress (auto-publish). Swap the last module; the Apify trigger + Get Dataset Items middle stays the same.

Looking for a More Powerful Alternative?

While Make.com is excellent for its simplicity, developers or users who need more power and control might prefer n8n.io, an open-source, self-hostable workflow automation tool. See our Apify & n8n.io Integration tutorial to learn more.

Frequently Asked Questions

You can automate any workflow that starts with web data: scrape Google Maps leads and push them to your CRM, monitor competitor prices and send Slack alerts on changes, extract social media data and update Google Sheets, or scrape product listings and sync them to your e-commerce platform.

No. Both Apify and Make.com are designed for no-code use. You configure Apify Actors with input forms and connect them to Make.com scenarios using a visual drag-and-drop interface. No programming knowledge is required.

Make.com and Apify are billed separately. Make.com charges based on the number of operations (steps) in your workflows, while Apify charges based on Compute Units consumed (plus any Actor-specific pricing in the Store). Check Make's current pricing for exact operation limits.

Use synchronous runs for short Actors when you want results in a single Make execution. For longer or variable-duration scrapes, use the asynchronous Watch Actor Runs trigger to avoid timeouts.

Add an Apify module in Make and authenticate via OAuth or an API token from Apify Console → Settings → API & Integrations. Then choose a trigger or action such as Run an Actor or Watch Actor Runs.