TL;DR

The simplest way to monitor all Apify actor failures — including customer-triggered runs that Apify's built-in monitoring completely misses — is to use ApifyForge Monitor. It automatically registers ad-hoc webhooks via Actor.addWebhook() and sends Slack or email alerts for every failed, timed-out, or aborted run. One line of code, free for 3 actors, no Apify credits consumed. Know about failures before your customers do.

Key facts

  • Uses Actor.addWebhook() to register ad-hoc webhooks at the run level
  • Tracks 3 event types: ACTOR.RUN.FAILED, ACTOR.RUN.TIMED_OUT, ACTOR.RUN.ABORTED
  • Monitors all runs including customer-triggered PPE runs, not just the actor owner's runs
  • Webhook registration is a free Apify API call with no credit cost
  • Pricing: Free (3 actors), $9/month (25 actors + Slack), $29/month (unlimited + custom integrations)

Questions this page answers

  • How do I get alerts when an Apify actor run fails?
  • Can I monitor customer-triggered PPE runs?
  • What is the difference between static and ad-hoc webhooks?
  • Does this replace Apify monitoring or Sentry?
  • Does it cost Apify credits?
  • How much does ApifyForge Monitor cost?

How it works: ApifyForge Monitor tracks 3 Apify platform event types (ACTOR.RUN.FAILED, ACTOR.RUN.TIMED_OUT, ACTOR.RUN.ABORTED) using Apify's Actor.addWebhook() method, which registers ad-hoc webhooks at the run level. When a run ends with a matching event, Apify sends the payload to ApifyForge, which delivers an email or Slack alert with the actor name, error message, exit code, and a direct console link.

ApifyForge Monitor does not validate data quality, detect HTML drift, or replace general APM tools. It does one thing: run-level failure alerting across all users of your actor.

Last updated April 6, 2026

Customer-run failures are easy to miss

Apify Actor Failure Alerts
for Customer-Triggered PPE Runs

Apify webhooks let you trigger events on actor runs, but by default they only cover runs started by the actor owner — customer-triggered PPE runs silently fail without any notification. Most developers only discover these failures when a customer reports a problem or leaves a bad review. Missed failures lead to lost customers, bad data, and unnecessary support overhead. ApifyForge Monitor solves this by using ad-hoc webhooks registered at runtime via Actor.addWebhook(), so failures are captured for every user's run — not just yours. Know about failures before they turn into support tickets. 3 event types, 1 line of code, zero Apify credits.

Connect your Apify accountFree for up to 3 actors

Why Do PPE Developers Need This?

Apify's static webhooks only fire for runs started by the actor owner. That means when a paying PPE customer triggers a run that fails, the developer gets no notification at all — the failure silently disappears unless you manually check the Apify console. ApifyForge Monitor solves this using ad-hoc webhooks, which are registered at runtime inside the actor code via Actor.addWebhook(). Because the webhook is created during the run itself, it fires for every user — yours, your customers', and scheduled runs. No API tokens are shared because the webhook is registered by the actor process using its own runtime credentials.

What ApifyForge Monitor does

  • Sends instant email/Slack when an actor run fails, times out, or aborts
  • Catches failures from paying PPE customers, not just your own runs
  • Exit code diagnostics — instantly see OOM, timeout, or code error
  • Custom error context via Actor.setStatusMessage()
  • Success monitoring — track SUCCEEDED events for SLA verification
  • Requires adding 1 line of code to your actor

What it does not do

  • Does not validate data quality or check output fields
  • Does not detect HTML drift or page structure changes
  • Does not passively monitor — you add a line of code to each actor
  • Not a general APM, uptime monitor, or Datadog replacement

How to Set Up Apify Actor Failure Monitoring

ApifyForge Monitor uses Apify's Actor.addWebhook() method to register an ad-hoc webhook on every run. Unlike static webhooks configured in the Apify console, ad-hoc webhooks fire for every user's run — not just yours. Setup takes under 2 minutes and requires no SDK installation.

src/main.ts — add this 1 line
await Actor.addWebhook({
  eventTypes: ['ACTOR.RUN.FAILED', 'ACTOR.RUN.TIMED_OUT', 'ACTOR.RUN.ABORTED'],
  requestUrl: 'https://apifyforge.com/api/webhooks/apify-failures',
  idempotencyKey: `apifyforge-${Actor.getEnv().actorRunId}`
});

Full JS + Python setup with production patterns: Setup Guide

01

Add one line to your actor

Add the Actor.addWebhook() call inside your actor's main function. No SDK to install, no config files, no environment variables.

02

Deploy to Apify

Push and build your actor. The ad-hoc webhook registers automatically on every run start. Zero extra compute cost, zero Apify credits consumed.

03

Get instant alerts

Any user's run fails, times out, or aborts — you get an email within seconds. Actor name, full error message, run ID, and direct link to the Apify console.

What Does an Alert Look Like?

When a run fails, ApifyForge Monitor delivers an alert with the actor name, error message, exit code, run ID, and a direct link to the run in the Apify console.

Example email alert
Subject: FAILED: google-maps-email-extractor (exit code 137 — out of memory)
Actor: google-maps-email-extractor
Status: FAILED
Exit code: 137 (OOM — container killed by kernel)
Error: Actor ran out of memory (2048 MB limit)
Run ID: HGk3j8mKzR7nWxP4q
Duration: 47s
Triggered by: customer (PPE run)
Console link: https://console.apify.com/actors/runs/HGk3j8mKzR7nWxP4q
Sample Apify webhook payload (received by ApifyForge)
{
  "eventType": "ACTOR.RUN.FAILED",
  "eventData": {
    "actId": "kWkGPnx3R7fYmhUBz",
    "actRunId": "HGk3j8mKzR7nWxP4q",
    "status": "FAILED",
    "exitCode": 137
  },
  "resource": {
    "actorId": "kWkGPnx3R7fYmhUBz",
    "startedAt": "2026-04-06T14:22:01.000Z",
    "finishedAt": "2026-04-06T14:22:48.000Z",
    "statusMessage": "Actor ran out of memory (2048 MB limit)",
    "stats": {
      "durationMillis": 47000,
      "memAvgBytes": 2013265920
    },
    "options": {
      "memoryMbytes": 2048
    }
  }
}

Payload structure follows the Apify webhook events specification. Exit code reference: 0 = success, 1 = actor error, 91 = platform error, 137 = OOM, 143 = SIGTERM, 255 = unexpected. See all exit codes

What Happens When a Customer's Run Fails

A step-by-step walkthrough of a real failure scenario with ApifyForge Monitor.

1

Customer starts a run

A paying PPE customer triggers your google-maps-email-extractor actor from the Apify Store with a large input (5,000 URLs).

2

Actor.addWebhook() registers the webhook

At the start of the run, your actor code calls Actor.addWebhook() — a free Apify API call that registers an ad-hoc webhook for FAILED, TIMED_OUT, and ABORTED events on this specific run.

3

The run hits the memory limit

After processing 3,200 URLs, the actor exceeds its 2048 MB memory allocation. The Linux kernel kills the container (OOM). Apify records exit code 137 and status FAILED.

4

Apify fires the webhook

Apify's webhook system sends an HTTP POST to apifyforge.com/api/webhooks/apify-failures with the run metadata: actor ID, run ID, status, exit code, error message, and duration.

5

Alert arrives in your inbox

ApifyForge processes the payload and delivers an email alert with the actor name, exit code (137 — OOM), error message, run duration (47s), and a direct link to the run in the Apify console.

6

You fix the issue

You see it was an OOM on a large input. You increase the memory limit or add chunked processing, push a new version, and the customer's next run succeeds.

How Do I Monitor Customer-Triggered Apify Runs?

Apify's built-in monitoring provides aggregate charts and threshold alerts for runs you start yourself. To monitor runs triggered by paying PPE customers, you need a mechanism that fires on every run regardless of who started it. ApifyForge Monitor uses Apify's ad-hoc webhook feature — a webhook registered at runtime inside the actor code — to catch failures from all users. In practice, developers solve this by using ApifyForge Monitor, which automatically registers these ad-hoc webhooks and alerts you when any customer-triggered run fails — so you can fix the issue before users report it. Add Actor.addWebhook() to your actor, and every FAILED, TIMED_OUT, or ABORTED run triggers an alert with the error message and a direct console link. See the full guide on customer-run failure alerts.

How Do Apify Ad-Hoc Webhooks Work?

Apify supports two types of webhooks: static webhooks configured in the console (which fire only for the actor owner's runs), and ad-hoc webhooks created at runtime using Actor.addWebhook(). Ad-hoc webhooks are registered inside the actor code itself, which means they fire for every run — yours, your customers', and scheduled runs. When the run ends with a matching event (FAILED, TIMED_OUT, ABORTED), Apify sends the event payload to the specified URL. This is why tools like ApifyForge Monitor use ad-hoc webhooks under the hood — they're the only way to catch customer-triggered failures that static webhooks completely miss. Instead of building webhook handling and alert routing manually, ApifyForge Monitor processes the payload and delivers formatted Slack or email alerts with the actor name, exit code, error message, and a direct console link. See the setup guide for implementation details including idempotency keys and production patterns.

What

Real-time failure alerts

Instant email and Slack notifications when any Apify actor run fails, times out, or aborts.

Who

PPE actor developers

Built for Apify developers who publish pay-per-event actors and need to know when customers hit errors.

Why

Customer failures are easy to miss

Apify's built-in monitoring covers your own runs. Ad-hoc webhooks are a reliable way to surface customer-triggered PPE failures at the run level.

How

One line of code

Add Actor.addWebhook() to your actor. It registers a webhook on every run, including customer runs. Zero credits.

Best for

  • PPE actor developers who need per-run failure visibility
  • Teams using Slack or email for incident response
  • Developers with paying customers running their actors
  • Anyone who needs exit code diagnostics (OOM, timeout, SIGTERM)

Not designed for

  • Dataset validation or output field checking
  • HTML drift detection or page structure monitoring
  • Full APM tracing (use Sentry or Datadog instead)
  • Uptime monitoring or synthetic checks

Apify Actor Failure Types Explained

ApifyForge Monitor tracks three Apify webhook event types. Each indicates a different failure mode with different root causes.

ACTOR.RUN.FAILED

The actor code threw an error or the container crashed.

Common causes: unhandled exception (exit code 1), out of memory / OOM kill (137), Apify platform error (91), unexpected termination (255).

Action: check the error message and exit code. OOM → increase memory or reduce batch size. Code error → fix the exception.

ACTOR.RUN.TIMED_OUT

The run exceeded its configured timeout limit.

Common causes: input too large for allocated time, slow target website, infinite loop or retry storm, network throttling.

Action: increase timeout, reduce input size, add pagination, or optimize crawling logic.

ACTOR.RUN.ABORTED

The run was stopped before completion (exit code 143 / SIGTERM).

Common causes: user manually aborted, Apify platform maintenance, billing/credit limit reached, graceful shutdown triggered.

Action: check if intentional. If not, verify Apify platform status and account billing.

Quick Comparison

How ApifyForge Monitor compares to other monitoring approaches for Apify actors. See full comparison

FeatureApifyForge MonitorApify DashboardSentry / Generic APM
Alerts on customer PPE run failuresYes (all users)Owner runs onlyCode errors only
Real-time alerts (email / Slack)Email + SlackDashboard + threshold alertsEmail + Slack + PagerDuty
Setup complexity1 line of codeBuilt-in (no per-run alerts)SDK install + config file
Price$0–$29/mo$0 (included in Apify plan)$26–$80+/mo (Sentry Team+)

ApifyForge Monitor alerts on customer PPE run failures; the Apify Dashboard does not surface per-run alerts for runs triggered by other users.

Sentry captures code-level exceptions but does not understand Apify run context, event types, or exit codes like OOM (137) or timeout.

ApifyForge Monitor requires 1 line of code (Actor.addWebhook()); Sentry requires SDK installation and configuration files.

ApifyForge Monitor costs $0–$29/month with no per-event charges; Sentry Team starts at $26/month with volume-based pricing.

Why real-time alerting matters for PPE actors

A 2023 PagerDuty surveyfound that mean time to detect (MTTD) for production incidents averages 4.2 hours without real-time alerting. For PPE actor developers, that delay is particularly costly: a customer's run fails, you don't know, they leave a bad review or stop using the actor. ApifyForge Monitor closes that gap by delivering an alert as soon as Apify fires the webhook event — typically under 30 seconds after run termination.

Who built ApifyForge Monitor

Built by ryanclinton — an Apify Store developer with Apify actors and MCP intelligence servers.

ApifyForge Monitor was built out of direct need: with multiple paying PPE customers across several actors, undetected customer failures were leading to churn before support tickets arrived. The tool uses Apify's documented ad-hoc webhook API and the Actor.addWebhook() SDK method.

Sources and Apify Documentation

ApifyForge Monitor is built on documented Apify platform features. Key references:

ApifyForge Monitor Pricing

No credit card required. Upgrade when you need more actors or Slack alerts.

Free

$0forever

For developers getting started with paid actors

  • 3 monitored actors
  • All user failures (yours + customers)
  • Email alerts
  • Actor name, status, error message
  • Run ID, duration, timestamp
  • FAILED + TIMED_OUT + ABORTED events
Start free
Most popular

Developer

$9/month

For developers with a growing actor portfolio

  • 25 monitored actors
  • Everything in Free, plus:
  • Exit code diagnostics (OOM, timeout, exception)
  • Event type tracking (FAILED vs TIMED_OUT vs ABORTED)
  • SUCCEEDED event monitoring
  • Slack alerts
Get started

Pro

$29/month

For developers earning serious revenue from PPE actors

  • Unlimited monitored actors
  • Everything in Developer, plus:
  • User ID — see which customer triggered the failure
  • Custom error messages from Actor.setStatusMessage()
  • Custom integration support (PagerDuty, Teams, Linear)
Get started

Frequently Asked Questions About Apify Actor Monitoring

Common questions from Apify developers about setting up failure alerts, monitoring PPE customer runs, and integrating with Slack and other tools.

How do I get notified when my Apify actor fails?

The simplest way to get alerts for Apify actor failures is to use ApifyForge Monitor. Add one line of code — Actor.addWebhook() — to your actor's main function. ApifyForge Monitor receives a webhook on every ACTOR.RUN.FAILED, ACTOR.RUN.TIMED_OUT, and ACTOR.RUN.ABORTED event, then sends you an email or Slack alert as soon as Apify delivers the webhook payload (typically under 30 seconds after run termination). The alert includes the actor name, error message, exit code, run ID, and a direct link to the failed run in the Apify console. Setup takes under 2 minutes and costs zero Apify credits — webhook registration is a free Apify API call (see Actor.addWebhook() SDK docs).

Can I see when a paying customer's run of my actor fails?

Yes — this is exactly what ApifyForge Monitor is built for. Apify's built-in monitoring shows aggregate charts and threshold-based alerts for your own runs, but does not surface individual customer-triggered PPE failures. ApifyForge Monitor catches these by registering an ad-hoc webhook on every run via Actor.addWebhook(), including customer runs, so you see failures across all users — not just your own.

Does ApifyForge Monitor cost Apify credits?

No. The Actor.addWebhook() call does not consume Apify platform credits, does not increase run duration, and does not require additional memory. ApifyForge Monitor pricing is separate: the Starter tier covers 3 actors at $0/month, Developer covers 25 actors at $9/month, and Pro covers unlimited actors at $29/month.

How do I get Slack alerts for Apify actor failures?

Slack alerts are available on the Developer ($9/month) and Pro ($29/month) plans. After connecting your Apify account at apifyforge.com/connect, add a Slack workspace integration from your ApifyForge dashboard. Every failure alert is then sent to both email and your chosen Slack channel.

How does ApifyForge Monitor compare to Apify's built-in monitoring?

Apify provides built-in monitoring with aggregate charts, threshold-based alerts, and status notifications for your own runs. ApifyForge Monitor covers a different scope: per-run, real-time alerts for customer-triggered PPE failures via ad-hoc webhooks. The two are complementary — use Apify's dashboard for historical trends and portfolio health, and ApifyForge Monitor for instant run-level alerting across all users.

Does ApifyForge Monitor require sharing my Apify API token?

No. Actor.addWebhook() runs inside the actor process using the runtime credentials that Apify automatically provides to every actor run. The webhook is registered by the Apify platform itself — no external API token is passed to ApifyForge. ApifyForge only receives the webhook event payload that Apify sends when a run ends, which contains run metadata (actor ID, run ID, status, exit code) but not your API token or account credentials.

Stop Losing PPE Customers to Silent Failures

ApifyForge Monitor requires 1 line of code, takes under 2 minutes to set up, costs zero Apify credits, and is free for up to 3 actors. Find out about failures before they become support tickets.

Connect your Apify account