Apify Tasks & Schedules

Contains affiliate links. Disclosure.

Quick Answer

Yes: Apify Schedules trigger recurring Actor runs on cron, or one of Apify's own presets, natively down to a 10-second floor — no external orchestrator required for anything short of that. Pair a Schedule with a webhook and a failed BI feed or pricing crawl alerts you the moment it breaks, not after someone notices a stale dashboard. Both Tasks and Schedules are free features on every plan; you still pay for the underlying Actor's compute.

Tasks remember how you want an Actor to run. Schedules remember when to trigger those runs (or ad-hoc Actor executions). Together they power price monitors, nightly lead pulls, and rolling social listening.

Official references: Actor tasks, Schedules, Schedules API.

What is a Task?

A Task is a named, saved configuration for an Actor:

• Frozen input JSON (with optional defaults for memory, timeout, build tag).
• A one-click Run action for humans.
• A stable ID for APIs, schedules, and integrations.

Treat it as a production recipe you can audit, review, and reuse.

Create, test, and run a Task (Console)

1. Open the Apify Console and select the Actor you rely on.
2. Click Create task, name it clearly (for example, maps-dentists-austin-weekly).
3. Fill in input JSON, then set memory, timeout, and build if needed.
4. Save, then Run once and inspect the default dataset.
5. Note the task ID in the URL if you will trigger it from code.

What is a Schedule?

A Schedule fires one or more actions on a timer. Typical actions:

• Run task: preferred for production (inputs are already validated).
• Run actor: useful for experiments; still migrate to a Task once stable.

Schedules accept cron expressions, shortcuts such as @daily, and per-schedule timezones — Apify's own API examples default to UTC, so set one explicitly if your team thinks in local time.

Cron presets (UTC examples)

Preset	Cron	When it runs
Hourly	0 * * * *	Minute 0 of every hour
Daily 06:00	0 6 * * *	Once a day at 06:00 UTC
Weekly Monday 09:00	0 9 * * 1	Mondays at 09:00 UTC
Every 15 minutes	*/15 * * * *	Four times per hour
Monthly (1st)	0 0 1 * *	Midnight UTC on the first day
Every 15 seconds	*/15 * * * * *	Sub-minute, using the optional seconds field
Shortcuts	@hourly, @daily, @weekly, @monthly, @yearly	Common presets

Compose custom expressions with crontab.guru, which covers the standard 5-field syntax. Apify's own cron parser adds a sixth, optional seconds field in front — */15 * * * * * runs every 15 seconds — and the documented floor is 10 seconds between runs (any run scheduled sooner than that is skipped). You only need an external orchestrator calling the Run Actor API if you need something faster than 10-second cadence.

Updated 2026-09-09: this page previously said Apify's cron was standard 5-field with a 1-minute floor. It isn't — the seconds field is real, and the floor is 10 seconds, confirmed against docs.apify.com/platform/schedules today.

Configure a Schedule

1. Console sidebar → Schedules → Create new schedule.
2. Set timezone if stakeholders think in local time.
3. Add actions: Run task (pick your Task) or Run actor.
4. Optionally set input overrides for seasonal tweaks without cloning Tasks.
5. Save & activate and verify the first triggered run.

Webhook triggers (vs Schedules)

• Schedules fire on a clock inside Apify.
• Webhooks send HTTP callbacks when run state changes, or when external systems orchestrate Apify through the API.

Common pattern: Schedule → Task run → webhook notifies Slack, Zapier, or your API → consumer fetches the dataset.

See Slack integration for a concrete notification path.

Practical automation patterns

Pattern	Task setup	Schedule	Notes
E-commerce price watch	Product URL list + lean memory	Daily off-peak UTC	Diff outputs in Sheets or a warehouse
Local lead refresh	Maps Actor with a tight query	Weekly Monday	Increase frequency only after CU review
Social mention sweep	Twitter Actor with capped maxItems	Hourly / bi-hourly	Watch compute; widen spacing if costs spike

Run a Task with the Apify API

Replace placeholders with your IDs. You need an API token authorized to start runs.

cURL

curl -X POST "https://api.apify.com/v2/actor-tasks/YOUR_TASK_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{}'

Use -d '{"key":"value"}' for a one-off input override.

JavaScript (Apify client)

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.task('YOUR_TASK_ID').call(
  {}, // optional input override
  {
    memoryMbytes: 2048,
    timeoutSecs: 900,
    build: 'latest',
  },
);

console.log('Run ID:', run.id);
console.log('Dataset ID:', run.defaultDatasetId);

Python (Apify client)

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.task('YOUR_TASK_ID').call(
    task_input={},  # optional override
    memory_mbytes=2048,
    timeout_secs=900,
    build='latest',
)

print('Run ID:', run['id'])
print('Dataset ID:', run['defaultDatasetId'])

Poll the run resource until status is SUCCEEDED or FAILED, then export the default dataset.

Cost and guardrails

Scheduling is free as a platform feature. You still pay for compute units, proxies, and storage like any other run.

• Keep timeouts and max items tight in Actor inputs.
• Right-size memory after a successful baseline run.
• Inspect Billing weekly while tuning hourly jobs.

Read compute units and cost optimization before raising cron frequency.

Automate on Apify

Create a free Apify account and save your first Task, then attach a Schedule when manual runs look perfect.

Frequently Asked Questions

A Task stores an Actor’s input and default run options. A Schedule is a timer that triggers Tasks or Actors using cron expressions or shortcuts.

Yes. The features are included on every plan. You still pay for the underlying Actor compute, proxies, and stored data.

You can assign a timezone per schedule, and Apify's Schedules API supports daylight saving time shifts. Apify's docs don't state an explicit default, and its own API examples use UTC, so set a timezone explicitly rather than assume one.

Yes. A schedule can include multiple actions (up to ten Tasks and ten Actors). Use this to fan out related jobs such as scrape-then-transform.

Yes. Scheduled actions support input JSON overrides for seasonal campaigns or experiments without duplicating the Task.

Webhooks notify external systems after run state changes. Pair schedules for timing with webhooks for downstream orchestration.

Yes. Run the Task once, validate the dataset schema, and only then enable the schedule to avoid burning credits on a broken loop.

Sources

• Apify schedules
• Apify scheduler
• Actor tasks
• Schedules API
• Cron reference