How to schedule jobs in Flask with Python APScheduler, cron jobs and RunMyJobs

Flask provides a flexible and efficient platform for job scheduling, allowing developers to better automate tasks, manage scheduled jobs and improve efficiency with APScheduler, cron jobs and extensions like RunMyJobs by Redwood.

Whether you’re executing tasks at regular intervals, using cron syntax for specific schedules or using powerful extensions, Flask gives you options to suit your job scheduling needs. By combining the simplicity and power of Flask with the versatility of Python, you can create robust and efficient web apps with automated job scheduling capabilities. In practice, most teams start small, maybe automating one report or cleaning up a recurring task, and expand as their app grows.

What is Flask? 

Flask is a micro web framework written in Python that allows developers to build web applications quickly and easily. It’s designed to be lightweight, flexible and easy to understand, so it’s great for developing web applications of varying complexities.

Flask provides tools and libraries to create web APIs, handle routing, manage databases and more. It can also be used to create RESTful APIs and microservices for deployment on a variety of platforms, including cloud-based tools like AWS. 

What is a Flask app? 

A Flask app is a Python module that contains the web application’s logic and routes. It serves as the entry point for the web application and provides the necessary configuration and functionality. 

With Flask, developers can define routes, handle requests and render HTML templates. Additionally, Flask supports extensions and plugins, so devs can enhance their web app with additional features like authentication, database integration and job scheduling.

Flask API 

Flask provides a simple and intuitive API for building web applications. Developers can define routes using decorators and specify the functions that handle those routes.

For example, the following Python code snippet demonstrates a basic Flask application that displays “Hello, World!” when accessing the root URL:

from flask import Flask

app = Flask(__name__)

@app.route('/')

def hello_world():

    return 'Hello, World!'

if __name__ == '__main__':

    app.run()

The @app.route(‘/’) decorator specifies that the following function should handle requests to the root URL (“/”). The hello_world() function is executed when a user accesses the root URL and returns the string “Hello, World!” as the response. Flask takes care of handling the HTTP request and response so devs can focus on the web app’s logic.

This is a tiny example, but it highlights why Flask is so approachable: you write a function, add a decorator and you’re off to the proverbial races. 

Flask and Python: Understanding the connection   

Flask is built on top of Python and can, thus, take advantage of its powerful features and libraries. It leverages the simplicity and readability of Python code for easy development of web applications. Python provides a vast ecosystem of libraries and modules that can be integrated into Flask web apps to extend functionality and enable job scheduling. Flask supports database integrations through libraries like SQLAlchemy, which can be used for managing data related to scheduled jobs, such as logging execution times or storing job configurations.

In regard to job scheduling specifically, Python’s datetime module can be used to handle date and time calculations, which is essential for scheduled jobs. And libraries like APScheduler and Celery can be integrated with Flask to facilitate scheduled tasks. For more complex scheduling needs Python’s threading module can be used alongside Flask to execute multiple tasks concurrently or manage background processes.

In real projects, the challenge usually isn’t writing the job itself, but deciding where it should run and how it fits into the rest of your app.

Scheduled jobs with Flask: APScheduler 

APScheduler is a popular Python library that provides a job scheduling mechanism for applications. It can be seamlessly integrated with Flask to automate tasks and execute them at predefined intervals. To use APScheduler with Flask, follow this tutorial using Python code:

1. Install APScheduler or the Flask-APScheduler extension from the Python Package Index (PyPi) using pip:

# Option A: Install the core APScheduler library

pip install apscheduler

# Option B: Install the Flask integration layer

pip install Flask-APScheduler

2. Import the necessary modules to create a Flask app:

from flask import Flask

from flask_apscheduler import APScheduler

from apscheduler.schedulers.background import BackgroundScheduler

from apscheduler.triggers.interval import IntervalTrigger

from apscheduler.triggers.cron import CronTrigger

app = Flask(__name__)

scheduler = APScheduler()

3. Configure the Flask app and scheduler:

if __name__ == '__main__':

    scheduler.init_app(app)

    scheduler.start()

    app.run()

4. Define and schedule a job function:

@scheduler.task('interval', id='my_job', seconds=10)

# The @scheduler.task decorator is provided by Flask-APScheduler. Standard APScheduler uses scheduler.add_job()

def my_job():

    print('This job is executed every 10 seconds.')

If you’ve ever set up a cron job by hand, APScheduler feels familiar but gives you a lot more control without much extra work. 

The id parameter ensures that only one instance of the job is running at a time, and the seconds parameter defines the interval between executions. The func parameter specifies the function to be executed. The args parameter can be used to pass arguments to the function being scheduled.

The Flask-APScheduler includes a REST API for managing scheduled jobs. Users can access docs for Flask APScheduler on GitHub.  

Scheduled jobs with Flask: Cron jobs 

Cron jobs are another popular method for scheduling recurring tasks in web applications. Flask allows users to leverage cron jobs through various libraries and tools, including the crontab module.

To use cron jobs with Flask, take the following steps outlined in the below tutorial using Python code.Install necessary dependencies, including the crontab module:

pip install python-crontab

Import required modules and define the Flask app:

from flask import Flask
from crontab import CronTab

app = Flask(__name__)
cron = CronTab(user='your_username')

Replace “your_username” in the above example with the actual username and configure the Flask app and cron job:

if __name__ == '__main__':
    app.run()

Define a cron job and schedule it with cron syntax:

job = cron.new(command='python /path/to/your_script.py')

The command parameter above specifies the command to be executed. Replace /path/to/your_script.py with the actual path to the Python script.

Next, set the schedule using cron syntax using the following command:

job.setall('*/5 * * * *')  

Ensure the system user has write permission to its crontab.

job.enable()

This example runs the job every 5 minutes.

cron.write()

Save the cron job.

Many developers still prefer cron for simple tasks because it’s predictable and easy to inspect when something goes wrong.

Scheduled jobs with Flask: Celery

Celery is a distributed task queue system that can be integrated with Flask to handle asynchronous task processing. Flask-Celery is a Flask extension that simplifies the integration process.

This extension provides a convenient way to define and execute tasks asynchronously within a Flask application. By combining Flask and Celery, users offload time-consuming tasks to the backend, improving overall performance and responsiveness of the application.

Here is a Python code tutorial for using Flask with Celery:

from flask import Flask
from celery import Celery

Create a Flask app.

app = Flask(__name__)

Configure Celery.

celery = Celery(app.name, broker='redis://localhost:6379/0', 
backend='redis://localhost:6379/0')

Sync Celery’s configuration with the Flask app.

celery.conf.update(app.config)

Define a Celery task.

@celery.task

def add_numbers(x, y):

    return x + y

Define a Flask route.

@app.route('/')

def home():

    result = add_numbers.delay(5, 10)

    return f'Task ID: {result.task_id}'

if __name__ == '__main__':

    app.run()

Celery takes a little more setup, but once it’s running, it handles the heavy lifting so your Flask app doesn’t have to.

Choosing the right method

There isn’t a single “best” option here. Each approach solves a different problem, and the right choice depends on how your application will look six months from now, not just today. 

If your priority is to keep everything inside your Flask process with minimal moving parts, Python APScheduler is usually the simplest fit. For example, “send a usage report every morning.” Use BackgroundScheduler for web applications, add jobs with scheduler.add_job(…) and start the engine with scheduler.start() inside your app factory or an init module, so it starts with the app.

Pick a trigger that matches your use case: IntervalTrigger for regular intervals, CronTrigger for specific times or a one-off run_date. 

For a concrete cron example: scheduler.add_job(send_report, ‘cron’, day_of_week=’mon-fri’, hour=8). 

Persist jobs with a job store, for example SQLAlchemy with SQLite/PostgreSQL or Redis/MongoDB, and remember to call scheduler.shutdown() gracefully on app stop so you don’t drop in-flight jobs or leave threads running. (APScheduler job stores may require additional pip packages depending on the backend.) This keeps small, predictable, scheduled jobs close to your API/backend code and app context, but be aware that jobs stop if the web process stops, unless you run the scheduler out-of-process or restart it with persistence. When developing locally, keep in mind that the debug reloader starts multiple processes, which can double-run APScheduler jobs.

APScheduler in app

Use APScheduler when you want simple in-process scheduling tied to your Flask app for things like API pings, cache warmers or report emails. For many teams, it’s the fastest way to get something working without adding new infrastructure.

Celery for scale

Choose Celery when you need distributed workers, robust retry semantics, rate limiting or workloads that shouldn’t run in-process — for example, image/video processing or long DB exports. In Flask, Celery uses a broker such as Redis or RabbitMQ and typically pairs with Celery Beat for schedules. 

APScheduler can also enqueue Celery tasks if you prefer its cron/interval ergonomics, but still want distributed execution so you schedule in app and execute on workers.

Once you’re running workers, scaling usually becomes a matter of adding more processes, which is one reason Celery has stayed popular for so long.

Cron at the OS level

Use cron for OS-level tasks that should stay independent of your web app lifecycle. For example, nightly maintenance scripts on a host. And, remember, cron won’t share Flask app context, so read config via env vars or a separate script.

If you need centralized orchestration across many apps and teams, SLAs and notifications, RunMyJobs provides enterprise workload automation across cloud and on-prem environments, languages and runtimes, complementing both APScheduler and Celery and helping reduce manual handoffs with SLA-based notifications.

Cron is old-school, but that’s part of the appeal: it rarely surprises you.

Most teams end up mixing approaches over time. That’s normal; your scheduling needs evolve as your application does.

RunMyJobs: More than a Flask job scheduler 

RunMyJobs offers event-driven job scheduling software supporting more than 25 scripting languages, including Python, with built-in syntax highlighting and parameter replacement for seamless job scheduling with Flask.

With the ability to automate job scheduling on any platform, RunMyJobs controls servers and runs scripts with lightweight agents for Windows, Linux, AIX, macOS and more. And creating new jobs in minutes is easy. Use the platform’s intuitive, low-code UI with a drag-and-drop editor and an extensive library of templates and wizards.

Enterprise teams can endlessly automate IT operations and any business process securely and reliably across applications, services and servers in the cloud, on premises or in hybrid environments from a single platform. RunMyJobs guarantees high performance of business applications with predictive SLA monitoring and notifications through email and SMS.

Preview what your Flask job scheduling could look like in a powerful workload automation solution: Demo RunMyJobs.