Cronhub

Best Self Hosted Alternatives to Cronhub

A curated collection of the 6 best self hosted alternatives to Cronhub.

Cloud cron job scheduler and monitor that executes and tracks scheduled tasks, triggers HTTP jobs or scripts, captures execution logs, alerts on failures or missed runs, supports retries and integrations, and provides dashboards and uptime-style monitoring for cron executions.

Alternatives List

#1
Uptime Kuma

Uptime Kuma

Uptime Kuma is a self-hosted uptime monitoring tool for HTTP(S), TCP, ping, DNS and more, with notifications, charts, and public status pages.

Uptime Kuma screenshot

Uptime Kuma is an easy-to-use self-hosted uptime monitoring service for servers, websites, and network endpoints. It provides a modern web UI to configure monitors, receive alerts, and publish status pages.

Key Features

  • Multiple monitor types including HTTP(S), TCP, ping, DNS record, WebSocket, keyword checks, JSON query checks, and push-based monitoring
  • Fast single-page web interface with real-time updates
  • Multi-channel alerting with many notification integrations (including email/SMTP and common chat and push services)
  • Public status pages with support for multiple pages and custom domain mapping
  • Charts and visibility features such as ping graphs and certificate/TLS information
  • Proxy support for checks and optional two-factor authentication

Use Cases

  • Track uptime and latency for websites, APIs, and internal services
  • Monitor homelab infrastructure and receive instant downtime notifications
  • Publish a simple public status page for customers or teammates

Limitations and Considerations

  • Network file systems such as NFS are not supported for the data directory and can cause instability

Uptime Kuma is a practical alternative to hosted uptime monitoring services when you want control over data and integrations. It is well-suited for individuals and teams that need straightforward monitoring, alerting, and shareable status pages.

81.5kstars
7.3kforks
View Details
#2
Cronicle

Cronicle

Open-source Node.js distributed task scheduler with web UI, real-time logs, multi-server failover, REST API and plugin support for arbitrary scripts.

Cronicle screenshot

Cronicle is a multi-server task scheduler and runner that provides a web-based UI for scheduling, executing and monitoring jobs. It supports scheduled, recurring and on-demand jobs across many worker servers, with real-time status, live logs and historical metrics.

Key Features

  • Multi-server architecture with auto-discovery, primary/backup roles and automatic failover
  • Visual date/time selector for single or recurring schedules with multi-timezone support
  • Support for targeted runs (single server, groups, random selection) and chaining events
  • Real-time job status, live log viewer and graphical performance metrics (CPU/memory, custom metrics)
  • Plugin API: plugins are plain executables (any language) communicating via JSON
  • External JSON REST API and API keys for remote triggering and automation
  • Storage-by-filesystem (JSON) by default; optional shared storage/backends supported for clusters
  • Simple install and Node.js/npm-based distribution with packaged CLI/control scripts

Use Cases

  • Run and monitor automated system maintenance, backups and periodic administration tasks
  • Orchestrate multi-step data processing workflows across multiple servers with chained events
  • Provide a lightweight replacement for cron with centralized logs, retries and real-time monitoring

Limitations and Considerations

  • Requires a POSIX environment (Linux/macOS); Windows is not a supported platform
  • Designed to run on Node.js Active LTS releases; may not work on current/non-LTS Node channels
  • Multi-primary clusters require shared storage (e.g., shared filesystem or supported storage backend) for reliable failover

Cronicle is a pragmatic, open-source scheduler focused on operability and extensibility. It emphasizes simple plugin integration, real-time visibility and predictable multi-server behavior for production task orchestration.

5.3kstars
468forks
View Details
#3
Dagu

Dagu

Portable, file-backed workflow orchestrator that defines DAGs in declarative YAML, runs anywhere as a single binary, and includes a modern Web UI for monitoring and control.

Dagu screenshot

Dagu is a lightweight workflow orchestration engine that runs as a single self-contained binary and provides a modern Web UI. Workflows are defined in a declarative YAML format and can execute local commands, SSH commands, and containerized steps with scheduling and retries.

Key Features

  • Single-binary installation with zero required external dependencies; uses file-based storage for definitions, logs, and history
  • Declarative YAML DSL for DAGs with scheduling (cron), timezones, conditional steps, retries, and repeat policies
  • Built-in Web UI: visual DAG view, real-time monitoring, execution history, log search, and an integrated YAML editor
  • Executors for shell commands, Docker containers, SSH remote execution, and HTTP steps
  • Distributed execution: coordinator/worker model and built-in queueing to scale across machines
  • Nested/sub-DAG support for reusable composition and inspectable sub-runs in the UI
  • Integrations and platform features: GitHub Actions executor, API key management and RBAC, webhooks, email notifications
  • Newer features include human-in-the-loop approvals and a Chat Executor for integrating LLMs into workflows

Use Cases

  • Replace scattered cron jobs with a visual, auditable DAG system for server maintenance and operational scripts
  • Orchestrate multi-step CI/maintenance workflows that mix local scripts, SSH calls, and containerized tasks
  • Run distributed data-processing pipelines across multiple worker nodes with centralized monitoring and retries

Limitations and Considerations

  • Secrets management is not provided as a full built-in secret store; references and integrations (KMS/Vault/OIDC) are discussed/tracked as planned features
  • While Dagu supports distributed runs and queueing, very large cloud-native deployments may require external orchestration or custom scaling strategies

Dagu is designed for teams that want powerful orchestration with minimal operational overhead and straightforward local-first deployment. It emphasizes portability, simple YAML-based definitions, and an integrated UI for everyday workflow operations.

3kstars
223forks
View Details
#4
CronMaster

CronMaster

Self-hosted web UI for managing cron jobs with human-readable schedules, script editing, live log streaming, and REST API with optional OIDC and API keys.

CronMaster is a self-hosted web interface for creating, viewing, and managing system cron jobs from a modern dashboard. It adds optional execution logging and live status updates, making cron-based automation easier to monitor and maintain.

Key Features

  • Create, view, clone, and delete cron jobs, including comments/notes
  • Human-friendly schedule presets and standard cron format support
  • Optional job execution logging with stdout/stderr, exit codes, timestamps, and automatic cleanup
  • Live updates via Server-Sent Events (SSE) for job status and long-running log streaming
  • Built-in script management for bash scripts and reusable snippets
  • System information dashboard (uptime, CPU, memory, network, and GPU when available)
  • Authentication options: password protection and SSO via OpenID Connect (OIDC)
  • REST API for cron management and system information, with optional API key auth

Use Cases

  • Manage and audit maintenance tasks (backups, cleanup jobs, renewals) on servers and homelabs
  • Centralize creation and monitoring of cron-driven automation with execution history
  • Provide a safer operational workflow for teams that need visibility into scheduled jobs

Limitations and Considerations

  • Docker-based setup commonly requires elevated privileges/root and direct host access to crontab files for full functionality
  • Jobs without logging are executed synchronously with a timeout, which may not suit long-running tasks

CronMaster is a practical option when you want cron scheduling to be approachable, observable, and API-accessible. It fits well for administrators who rely on cron but want better visibility, easier edits, and optional SSO-protected access.

943stars
21forks
View Details
#5
Lunalytics

Lunalytics

Self-hosted monitoring tool for uptime, TCP/HTTP checks, Docker monitoring, multi-user dashboards, incident management, SSO and alerting integrations.

Lunalytics screenshot

Lunalytics is an open-source monitoring application that runs a Node.js backend with a React + Vite frontend to monitor service uptime and health. It provides multi-user dashboards, incident management, role-based access control and integrations for notifications and single-sign-on. (github.com)

Key Features

  • Uptime and availability checks for HTTP(S), TCP, PING, JSON queries, PUSH checks and Docker containers.
  • Multi-user support with role-based access control (owners, admins, editors) and customizable user profiles and themes.
  • Custom status/dashboard pages and incident management flows for tracking outages and history.
  • Notification integrations (Apprise-compatible, Discord, Slack, Telegram, Email/SMTP, Home Assistant, Pushover, Webhooks and more).
  • Single sign-on support for external providers (Discord, Google, GitHub, Slack, Twitch) and pluggable/custom SSO setups.
  • Docker image and Docker Compose support plus simple self-hosting setup and a web-accessible API for monitors. (github.com)

Use Cases

  • Team uptime and latency monitoring for internal services, APIs and third-party endpoints.
  • Monitoring running Docker containers and containerized services on self-hosted infrastructure.
  • Public or private status pages and incident dashboards to share service health with colleagues or customers. (demo.lunalytics.xyz)

Limitations and Considerations

  • The project is actively developed and marked beta; some features are on the roadmap (expanded DB support, OAuth2 improvements, API tokens) and may be incomplete or change. (github.com)
  • Designed for small teams and self-hosting; production scalability characteristics (large-scale high-frequency checks, clustered backends) are not documented as fully supported yet.

Lunalytics is positioned as a developer-first, self-hostable alternative for teams that need multi-user monitoring and customizable status pages. A hosted demo and Docker image are available for evaluation and testing. (demo.lunalytics.xyz)

709stars
36forks
View Details
#6
gocron

gocron

Lightweight scheduler written in Go with a Vue.js web UI, YAML-based job configuration, cron expression support, per-job environment variables, and Docker deployment.

gocron is a lightweight task scheduler that executes recurring jobs defined in a YAML configuration. It combines a Go backend with a Vue.js frontend, supports cron expressions for timing, and exposes an API for job management.

Key Features

  • YAML configuration file to define defaults, multiple jobs, cron schedules, environment variables, and sequential commands per job
  • Cron expression support for precise scheduling and per-job overrides
  • Per-job environment variables passed into executed commands
  • Web UI built with Vue.js for viewing and managing jobs, plus API documentation and endpoints
  • Docker and Docker Compose friendly deployment with a ready container image
  • Ability to include and manage common backup tools via configuration (apprise, borgbackup, restic, rclone, rsync, kopia, etc.)

Use Cases

  • Schedule regular system maintenance tasks, updates, and cleanup scripts on a single host
  • Run automated backup jobs using configured backup tools at defined intervals
  • Execute periodic data collection, reporting, or integration scripts in homelabs and small server environments

Limitations and Considerations

  • Not designed as a distributed or highly-available scheduler; primarily single-node operation
  • Job execution runs commands on the host where the service is deployed, so isolation and security depend on container/host configuration
  • Lacks built-in enterprise features like clustering, advanced retry/backoff policies, and multi-tenant RBAC

gocron is suited for users who need a simple, file-driven scheduler with a web UI and Docker deployment. It is practical for homelabs, single-server automation, and scheduled backup workflows where lightweight configuration and local command execution are sufficient.

495stars
15forks
View Details

Why choose an open source alternative?

  • •Data ownership: Keep your data on your own servers
  • •No vendor lock-in: Freedom to switch or modify at any time
  • •Cost savings: Reduce or eliminate subscription fees
  • •Transparency: Audit the code and know exactly what's running