Free, Open Source Job Queue for Your Stack

Background jobs.
Your stack.

Background jobs for Node.js, Deno, Python, PHP, Go, Rust, Elixir and Bun. Free, open source, hosted by you.

Run your first job Explore the source

Your application

Node.js Deno Python PHP Go Rust Elixir Bun

add a jobTCP :6789

bunqueue serverRuns on Bun. Runs on your infrastructure.

MIT

process a jobTCP :6789

Your workersThe same language, or a different one.

The server runs on Bun. Your application keeps its runtime.

Free, including the server.Every queue feature ships under MIT.

Your infrastructure.Run locally, on a VPS, or in Docker.

Bun app? Embed it.Queue and worker in one process.

Your first job, end to end.

Choose how to run the queue. Both options are free, with the same core queue features.

Server + your language
Embedded in Bun

With Docker running, choose a base and copy the command. No Bun installation needed.

The default: a compact musl base with a shell and apk. Same bunqueue features on AMD64 and ARM64.

docker run -d --name bunqueue \
  --restart unless-stopped \
  -p 127.0.0.1:6789:6789 \
  -p 127.0.0.1:6790:6790 \
  -v bunqueue-data:/app/data \
  egeominotti/bunqueue:alpine

A full Debian base with glibc, a shell and apt. Same bunqueue features on AMD64 and ARM64.

docker run -d --name bunqueue \
  --restart unless-stopped \
  -p 127.0.0.1:6789:6789 \
  -p 127.0.0.1:6790:6790 \
  -v bunqueue-data:/app/data \
  egeominotti/bunqueue:debian

Debian with glibc, a shell and apt, with fewer bundled utilities. Same bunqueue features on AMD64 and ARM64.

docker run -d --name bunqueue \
  --restart unless-stopped \
  -p 127.0.0.1:6789:6789 \
  -p 127.0.0.1:6790:6790 \
  -v bunqueue-data:/app/data \
  egeominotti/bunqueue:slim

Required runtime libraries only. No shell or package manager. Same bunqueue features on AMD64 and ARM64.

docker run -d --name bunqueue \
  --restart unless-stopped \
  -p 127.0.0.1:6789:6789 \
  -p 127.0.0.1:6790:6790 \
  -v bunqueue-data:/app/data \
  egeominotti/bunqueue:distroless

Check that the server is ready:

curl --fail http://127.0.0.1:6790/health

Client connection: 127.0.0.1:6789 TCP
HTTP API: 127.0.0.1:6790 HTTP
Storage: bunqueue-data Docker volume

Ports stay local to your machine. SQLite data persists in the volume when you replace the container. Run one variant at a time.

These tags follow new releases. Pin a version or digest for deployment.

In a terminal with Bun installed, start the included server. Keep it running.

bunx bunqueue start --host 127.0.0.1 --data-path ./bunqueue.db

Client connection: 127.0.0.1:6789 TCP
HTTP API: 127.0.0.1:6790 HTTP
Storage: ./bunqueue.db SQLite

This is a local process on your machine. The server is included in the MIT-licensed package.

Docker & deployment options

2 Connect your app and worker

Open another terminal. Install a client, save the example, then run it.

npm install bunqueue-client

import { Queue, Worker } from 'bunqueue-client';

const options = {
  embedded: false,
  connection: { host: '127.0.0.1', port: 6789 },
};
const queue = new Queue('emails', options);

const worker = new Worker(
  'emails',
  async (job) => {
    console.log('Processing:', job.data.to);
    return { sent: true };
  },
  options
);

worker.on('error', (error) => console.error(error));
await queue.add('welcome', { to: 'hello@example.com' });

node jobs.mjs

deno add npm:bunqueue-client

import { Queue, Worker } from 'bunqueue-client';

const options = {
  embedded: false,
  connection: { host: '127.0.0.1', port: 6789 },
};
const queue = new Queue<{ to: string }>('emails', options);

const worker = new Worker<{ to: string }>(
  'emails',
  async (job) => {
    console.log('Processing:', job.data.to);
    return { sent: true };
  },
  options
);

worker.on('error', (error) => console.error(error));
await queue.add('welcome', { to: 'hello@example.com' });

deno run --allow-net --allow-env --allow-sys=hostname jobs.ts

pip install bunqueue-client

from bunqueue import Queue, Worker

connection = {"host": "127.0.0.1", "port": 6789}
queue = Queue("emails", **connection)
queue.add("welcome", {"to": "hello@example.com"})
queue.close()

def process(job):
    print("Processing:", job.data["to"])
    return {"sent": True}

Worker("emails", process, **connection).run()

python jobs.py

You should see Processing: hello@example.com. Your application and worker use the same queue name and TCP address.

PHP, Go, Rust, Elixir & all SDK guides

Run everything in your Bun process

Use embedded mode when your app and worker run together on Bun. The queue engine lives inside your application.

bun add bunqueue

Runtime: Bun
Separate server: Not needed
Connection address: Not needed

Set embedded: true on both the queue and worker. The example keeps jobs in memory; configure SQLite persistence to recover work after a restart.

Add a job and process it

import { Queue, Worker } from 'bunqueue/client';

const queue = new Queue<{ to: string }>('emails', { embedded: true });

const worker = new Worker<{ to: string }>(
  'emails',
  async (job) => {
    console.log('Processing:', job.data.to);
    return { sent: true };
  },
  { embedded: true }
);

worker.on('error', (error) => console.error(error));
await queue.add('welcome', { to: 'hello@example.com' });

bun jobs.ts

Read the full quickstart

The useful parts. All included.

Start with a queue and a worker. Add the controls your workload needs.

Make failed work retryable.

Retries with backoff, stall recovery and a dead letter queue you can inspect and replay.

Retries & recovery

Control what runs next.

Priorities, delayed jobs, rate limits, concurrency controls and FIFO groups.

Queue controls

Schedule and coordinate.

Cron schedules and parent-child job flows. A separate workflow engine adds in-process orchestration on Bun.

Flows & dependencies

See what is happening.

Job queries, Prometheus metrics, health probes and events. Connect AI tools through the native MCP server.

Monitoring & operations

Official clients share the Queue/Worker/Flow core. Check the SDK capability matrix for language-specific APIs.

Start small. Keep your options.

Choose storage when you need it. Your application keeps the same queue API.

Try it in memory

The default. Nothing to provision. Jobs are ephemeral and disappear when the process exits.

Persist to SQLite

One file, owned by one process. Run embedded on Bun or connect clients to a standalone server.

Run multiple brokers

Use PostgreSQL as the shared store for several active servers. Operate the database and routing yourself.

Storage, durability & deployment trade-offs

Coming from BullMQ?

A familiar way to work.

Keep the Queue and Worker mental model. bunqueue uses its own engine and protocol, with SQLite or PostgreSQL for persistence.

Read the migration guide

Moving a Node.js app?Use bunqueue-client and connect to a bunqueue server. Your application stays on Node.js.

Check the differences first.Review compatibility and scheduling behavior in the full comparison. Explore the benchmark methodology for performance evidence.

A few things, made clear.

The cost, the name, and the connection.

Is there anything I have to pay for?

bunqueue is completely free and open source under the MIT license. The server, clients and queue features are included. There is no paid plan or feature paywall. If you rent a server or database, you pay your infrastructure provider.

Why is it called bunqueue?

The core engine uses Bun and its native APIs. The standalone server and embedded runtime require Bun. Network clients use their own runtime, including Node.js, Deno, Python, PHP, Go, Rust and Elixir.

Do I need a bunqueue account or a hosted service?

No. Start the included server on your machine or your own infrastructure, then point your client at its host and TCP port. A Bun application can also use embedded mode without a separate server.

Why is my client not connecting?

For server mode, start the server first and use a reachable hostname with TCP port 6789. Port 6790 is the HTTP API. Inside Docker, localhost refers to that container. For embedded mode, run on Bun and set embedded: true on both Queue and Worker.

Your jobs. Your infrastructure.

Free and open source, from the first local job to production.

Explore the documentation

Background jobs.Your stack.

Your first job, end to end.

1 Run your own server

2 Connect your app and worker

Run everything in your Bun process

Add a job and process it

The useful parts. All included.

Make failed work retryable.

Control what runs next.

Schedule and coordinate.

See what is happening.

Start small. Keep your options.

Try it in memory

Persist to SQLite

Run multiple brokers

A familiar way to work.

A few things, made clear.

Your jobs. Your infrastructure.

Background jobs.
Your stack.