---
id: arq
version: "0.28.0"
license: MIT
license_treatment: permissive
maintenance: active
---

# arq — Job queues in python with asyncio and redis

License: permissive · Maintenance: active · Downloads: 4.7M/mo

## What it is and what it does

arq is a job queue library that lets you offload work from your main Python application to background workers using asyncio and Redis. It sits between your application and a Redis instance, allowing you to enqueue tasks that execute asynchronously on one or more worker processes. The package is designed for developers building async Python applications who need reliable background job execution without the overhead of a full message broker like RabbitMQ or Kafka.

The library is currently in maintenance-only mode, meaning it is stable and receives bug fixes and security updates but is not actively gaining new features. It supports Python 3.9 through 3.14 and has a permissive MIT license. Its two runtime dependencies—click and redis—are both widely used and well-maintained, keeping the installation footprint small.

Use it for:

- Offload long-running computations from a web request handler to execute asynchronously in the background
- Distribute batch processing tasks across multiple worker processes on the same or different machines
- Schedule periodic or one-time jobs to run at specific times without blocking the main application
- Build a microservice that consumes work items from a shared Redis queue and processes them in parallel
- Implement retry logic and error handling for tasks that may fail transiently

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

arq provides a job queue system for Python that uses asyncio and Redis to run background tasks asynchronously and distribute work across multiple workers.

Yes, if you need a lightweight async job queue backed by Redis and are comfortable with maintenance-only mode. The low install friction, permissive license, broad Python version support, and zero known vulnerabilities make it a solid choice for background task processing in async applications. Not suitable if you require active feature development or prefer a more feature-rich task queue.

## Install

pip install arq
uv add arq
poetry add arq

## Installing arq

Before you install: Low friction installation with only two runtime dependencies (click and redis). The package is in maintenance-only mode but remains actively maintained; the last commit was recent and the repository is not archived, suggesting stability rather than abandonment.

License in practice: MIT license is permissive, allowing use in commercial and proprietary projects with minimal restrictions beyond attribution.

Quickstart:

pip install arq

from arq import create_pool
import asyncio

async def my_job(ctx):
    return 'done'

async def main():
    redis = await create_pool('redis://localhost')
    job = await redis.enqueue_job('my_job')

asyncio.run(main())

Requires a running Redis server accessible at the configured URL; Python 3.9 or later.

Verify before relying:

- Whether maintenance-only mode implies no new features or breaking changes will be accepted
- Performance characteristics and scalability limits for typical workloads
- Whether the package handles task retry logic, scheduling, or only basic queueing

## Package facts

- License: MIT (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: active
- Downloads: 4.7M/month (top 5,000 on PyPI)
- Known vulnerabilities: none known

## Tags

async job queue python, background task queue redis, distributed task processing, asyncio worker pool, redis-backed job scheduler, python async task runner, background job management, async-first, redis-backed, task-queue

[View on SkillFed](https://skillfed.io/packages/arq) · [View on PyPI](https://pypi.org/project/arq/)