Process background tasksProcess background taskswith confidence

Web UI dashboard

Simple and ergonomic API

Apalis provides production-ready task processing with minimal boilerplate, letting you focus on business logic.

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
struct Email {
to: String,
subject: String,
}

async fn send_email(task: Email) {
// Do something
}

#[tokio::main]
async fn main() -> Result<()> {
let worker = WorkerBuilder::new("rango-tango")
.backend(backend)
.build(send_email);
worker.run().await?;
}

Feature rich

Apalis offers a complete developer toolset for background processing in rust. Process background tasks confidently, concurrently and fearlessly

Functional
Functional programming approach with dependency injection with no macros.

Web-based UI
Intuitive web interface for managing and monitoring background tasks.

Web UI for workers

Compatible with popular backends
Easily connect your projects to databases and services.

Flexible Middleware
Provides middleware support build on top of tower

Workflow Orchestration
Coordinate complex background tasks with ease.

Fetch unpaid users
AndThen • and_then(fetch_unpaid)
Remove unsubscribed
FilterMap • filter_map(remove_unsubs)
Generate report
Fold • fold(build_report)
Email report
AndThen • and_then(email_report)

Observability
Gain insights into your background tasks with built-in instrumentation.

Pricing built for every developer

Choose a plan that fits your background processing requirements, from individuals starting out to
growing professionals and large organizations.

Free
$0
/year
Perfect for individuals starting their journey.
Get Started today:
Open source under MIT/Apache license
Cron, Postgres, Redis and other common backends
Realtime logs
Support via Github issues
Basic Web UI for observability
Pro
Popular
$999
/year
Ideal for professionals.
Everything in Free +
Batch processing support
Pausable Queues
Improved perfomance via bulk inserts
Enhanced Web UI
Observability for Cronjobs
Custom feature requests
Custom telemetry backends
1 Application
Priority support
Enterprise
Custom
Tailored solutions for teams.
Everything in Free +
Encryption support
Unlimited Applications
Advanced workflow coordination
Dedicated account support
Collaborative coding with our team
Priority Custom feature requests
Logs and metrics retention
Enterprise-grade security and compliance
All Pro features

Developers love it

Hear how developers ship products faster
and build with confidence using apalis and apalis based backends

Apalis was the missing puzzle piece for me migrating from another ecosystem, and has excelled at its job. I was looking for something like it for years!
Kat Marchán avatar
Kat Marchán
Fastly
we are using apalis in Vodafone Oman for Whatsapp Bot Project. it represents the core of the entire bot.
Anwar Al Jahwari avatar
Anwar Al Jahwari
Vodafone Oman
I have been using Apalis for my project Ryot from the beginning. It has is extremely feature packed with background jobs, delayed jobs, crons and stepped functions. Building entire workflows with Apalis is very easy.
IgnisDa avatar
IgnisDa
Ryot

Frequently Asked Questions

Everything you need to know about Pointer and how it can transform your development workflow

What is Apalis and who should use it?
Apalis is a Rust-first background job and task processing framework designed for developers building reliable, scalable systems. It’s ideal for backend engineers, platform teams, and infrastructure-focused projects that need asynchronous job execution, worker orchestration, and strong type safety without sacrificing performance.
What problems does Apalis solve?
Apalis helps you run background jobs such as email delivery, data processing, scheduled tasks, and long-running workflows. It provides a structured way to define jobs, execute them with workers, manage retries, handle failures, and coordinate concurrent task execution in production-grade Rust applications.
How does Apalis handle workers and job execution?
Apalis uses a worker-based execution model where workers continuously pull jobs from a backend and process them asynchronously. It supports configurable concurrency, graceful shutdowns, retries, timeouts, and middleware, giving you fine-grained control over how jobs are executed and supervised.
Which storage backends are supported?
Apalis is backend-agnostic and works with multiple storage providers through dedicated crates. Popular options include PostgreSQL, Redis, SQLite, and in-memory backends. This flexibility allows you to choose the best storage layer for your workload, from local development to large-scale production systems.
Can Apalis be integrated into existing Rust applications?
Yes. Apalis is designed to integrate cleanly with existing Rust applications and async runtimes like Tokio. It works well alongside popular web frameworks such as Axum and Actix, making it easy to add background processing to APIs, services, and microservice architectures.
Is Apalis suitable for production use?
Absolutely. Apalis focuses on reliability, observability, and correctness. It supports structured error handling, retries, graceful shutdowns, and extensibility via middleware. Its strongly typed API and async-first design make it a solid choice for production workloads that demand performance and safety.