Resources · Make integration

Apify Make integrationAutomate Apify with Make.

Your Apify runs finish, and then nothing happens. The Apify Make integration wakes up the second an actor or a task is done, pulls the data it produced and passes it on. 7 building blocks, no code, and a first automation you can build today.

Try the Apify integration on MakeSee the 7 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Apify Make integration actually do?

The Apify Make integration lets Make drive your Apify account: start an actor, wait for the run to finish, then read the rows it wrote. A scenario is the automation you build in Make, and a module is one brick of that scenario, one step tied to one app. Apify brings 7 of those bricks, and 2 of them are triggers that start everything else.

Scraping that reports itself. A retail team launches a price actor by hand, then copies the rows into a sheet. Watch Actor Runs fires when the run ends, Get Dataset Items reads what came out, and the module you add next drops it where the team already looks.

Scraping on demand. A form comes in with the URL of a company. Scrape Single URL returns that page as text, markdown and HTML, ready to feed an AI step. No actor to pick, no dataset to chase.

Apify started from somewhere else. Run an Actor and Run a Task flip the direction: another app gives the signal, a new row, a ticket opened, and the scraper goes to work. Watch Task Runs closes the loop when the job comes back.

What Make will not do here is write your actors. Apify stays the place where scrapers are built and tuned, Make only calls them and moves what comes out. The Apify documentation lists no numeric limit on these modules, so the only counter worth watching is operations, one operation being one module running on one item. Make pricing has the detail.

The same app exists on the other side: there is an Apify n8n integration too, and n8n vs Make lays out the criteria without crowning a winner.

Connect

How do you connect Apify to Make?

  1. 01

    Create the token in Apify

    Log in to Apify and open Settings > Integrations. Click + Add token, give the token a name in the Add authentication token popup, then click Save. The name is only for you, so pick one you will still recognize in six months.

  2. 02

    Copy the value

    Click the Copy button next to the token you just created. That string is the key Make will use for every Apify module, so keep it on the clipboard while you switch tabs, and keep it out of any shared document.

  3. 03

    Paste it into Make

    In Make, add any Apify module and open its Create a connection dialog. Paste the value into the API token field and click Save. A connection is your Apify account linked to Make once, and every other Apify module reuses it.

First scenario

Your first scenario: the actor tells Make it is done

GoalWhen an actor finishes a run in Apify, Make reads the data it produced and passes it on.

  1. 01

    Create the scenario

    From the Scenarios page in Make, create a new scenario and click the + to place the first module. Search Apify by name and pick Watch Actor Runs.

  2. 02

    Point it at one actor

    Open the module, create or select your connection, then choose the actor Make should follow. Nothing else to set here: the trigger is instant, so Apify calls Make as soon as the run ends.

  3. 03

    Add the module that reads the results

    Click the + on the right of the trigger and add Get Dataset Items. Map the value coming out of the trigger so the second module reads the run that just finished.

  4. 04

    Test it with Run once

    Click Run once, then start a run in Apify. Make executes the scenario one time and shows the bundles each module received, one bundle being one item that came through.

  5. 05

    Switch it on

    Add whatever module should receive the data, then turn the scenario on. No interval to choose here: the trigger is instant, and Apify calls Make through a webhook, a URL an app calls to say something happened.

Triggers

What starts a scenario

2 modules start a scenario when something happens in Apify. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Apify as soon as it happens.

Apify1Watch Actor Runs

Watch Actor Runs

Instant trigger

In Make“Triggers whenever a selected Actor is run and finished.”

Watch Actor Runs sits on one actor and starts your scenario the moment a run of that actor finishes. What lands in Make is a finished run, so everything after it works on results and not on a job still in progress.

How it fires
instant, the app calls Make through a webhook as soon as it happens, so there is no interval to set on this module.
When to use it
the scraper is launched from Apify itself and you want its output to travel on without anyone watching a screen.
Watch out
it listens to the actor you select, so a second scraper needs a trigger of its own.
Apify2Watch Task Runs

Watch Task Runs

Instant trigger

In Make“Triggers whenever a selected task is run and finished.”

An Apify task just came back? Watch Task Runs wakes the scenario at that exact point, for the task you pointed it at. It is the natural partner of Run a Task: one scenario asks for the work, this one handles what returns.

How it fires
instant, the app calls Make through a webhook as soon as it happens, with no polling of Apify from the Make side.
When to use it
an agency keeps its recurring scrapes as tasks and wants every finished run handled without anyone opening the console.
Watch out
the scenario has to be switched on for the Apify call to land; while it is off, nothing is caught up later.
Modules

What Apify can do inside a scenario

Apify gives you 5 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Apify1

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

The list of ready-made modules stops somewhere, and Make an API Call is where it keeps going: an authorized request to any endpoint of the Apify API, on the connection you already created.

When to use it
what you need exists in Apify but has no module of its own.
Watch out
you write the request yourself, so this one is for someone comfortable with the Apify API, not for a first scenario.
Apify2

Run an Actor

Action

In Make“Run a selected Actor.”

Run an Actor launches a scraper you picked from inside the scenario, on the item that just arrived. The run starts in your Apify account exactly as if you had clicked it there yourself.

When to use it
a new lead reaches the CRM and you want its website scraped before a human opens the record.
Watch out
starting a run and holding its results are two different things; Watch Actor Runs is what tells you the job came back.
Apify3

Run a Task

Action

In Make“Runs a selected Actor task.”

Same move, different object: Run a Task triggers the task you selected and Apify takes it from there. Choosing between the two comes down to how your Apify account is organized.

When to use it
the scrape is already set up on the Apify side and Make only has to give the go-ahead.
Watch out
what the task goes after is defined in Apify, so changing the target happens there, not in this module.
Apify4

Scrape Single URL

Action

In Make“Runs a scraper for the website and returns its content as text, markdown and HTML. This action is made for getting content of a single page, for example, to use in large language models (LLM) flows.”

One address in, readable content out. Scrape Single URL skips the actor step: it runs a scraper on the page you give it and returns the content as text, markdown and HTML. Apify presents it as the module for feeding a single page into a language model flow.

When to use it
someone drops a company URL in a form and the scenario needs that page in plain text before an AI step.
Watch out
one page per call, a whole site is still a job for an actor.
Apify5

Get Dataset Items

Search

In Make“Fetches items from a dataset.”

This is where the scraped rows actually arrive. Get Dataset Items points at a dataset and pulls the items out, one bundle per item, ready for whatever module comes next.

When to use it
right behind Watch Actor Runs, to turn a finished run into rows your team can use.
Watch out
this is a search module, so it can come back with nothing, with one item or with many; plan for the empty case instead of assuming rows are always there.
Need help

Need help automating Apify with Make?

A person reads every message.

FAQ

Questions people ask next

01Is the Apify Make integration free?
Yes. Apify is a standard app in Make, which means it is there from the Free plan with nothing extra to buy. What the Free plan limits is the running, not the app: 2 active scenarios, a 15-minute minimum gap between two scheduled runs, 5 minutes of execution, files up to 5 MB and 512 MB of transfer. Paid plans bring the gap down to 1 minute, lift the cap on active scenarios and stretch execution to 40 minutes. Usage is counted in credits per month, and one credit is one operation, meaning one module running on one item.
02What do you need to connect Apify to Make?
An Apify account and an API token, nothing else. The documentation asks for no other prerequisite. You generate the token in Apify under Settings > Integrations with + Add token, name it in the Add authentication token popup, save it, then click Copy. On the Make side you open the Create a connection dialog of any Apify module, paste the value into the API token field and save. That connection is your Apify account linked to Make once, and every Apify module you add afterwards reuses it without asking again.
03Does the Apify trigger react in real time?
Yes. Both Apify triggers are instant ones: the app calls Make through a webhook as soon as a run finishes. There is no interval to configure and no wait, unlike a scheduled trigger where Make would go and look at a fixed rhythm. Watch Actor Runs covers runs of an actor you select, Watch Task Runs covers runs of a task. The one condition is that the scenario is switched on; while it is off, the call from Apify lands nowhere.
04What if the module you need is missing?
Use Make an API Call. Apify ships that module too, and it sends an authorized request to any endpoint of the Apify API with the connection you already created. Whatever the ready-made modules leave out goes through there. The trade-off is that you build the request yourself, so keep it for the cases that genuinely need it. On limits, the Apify documentation attached to these modules publishes none, so there is no documented ceiling to design around. What you do have to count is Make operations, one per module and per item handled.
05Make or n8n for Apify?
It depends on what your team already runs. Apify exists on both sides, so coverage is not what decides it. Make gives you a visual editor, one connection created once and reused by every module, and a plan that counts operations. n8n makes sense if your team already works there. The honest answer is that the right tool is the one your colleagues will actually open, and the comparison linked above walks through the criteria one by one.
Hack'celeration Lab

Get our weekly automation tips.

No spam. Unsubscribe anytime.

Same platform

Other docs you might need on this stack.

Browse all integrations