How to Use Make.com and Apify Together to Automate Any Data Workflow
Key Takeaways
How does the Apify Make.com integration work? Make.com has a native Apify module that connects via OAuth or API token. The module provides two triggers (Watch Actor Runs, Watch Task Runs), three actions (Run an Actor, Run a Task, Scrape Single URL), and one search module (Get Dataset Items). You build scenarios by chaining these modules with any of Make's 3,000+ app connectors.
What is the best way to handle long-running Apify Actors in Make.com? Use the asynchronous pattern. The "Watch Actor Runs" trigger listens for a webhook from Apify when an Actor finishes, then fetches results via Get Dataset Items. The synchronous "Run an Actor" action has a hard timeout enforced by Make, so it only works reliably for Actors that complete in under 40 seconds.
What real workflows can you automate with Apify and Make.com? Common pipelines include SEC insider trade alerts to Slack using the SEC Insider Scraper, Polymarket price monitoring to Google Sheets with the Polymarket Market Scraper, YC startup job feeds to Airtable via the YC Jobs Scraper, and local business lead generation to HubSpot through the Yandex Maps Scraper.
The Gap Between Scraping and Doing Something with the Data
Most data collection projects stall at the same point. The scraper runs, the dataset fills up, and then the data sits in a JSON file or Apify console while someone manually copies rows into a spreadsheet. The collection is automated. Everything after it is not.
Make.com (formerly Integromat) closes that gap. It connects to Apify through a native module, watches for completed scraping runs, and routes the structured output to wherever it needs to go: Google Sheets for analysis, Slack for alerts, HubSpot for lead enrichment, Airtable for team dashboards. No backend code, no webhook plumbing, no cron jobs.
Why Make.com and Apify Fit Together
Apify is a web scraping platform that runs pre-built scraping tools called Actors. Each Actor handles a specific data source, from Polymarket prediction markets to Dutch real estate listings on Funda.nl. Actors return structured JSON datasets. Make.com is a visual automation platform that connects apps, transforms data, and triggers actions based on events.
The Apify module in Make.com provides five components:
| Module Type | Module Name | What It Does |
|---|---|---|
| Trigger | Watch Actor Runs | Fires when a selected Actor run completes |
| Trigger | Watch Task Runs | Fires when a saved Actor Task completes |
| Action | Run an Actor | Starts an Actor with optional input overrides |
| Action | Run a Task | Starts a saved Actor Task |
| Search | Get Dataset Items | Retrieves output data from an Actor run's dataset |
To connect the two platforms, you add an Apify connection in Make using either OAuth (recommended) or an API token from your Apify account settings.
Synchronous vs Asynchronous Execution
The Apify Make.com integration supports two execution patterns, and choosing the wrong one is the most common source of failed scenarios.
Synchronous execution uses the "Run an Actor" action with the "Run synchronously" option set to Yes. Make sends the request, waits for the Actor to finish, and returns the results in the same scenario step. This works for fast Actors that complete in under 40 seconds, but Make enforces a hard timeout on synchronous requests. If the Actor takes longer, the scenario fails.
Asynchronous execution uses the "Watch Actor Runs" trigger. You configure a webhook in Apify that fires when the Actor run succeeds, and Make listens for that webhook to start the scenario. Once triggered, a subsequent "Get Dataset Items" module fetches the results. This pattern works for any Actor regardless of run duration.
| Pattern | Best For | Timeout Risk | Setup Complexity |
|---|---|---|---|
| Synchronous | Fast Actors (under 40 seconds) | High | Low (single module) |
| Asynchronous | Any Actor, especially long runs | None | Medium (webhook + trigger) |
For most production workflows, the asynchronous pattern is the right choice. Scraping runs vary in duration depending on the number of results, network conditions, and target site response times. A synchronous setup that works during testing with 10 results will break in production when the Actor processes 500.
How do you set up the asynchronous webhook between Apify and Make.com? In Make, add a "Watch Actor Runs" trigger module and create a new webhook. Make generates a unique URL. In the Apify Console, go to your Actor's Integrations tab, add a webhook, select the "Run succeeded" event type, and paste the Make webhook URL. Every time the Actor completes a run, Apify sends a POST request to Make with the run metadata, and Make starts the scenario.
Four Workflows You Can Build Today
These are real automation patterns built with ParseBird Actors and Make.com. Each follows the same structure: an Apify Actor collects data, Make processes and filters it, and the results land in a destination app.
SEC Insider Trade Alerts
The SEC Insider Scraper pulls real-time Form 4 insider transaction data from Dataroma. Pipe this into Make with a filter that only passes transactions above a dollar threshold, and route matching trades to a Slack channel.
Apify: SEC Insider Scraper (scheduled daily)
→ Make: Watch Actor Runs (trigger)
→ Make: Get Dataset Items
→ Make: Iterator (loop through each trade)
→ Make: Filter (transactionAmount > 1000000 AND type = "Buy")
→ Slack: Post Message (#insider-trades channel)Polymarket Monitoring Dashboard
The Polymarket Market Scraper extracts prediction market data including prices, volume, and liquidity. Schedule it hourly in Apify, and use Make to append results to a Google Sheet that tracks price movements over time.
Apify: Polymarket Market Scraper (scheduled hourly)
→ Make: Watch Actor Runs (trigger)
→ Make: Get Dataset Items
→ Make: Iterator (loop through each market)
→ Google Sheets: Add Row (market name, yes price, no price, volume, timestamp)YC Startup Jobs Pipeline
The YC Jobs Scraper collects job listings from Y Combinator companies with salary data, equity details, and visa sponsorship status. Filter by role type and push matching jobs to an Airtable base or CRM for your recruiting pipeline.
Apify: YC Jobs Scraper (scheduled daily)
→ Make: Watch Actor Runs (trigger)
→ Make: Get Dataset Items
→ Make: Iterator (loop through each job)
→ Make: Filter (role contains "Engineer" AND salary_min > 150000)
→ Airtable: Create Record (Jobs base)Yandex Maps Lead Generation
The Yandex Maps Scraper extracts business data including phone numbers, emails, addresses, ratings, and working hours for any city in Russia, Turkey, Kazakhstan, and CIS countries. Route new business leads directly into HubSpot or any CRM.
Apify: Yandex Maps Scraper (search: "restaurants" in Istanbul)
→ Make: Watch Actor Runs (trigger)
→ Make: Get Dataset Items
→ Make: Iterator (loop through each business)
→ Make: Filter (rating >= 4.0 AND phone != null)
→ HubSpot: Create Contact (name, phone, email, address)Setting Up Your First Apify-Make Scenario Step by Step
Here is the complete setup process for the asynchronous pattern, which works with any Apify Actor.
Step 1: Create the Apify connection in Make. Open Make.com, create a new scenario, and add the Apify "Watch Actor Runs" module. Click "Create a connection" and authenticate with OAuth or paste your Apify API token.
Step 2: Create the webhook. In the Watch Actor Runs module, click "Add" next to the webhook field. Make generates a unique webhook URL. Copy this URL.
Step 3: Register the webhook in Apify. Go to the Apify Console, open the Actor you want to automate, navigate to the Integrations tab, and click "Add webhook." Set the event type to "Run succeeded" and paste the Make webhook URL.
Step 4: Add the Get Dataset Items module. After the trigger, add an Apify "Get Dataset Items" module. Map the dataset ID from the trigger's output to retrieve the Actor's results.
Step 5: Add an Iterator. The Get Dataset Items module returns an array. Add a Make Iterator module to loop through each record individually, which allows downstream modules to process one record at a time.
Step 6: Add your destination. Connect any Make module as the final step: Google Sheets (Add Row), Slack (Post Message), Airtable (Create Record), HubSpot (Create Contact), or any of Make's 3,000+ app connectors.
Step 7: Test the scenario. Run the Actor manually in Apify. The webhook fires, Make processes the results, and data lands in your destination. Once verified, enable the scenario and set up a schedule in Apify using Apify Schedules.
Cost and Scaling Considerations
Both platforms use consumption-based pricing, so understanding the cost model prevents surprises at scale.
Make.com credits. Every module execution in a Make scenario costs one credit. A scenario with five modules (trigger, get dataset, iterator, filter, Google Sheets) processing 100 records uses approximately 400 credits per run. Make's free plan includes 1,000 credits per month. The Core plan starts at $9/month for 10,000 credits.
Apify pricing. Most ParseBird Actors use pay-per-event pricing, where you pay per result scraped. Platform compute and proxy costs are charged separately. A daily run of the SEC Insider Scraper returning 50 transactions costs a fraction of a cent per result.
Scheduling. You can trigger Actor runs from either platform. Apify Schedules support cron expressions with timezone awareness and can run Actors up to every minute. Make's built-in scheduler works too, but using Apify Schedules with the webhook trigger is more reliable for long-running Actors because it avoids Make's synchronous timeout.
| Cost Factor | Apify | Make.com |
|---|---|---|
| Pricing model | Pay per result + compute | Credits per module execution |
| Free tier | 5 free Actors/month | 1,000 credits/month |
| Scheduling | Cron with timezone support | Interval-based (every N minutes) |
| Scaling concern | Result volume | Module count x execution frequency |
From Raw Data to Automated Workflows
The combination of Apify for data collection and Make.com for data routing eliminates the manual work between scraping and action. Every Actor in the ParseBird collection produces structured JSON output that Make can process directly, with no data cleaning or format conversion required.
The pattern is always the same: schedule an Actor, watch for completion, iterate through results, filter what matters, and deliver it where your team works.
Related: The Agentic Stack and How Modern Automation Fits Together explains the three-layer architecture that Apify and Make.com plug into. How to Structure Web Scraped Data for AI Pipelines covers why structured JSON output matters for downstream consumption.