Scheduler0

A Unified Platform for Cron Jobs

Set up, run, and scale scheduled jobs — without the guesswork.

Say goodbye to silent failures, timezone headaches, and clunky UIs. Scheduler0 helps modern teams schedule jobs across any cloud, monitor execution in real time, and recover automatically when things go wrong.

Get Started for Free View Docs

Built for Developers

Scheduler0 is more than a cron runner — it's your automation engine, built with DX and observability in mind.

📊 Full Observability

Real-time logs, job history, success rates, and alerts.

🐳 Flexible Execution

Run containers, webhooks, scripts, or cloud functions.

🌍 Cloud-Native & Multi-Cloud

Execute jobs to AWS, GCP, Azure — or bring your own environment.

package main

import (
    "fmt"
    sdk "github.com/scheduler0/scheduler0-go-client"
)

func main() {
    // Initialize SDK client (scoped to your account)
    c, err := sdk.NewClient("https://api.scheduler0.com", "v1",
        sdk.WithAccountID("your-account-id"),
        sdk.WithAPIKey("$SCHEDULER0_API_KEY"),
        sdk.WithAPISecret("$SCHEDULER0_API_SECRET"),
    )
    if err != nil { panic(err) }

    // 1) Create an executor for the project
    execRes, err := c.CreateExecutor(&sdk.ExecutorRequestBody{
        ProjectID: 123,
        Name:      "webhook-exec",
        Type:      "webhook_url",
        WebhookUrl:    "https://example.com/run",
        WebhookMethod: "POST",
    })
    if err != nil { panic(err) }

    // 2) Create a job that runs every minute using the executor
    jobRes, err := c.CreateJob(&sdk.JobRequestBody{
        ProjectID: 123,
        Timezone:  "UTC",
        Spec:      "@every 1m",
        Data:      "{""hello"":""world""}",
        RetryMax:  3,
        Status:    "active",
        ExecutorID: execRes.Data.ID,
        CreatedBy: "you@example.com",
    })
    if err != nil { panic(err) }
    fmt.Println("Created Job ID:", jobRes.Data.ID)

    // 3) Fetch recent executions for the job
    execs, err := c.GetExecutions(jobRes.Data.ID, sdk.ListOptions{Limit: 10})
    if err != nil { panic(err) }
    fmt.Println("Recent Executions:", len(execs.Data.Items))
}

import Client from '@scheduler0/node';

const client = new Client({
  baseUrl: 'https://api.scheduler0.com',
  apiVersion: 'v1',
  accountId: 'your-account-id',
  apiKey: process.env.SCHEDULER0_API_KEY,
  apiSecret: process.env.SCHEDULER0_API_SECRET,
});

async function main() {
  // 1) Create executor
  const exec = await client.executors.create({
    projectId: 123,
    name: 'webhook-exec',
    type: 'webhook_url',
    webhookUrl: 'https://example.com/run',
    webhookMethod: 'POST',
  });

  // 2) Create job using the executor
  const job = await client.jobs.create({
    projectId: 123,
    timezone: 'UTC',
    spec: '@every 1m',
    data: '{"hello":"world"}',
    retryMax: 3,
    status: 'active',
    executorId: exec.data.id,
    createdBy: 'you@example.com',
  });
  console.log('Created Job ID:', job.data.id);

  // 3) Fetch recent executions
  const executions = await client.executions.list({ jobId: job.data.id, limit: 10 });
  console.log('Recent Executions:', executions.data.items.length);
}

main().catch(console.error);

from scheduler0 import Client
import os

client = Client(
    base_url='https://api.scheduler0.com',
    api_version='v1',
    account_id='your-account-id',
    api_key=os.environ['SCHEDULER0_API_KEY'],
    api_secret=os.environ['SCHEDULER0_API_SECRET'],
)

# 1) Create executor
exec = client.executors.create({
    'projectId': 123,
    'name': 'webhook-exec',
    'type': 'webhook_url',
    'webhookUrl': 'https://example.com/run',
    'webhookMethod': 'POST',
})

# 2) Create job
job = client.jobs.create({
    'projectId': 123,
    'timezone': 'UTC',
    'spec': '@every 1m',
    'data': '{"hello":"world"}',
    'retryMax': 3,
    'status': 'active',
    'executorId': exec.data.id,
    'createdBy': 'you@example.com',
})
print('Created Job ID:', job.data.id)

# 3) Fetch recent executions
executions = client.executions.list({'jobId': job.data.id, 'limit': 10})
print('Recent Executions:', len(executions.data.items))

#!/usr/bin/env bash

# Using scheduler0 CLI
export SCHEDULER0_API_KEY=...
export SCHEDULER0_API_SECRET=...

# 1) Create executor
EXEC_ID=$(scheduler0 executors create \
  --project-id 123 \
  --name webhook-exec \
  --type webhook_url \
  --webhook-url https://example.com/run \
  --webhook-method POST \
  --output id)

# 2) Create job
JOB_ID=$(scheduler0 jobs create \
  --project-id 123 \
  --timezone UTC \
  --spec "@every 1m" \
  --data '{"hello":"world"}' \
  --retry-max 3 \
  --status active \
  --executor-id "$EXEC_ID" \
  --output id)
echo "Created Job ID: $JOB_ID"

# 3) Fetch executions
scheduler0 executions list --job-id "$JOB_ID" --limit 10

import com.scheduler0.Client;
import com.scheduler0.types.*;

public class Main {
  public static void main(String[] args) throws Exception {
    Client client = new Client(
      "https://api.scheduler0.com", "v1",
      System.getenv("SCHEDULER0_API_KEY"),
      System.getenv("SCHEDULER0_API_SECRET"),
      "your-account-id"
    );

    // 1) Create executor
    var exec = client.executors().create(new ExecutorRequestBody()
      .setProjectId(123)
      .setName("webhook-exec")
      .setType("webhook_url")
      .setWebhookUrl("https://example.com/run")
      .setWebhookMethod("POST")
    );

    // 2) Create job
    var job = client.jobs().create(new JobRequestBody()
      .setProjectId(123)
      .setTimezone("UTC")
      .setSpec("@every 1m")
      .setData("{\"hello\":\"world\"}")
      .setRetryMax(3)
      .setStatus("active")
      .setExecutorId(exec.getData().getId())
      .setCreatedBy("you@example.com")
    );
    System.out.println("Created Job ID: " + job.getData().getId());

    // 3) List executions
    var executions = client.executions().list(new ListExecutionsRequest()
      .setJobId(job.getData().getId())
      .setLimit(10)
    );
    System.out.println("Recent Executions: " + executions.getData().getItems().size());
  }
}

require 'scheduler0'

client = Scheduler0::Client.new(
  base_url: 'https://api.scheduler0.com',
  api_version: 'v1',
  account_id: 'your-account-id',
  api_key: ENV['SCHEDULER0_API_KEY'],
  api_secret: ENV['SCHEDULER0_API_SECRET']
)

# 1) Create executor
exec = client.executors.create(
  projectId: 123,
  name: 'webhook-exec',
  type: 'webhook_url',
  webhookUrl: 'https://example.com/run',
  webhookMethod: 'POST'
)

# 2) Create job
job = client.jobs.create(
  projectId: 123,
  timezone: 'UTC',
  spec: '@every 1m',
  data: '{"hello":"world"}',
  retryMax: 3,
  status: 'active',
  executorId: exec.data.id,
  createdBy: 'you@example.com'
)
puts "Created Job ID: #{job.data.id}"

# 3) Fetch executions
executions = client.executions.list(jobId: job.data.id, limit: 10)
puts "Recent Executions: #{executions.data.items.size}"

use scheduler0::{Client, ListOptions};

fn main() -> anyhow::Result<()> {
    let client = Client::new(
        "https://api.scheduler0.com",
        "v1",
        std::env::var("SCHEDULER0_API_KEY")?,
        std::env::var("SCHEDULER0_API_SECRET")?,
        "your-account-id".to_string(),
    );

    // 1) Create executor
    let exec = client.executors().create(
        123,
        "webhook-exec",
        "webhook_url",
        Some("https://example.com/run"),
        Some("POST"),
    )?;

    // 2) Create job
    let job = client.jobs().create(
        123,
        "UTC",
        Some("@every 1m"),
        Some("{\\"hello\\":\\"world\\"}"),
        3,
        "active",
        Some(exec.data.id),
        Some("you@example.com"),
    )?;
    println!("Created Job ID: {}", job.data.id);

    // 3) List executions
    let executions = client.executions().list(job.data.id, ListOptions { limit: Some(10), ..Default::default() })?;
    println!("Recent Executions: {}", executions.data.items.len());
    Ok(())
}

<?php
require 'vendor/autoload.php';

use Scheduler0\Client;

$client = new Client([
  'baseUrl' => 'https://api.scheduler0.com',
  'apiVersion' => 'v1',
  'accountId' => 'your-account-id',
  'apiKey' => getenv('SCHEDULER0_API_KEY'),
  'apiSecret' => getenv('SCHEDULER0_API_SECRET'),
]);

// 1) Create executor
$exec = $client->executors()->create([
  'projectId' => 123,
  'name' => 'webhook-exec',
  'type' => 'webhook_url',
  'webhookUrl' => 'https://example.com/run',
  'webhookMethod' => 'POST',
]);

// 2) Create job
$job = $client->jobs()->create([
  'projectId' => 123,
  'timezone' => 'UTC',
  'spec' => '@every 1m',
  'data' => '{"hello":"world"}',
  'retryMax' => 3,
  'status' => 'active',
  'executorId' => $exec->data->id,
  'createdBy' => 'you@example.com',
]);
echo "Created Job ID: {$job->data->id}\n";

// 3) Fetch executions
$executions = $client->executions()->list(['jobId' => $job->data->id, 'limit' => 10]);
echo "Recent Executions: ".count($executions->data->items)."\n";

Tip: Omit Spec to create a one-off job with just a StartDate.

Schedule with Natural Language

Let your end users describe their scheduling needs in plain English. AI handles the complexity, you focus on building.

📅 Event-Based Follow-ups

Perfect for sales teams, customer success, and any workflow that needs to respond to calendar events.

End User Says:

"Follow up 2 days after the demo"

No cron expressions, no complex timing logic

AI Delivers:

Type: FOLLOW_UP

Start Date: demo + 2 days

Subject: "How was your demo?"

Perfect timing, professional messaging

// AI Prompt Scheduling - Let your end users describe scheduling in plain English
import Client from '@scheduler0/node';

const event = await client.events.create({
  event: "demo_scheduled",
  data: {
    customerName: "Acme Corp",
    customerEmail: "john@acme.com",
    demoDate: "2024-01-15T14:00:00Z",
    product: "Enterprise Plan",
    salesRep: "sarah@company.com"
  },
  projectId: 123,
  startDate: "2024-01-15T14:00:00Z",
  endDate: "2024-01-15T15:00:00Z",
  timezone: "America/New_York"
});

const promptResponse = await client.ai.createJobFromPrompt({
  prompt: "Follow up 2 days after the demo", // End user's natural language
  purposes: ["sales_follow_up", "customer_engagement"],
  events: ["demo_scheduled"],
  metadata: {
    eventId: event.data.id,
    customerEmail: "john@acme.com",
    salesRep: "sarah@company.com"
  },
  timezone: "America/New_York"
});

const followUpJob = await client.jobs.create({
  projectId: 123,
  timezone: promptResponse.timezone,
  spec: promptResponse.cronExpression,
  startDate: promptResponse.startDate, // AI calculated: demo + 2 days
  data: JSON.stringify({
    subject: promptResponse.subject,
    body: promptResponse.body,
    delivery: promptResponse.delivery,
    eventId: event.data.id
  }),
  retryMax: 2,
  status: 'active',
  executorId: 'email-executor-id',
});

⏰ One-Off Task Scheduling

Let users schedule one-time tasks like file sharing, report delivery, and reminders through natural conversation.

End User Says:

"Send the quarterly report to john@company.com tomorrow at 2 PM"

Chatbot understands file, recipient, and timing

AI Delivers:

Subject: "Quarterly Report - Q4 2024"

Timing: Tomorrow 2 PM EST

Attachment: q4-2024-report.pdf

Professional email with perfect timing

// AI File Delivery - Let your users describe file sharing naturally
import Client from '@scheduler0/node';

const userPrompt = "Send the quarterly report to john@company.com tomorrow at 2 PM";
const promptResponse = await client.ai.createJobFromPrompt({
  prompt: userPrompt,
  purposes: ["file_delivery", "document_sharing"],
  events: ["user_request"],
  metadata: {
    filePath: "/reports/q4-2024-report.pdf",
    recipientEmail: "john@company.com",
    senderEmail: "bot@company.com"
  },
  timezone: "America/New_York"
});

const deliveryJob = await client.jobs.create({
  projectId: 123,
  timezone: promptResponse.timezone,
  spec: promptResponse.cronExpression,
  startDate: promptResponse.startDate,
  data: JSON.stringify({
    subject: promptResponse.subject,
    body: promptResponse.body,
    delivery: promptResponse.delivery,
    filePath: "/reports/q4-2024-report.pdf",
    recipientEmail: "john@company.com"
  }),
  retryMax: 2,
  status: 'active',
  executorId: 'email-with-attachment-executor',
  createdBy: 'chatbot'
});

🔄 Recurring Event-Based Tasks

Perfect for ongoing workflows that start after an event and repeat on a schedule.

End User Says:

"Send weekly check-ins every Monday after the trial starts"

Recurring task triggered by an event

AI Delivers:

Cron: 0 9 * * 1

Start: trial_start + 1 week

Subject: "How's your trial going?"

Perfect recurring schedule after event

// AI Recurring Event-Based Tasks - Start recurring tasks after events
import Client from '@scheduler0/node';

const trialEvent = await client.events.create({
  event: "trial_started",
  data: {
    customerName: "Acme Corp",
    customerEmail: "john@acme.com",
    trialStartDate: "2024-01-15T00:00:00Z",
    plan: "Enterprise Trial"
  },
  projectId: 123,
  startDate: "2024-01-15T00:00:00Z",
  endDate: "2024-01-15T00:00:00Z",
  timezone: "America/New_York"
});

const promptResponse = await client.ai.createJobFromPrompt({
  prompt: "Send weekly check-ins every Monday after the trial starts",
  purposes: ["customer_success", "trial_engagement"],
  events: ["trial_started"],
  metadata: {
    eventId: trialEvent.data.id,
    customerEmail: "john@acme.com",
    trialDuration: "30 days"
  },
  timezone: "America/New_York"
});

const recurringJob = await client.jobs.create({
  projectId: 123,
  timezone: promptResponse.timezone,
  spec: promptResponse.cron, // Recurring schedule
  startDate: promptResponse.startDate, // Start after event
  data: JSON.stringify({
    subject: promptResponse.subject,
    body: promptResponse.body,
    delivery: promptResponse.delivery,
    eventId: trialEvent.data.id
  }),
  retryMax: 2,
  status: 'active',
  executorId: 'email-executor-id',
  createdBy: 'ai-assistant'
});

📅 Recurring Scheduled Tasks

Perfect for regular maintenance, reports, and routine tasks that run on a fixed schedule.

End User Says:

"Send monthly reports every first Monday at 9 AM"

Standalone recurring task

AI Delivers:

Cron: 0 9 1-7 * 1

Frequency: Monthly

Subject: "Monthly Report - [Month]"

Complex cron expression made simple

// AI Recurring Scheduled Tasks - Standalone recurring tasks
import Client from '@scheduler0/node';

const promptResponse = await client.ai.createJobFromPrompt({
  prompt: "Send monthly reports every first Monday at 9 AM",
  purposes: ["reporting", "monthly_updates"],
  events: [],
  metadata: {
    reportType: "monthly_summary",
    recipients: ["team@company.com", "management@company.com"]
  },
  timezone: "America/New_York"
});

const monthlyJob = await client.jobs.create({
  projectId: 123,
  timezone: promptResponse.timezone,
  spec: promptResponse.cron, // Complex recurring schedule
  data: JSON.stringify({
    subject: promptResponse.subject,
    body: promptResponse.body,
    delivery: promptResponse.delivery,
    reportType: "monthly_summary"
  }),
  retryMax: 1,
  status: 'active',
  executorId: 'report-generator-executor',
  createdBy: 'ai-assistant'
});

Developer Experience You'll Love

From CLI to UI to Terraform — schedule and manage jobs however you work.

🧑‍💻 scheduler0-cli

Create, test, and monitor jobs from your terminal.

🔧 API & SDKs

Automate everything with REST or native SDKs (Go, Python, JS).

Cloud-Native Architecture

Scheduler0 is designed to be truly cloud-native. The core platform doesn't rely on cloud providers for data storage, using SQLite and Raft consensus instead.

🚀 Built with Go

High-performance, compiled language ensures reliability and speed across all environments.

💾 SQLite & Raft

No cloud provider lock-in. Self-contained data storage with distributed consensus for high availability.

☁️ Deploy Anywhere

Run on AWS, GCP, Azure, on-premises, or any infrastructure that fits your needs.

Enterprise Deployment Options

For teams that need more control, we offer deployment on your infrastructure with full support and management.

🏢 Custom Deployment

Deploy Scheduler0 on your own infrastructure. We work directly with your team to set up and configure the platform.

✓ Deploy to your cloud or on-premises
✓ Full control over data and infrastructure
✓ Custom SLAs and configurations

🔧 Managed Infrastructure

Let us manage the infrastructure for you. We handle deployment, updates, and maintenance while you focus on building.

✓ Fully managed deployment
✓ Automatic updates and monitoring
✓ Dedicated support and priority assistance

Contact Sales for Enterprise

Simple Pricing

Free Tier

1,000 job executions per month
Job payload up to 3kb
Up to 3 retries
30 days executions logs retention
Free 100 AI prompt credits

Additional credits: $25 per 2000 credits

Paid

/month

/year

Save $70/year (17% off)

100,000 job executions per month
Job payload up to 1mb
Up to 15 retries
90 days execution logs retention
10 seat for team members
2000 AI prompt credits / month

Additional credits: $25 per 2000 credits

Enterprise

Everything in Paid plan
Deploy to your infrastructure
Custom SLAs
SSO
Group based access control
Dedicated support
Migration support
Priority feature requests

Schedule a Demo

Ready to take control of your cron jobs?

Start free — No credit card required View Docs