Run an Apify Actor From n8n, Make or Zapier

If you want to run an Apify Actor from n8n, Make, or Zapier, the short version is: install the official connector, point it at the Actor slug, pass your input as JSON, and either wait for the run to finish inline or fire a webhook when it does. The whole setup takes about 10 minutes once you know which of those two patterns your workflow needs. Here’s both, with a working example against a live Actor.

Why wire a scraper into a no-code tool at all

Most teams that reach for n8n, Make, or Zapier already have the destination sorted — a Slack channel, a Google Sheet, a CRM field, an AI agent’s context window. What they’re missing is the step that gets fresh, structured data into that destination on a schedule, without someone manually running a script. An Apify Actor is that step: point it at a target, get back Pydantic-validated rows, and let your automation platform do the routing.

We’ll use Google Ads Transparency Scraper as the running example — it pulls a competitor’s live ad creatives by domain, which is a natural fit for a recurring “check what our competitors are running this week” workflow. The pattern below applies to any of our 202 live Actors; only the input fields change.

Option A — n8n

n8n ships an official Apify node (community package, install it from the n8n node panel).

1. Add the Apify node to your workflow canvas and connect it with your Apify API token (create one under Apify Console → Settings → Integrations).
2. Pick the operation. For a short run, use Run Actor synchronously and get dataset items — this maps to Apify’s run-sync-get-dataset-items endpoint and returns the rows directly into the next node, no polling required.
3. Set the Actor to DevilScrapes/google-ads-transparency and pass the input JSON:

{
  "advertiserDomain": "competitor.com",
  "maxAds": 100
}

4. Chain a downstream node — a Sheets append, a Slack message, or an AI-agent node that summarizes new creatives.
5. Add a Schedule Trigger upstream to run it daily or weekly.

Option B — Make

Make (formerly Integromat) has an Apify app with two modules that matter here: Run Actor and Get Dataset Items.

1. Add the Apify → Run Actor module, authenticate with your API token, and select the Actor.
2. Fill the input fields — Make renders the Actor’s input schema as a form automatically, so you rarely need to hand-write JSON here.
3. For a fast Actor, tick wait for finish and the module blocks until the run completes, then hands the run ID to the next module.
4. Add Apify → Get Dataset Items, feed it the dataset ID from step 3, and route the rows into your scenario — a filter, a router, a CRM update.

Option C — Zapier

Zapier’s Apify integration exposes Run Actor as an action and New Dataset Item as a trigger.

1. Create a Zap with your usual trigger (a form submission, a new row, a schedule).
2. Add the Apify: Run Actor action, select the Actor and fill the input fields from the trigger’s data.
3. If you need the results in the same Zap, add a second Apify: Get Dataset Items action after a short delay step, since Zapier’s action model doesn’t block on long-running Actor runs the way n8n’s synchronous option does.

run-sync-get-dataset-items vs async + webhook

This is the one decision that actually matters, and it comes down to how long the Actor takes to finish.

Use run-sync-get-dataset-items (synchronous) when:

• The run typically finishes in well under the platform’s timeout window (n8n, Make, and Zapier all cap how long a single step can block — usually somewhere between 30 seconds and a few minutes depending on your plan).
• You’re pulling a small-to-medium batch — a handful of URLs, one domain, one channel.
• You want the simplest possible workflow: one node in, rows out, no state to track between steps.

curl "https://api.apify.com/v2/acts/DevilScrapes~google-ads-transparency/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"advertiserDomain": "competitor.com", "maxAds": 100}'

Use async + webhook when:

• The run can take minutes to hours — a channel back-catalog pull, a multi-thousand-row batch, or anything where we’re deliberately pacing requests against a target’s rate limits rather than hammering it and getting the whole run blocked.
• You don’t want your automation platform’s execution sitting idle (and possibly billed) while a run completes.
• You want retry/notification logic independent of the trigger — e.g. post to Slack only on SUCCEEDED, alert on FAILED.

The async pattern: call the regular run-actor endpoint (no -sync), attach a webhooks parameter pointing at your automation platform’s webhook-catching URL, and let Apify call you back when the run finishes:

from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("DevilScrapes/google-ads-transparency").call(
    run_input={"advertiserDomain": "competitor.com", "maxAds": 500},
    webhooks=[{
        "eventTypes": ["ACTOR.RUN.SUCCEEDED"],
        "requestUrl": "https://hook.eu1.make.com/your-webhook-id",
    }],
)

n8n and Make both expose a Webhook trigger node — drop that URL in, and the rest of your workflow only runs once the Actor has actually finished, with the run ID and dataset ID available in the payload for a follow-up Get Dataset Items call.

What this costs

Pay-Per-Event pricing applies the same whether you trigger a run from the Apify Console or from n8n — there’s no automation surcharge. Google Ads Transparency Scraper charges a $0.20 actor-start fee plus $3.00 per 1,000 ad rows returned. Pulling 100 ads through the n8n flow above costs $0.20 + $0.30 = $0.50; a 1,000-ad batch runs $3.20. If the domain has no ads live, you’re charged only the $0.20 start fee — never for rows that never landed.

Run it on Apify

Grab an Apify account (free trial credit, no card required) and connect it to your automation tool of choice:

• Google Ads Transparency Scraper on Apify — the Actor used in this walkthrough.
• Browse the rest of the catalog for an Actor that fits your workflow — every one of our 202 live Actors works with the same n8n / Make / Zapier setup described above, just with different input fields.

FAQ

Do I need a paid n8n, Make, or Zapier plan to run an Apify Actor?

No. All three platforms’ free tiers support HTTP-based integrations and the official Apify connectors. What limits you on a free tier is usually execution time or monthly task/operation count, not the ability to call Apify at all.

Which is faster to set up, the node/app or a raw HTTP request?

The official connectors (n8n’s Apify node, Make’s Apify app) are faster for most people because they render the Actor’s input schema as a form. A raw HTTP Request node calling the REST API directly works identically and is sometimes preferable if you’re already comfortable with JSON and want fewer moving parts.

What happens if the Actor run fails mid-workflow?

Apify marks the run FAILED and, if you’re on the async + webhook pattern, still fires the webhook (filter on ACTOR.RUN.FAILED to catch it). We fail loud on genuine blocks rather than handing back a silent empty dataset, so a FAILED status means something upstream actually broke — check the run log for the reason.

Can I pass a schedule from n8n/Make instead of using Apify’s own Scheduler?

Yes, and it’s a common pattern — use your automation platform’s schedule trigger to control cadence and business logic (e.g. skip weekends, only run for active accounts) while Apify just executes the single run you ask for.