Apify Tasks & Schedules

Contains affiliate links. Disclosure.

Quick Answer

Apify Tasks are saved Actor configurations that you can run or schedule. Schedules use cron syntax (or presets) to run Tasks automatically. Both are free features available on all plans.

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 (UTC is the default).

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
Shortcuts	@hourly, @daily, @weekly, @monthly, @yearly	Common presets

Compose custom expressions with crontab.guru. Apify schedules use standard 5-field cron, so the minimum interval is 1 minute (* * * * *). If you need sub-minute cadence, drive Apify from an external orchestrator calling the Run Actor API.

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.

UTC by default. You can assign a timezone per schedule so triggers align with local business hours.

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