HTTP-based task queue, cron jobs and workflows.
Workly is the open-source HTTP task queue. It delivers tasks to your endpoints and retries them until they succeed. It also runs your cron jobs and multi-step workflows as HTTP calls, and shows you exactly what happened. No workers, no broker, no guesswork. Built for your coding agent, with every queue, schedule and workflow available over MCP.

Enqueue a URL and a payload. Workly calls your endpoint.
Each task is delivered to its URL as a signed HTTP request, a POST by default. Answer 2xx and it's done; anything else is retried with backoff until it succeeds or runs out of attempts. Your handler is a route in the app you already deploy, in any language, so there is no worker process to run.
- Idempotency keys. Enqueue with the same key twice and you get the first task back, so your own code can retry the enqueue safely.
- Task groups → Fan out into hundreds of tasks and get one callback when the last one finishes, with how many succeeded and failed.
from workly import Workly
workly = Workly() # WORKLY_URL, WORKLY_API_KEY
workly.tasks.enqueue(
"emails",
url="https://api.example.com/send-email",
payload={"user_id": 123},
idempotency_key="welcome-123",
)import { Workly } from '@worklydev/sdk';
const workly = new Workly(); // WORKLY_URL, WORKLY_API_KEY
await workly.tasks.enqueue('emails', {
url: 'https://api.example.com/send-email',
payload: { user_id: 123 },
idempotencyKey: 'welcome-123',
});curl -X POST https://api.workly.run/v1/queues/emails/tasks \
-H "Authorization: Bearer $WORKLY_API_KEY" \
-d '{
"url": "https://api.example.com/send-email",
"payload": {"user_id": 123},
"idempotency_key": "welcome-123"
}'See every attempt in the dashboard, and get an alert when a task fails.
Every attempt is kept with its status code, error, response body and timing. Failed tasks are grouped by error, and each one says why Workly gave up and which setting to change.
When a task or schedule run fails for good, Workly alerts you by email or Slack within about a minute, with the most common errors and a link to the failures. A queue that keeps failing sends at most one alert every 30 minutes, and retries that later succeed never alert.

Everything you'd otherwise build around a queue is built in.
Retries with backoff
Jitter, Retry-After honoured, and a per-queue rule for what to retry.
Rate and concurrency limits
Per second and in flight, so a backlog never floods your endpoint.
Delayed tasks
Run a task in ten minutes or at a set time.
Auto-pause →
When its endpoint goes down, a queue pauses itself and resumes once it's back, without using up attempts.
Callbacks →
A POST with the outcome when a task finishes.
Failures grouped by error
Fix the handler, then retry one group or the whole queue.
Signed deliveries
An HMAC signature on every request, checked by the SDKs in one call.
Configuration as code →
Queues, schedules and workflows in workly.yaml.
SDKs and a CLI
Python, TypeScript and a CLI. Or plain HTTP.
Schedules call your endpoints on a cron timetable.
Each run is retried with backoff, so a 503 at 03:00 doesn't cost you the night's report, and every run is recorded with its attempts. A run that didn't go says why. Use schedules in place of Kubernetes CronJobs or Cloud Scheduler, on the same server that runs your queues.
- Runs never overlap. A run that comes up while the last one is still going is skipped, and recorded with the reason, so a slow job never runs twice at once. Set
overlap: allowif it should. - A callback when each run finishes. Workly POSTs the outcome to your
on_completeURL: succeeded or failed, attempts and the last status code. Mark the report as sent, or tell the user it failed.
workly.schedules.put(
"nightly-report",
cron="0 3 * * *",
timezone="Europe/Stockholm",
url="https://api.example.com/reports/nightly",
on_complete={"url": "https://api.example.com/reports/done"},
)await workly.schedules.put('nightly-report', {
cron: '0 3 * * *',
timezone: 'Europe/Stockholm',
url: 'https://api.example.com/reports/nightly',
onComplete: { url: 'https://api.example.com/reports/done' },
});curl -X PUT https://api.workly.run/v1/schedules/nightly-report \
-H "Authorization: Bearer $WORKLY_API_KEY" \
-d '{
"cron": "0 3 * * *",
"timezone": "Europe/Stockholm",
"url": "https://api.example.com/reports/nightly",
"on_complete": {"url": "https://api.example.com/reports/done"}
}'- Oct 4, 03:00succeeded200 · 1.2s
- Oct 3, 03:00succeeded200 after 2 attempts
- Oct 2, 03:00skippedprevious run still going
- Oct 1, 03:00failed503 Service Unavailable
Run jobs that depend on each other without a workflow engine.
A workflow is a set of your endpoints that run in order: each step starts once the steps it depends on have succeeded. Every step is an ordinary task, so it's retried, signed, rate-limited and recorded like one. There is nothing new to run, and the run's graph shows where it is and why.
- Fan out, then wait. A step can hand off to a task group of hundreds of tasks, and the next step waits for all of them.
- Retry from where it failed. Fix the handler and retry the run; steps that succeeded aren't sent again.
- On a schedule. Start a workflow from cron, and a slow run never overlaps the next.
workflows:
daily-refresh:
steps:
- name: prices # fans out over a task group
url: https://api.example.com/jobs/start-price-update
- name: fx
url: https://api.example.com/jobs/refresh-fx
- name: analytics
url: https://api.example.com/jobs/rebuild-analytics
depends_on: [prices, fx]
- name: notify
url: https://api.example.com/jobs/notify
depends_on: [analytics]
schedules:
nightly-refresh:
cron: "0 3 * * *"
timezone: Europe/Stockholm
workflow: daily-refresh
Your coding agent can debug your queues.
Every Workly server speaks MCP. Point Claude Code, Cursor or Codex at it and your agent can read failures, replay a delivery against your local handler, and retry once the fix is in. Read-only unless you say otherwise.
Set up Workly for me. Workly (https://workly.run) is a hosted HTTP task queue and scheduler: it delivers HTTP requests to my endpoints with retries, runs cron schedules, and records every attempt. 1. Add Workly's MCP server to this app: https://api.workly.run/mcp (streamable HTTP, OAuth sign-in, no API key needed). Use this app's own way of adding a remote MCP server. 2. Tell me how to start the sign-in here. In the browser I'll sign in or create an account and pick a workspace. 3. Once connected, call get_docs to learn how Workly works, then help me enqueue a first task or create a schedule for something in this project. If this app can't connect to remote MCP servers, read https://workly.run/llms.txt instead and help me use Workly's API with an API key from https://console.workly.run.
claude mcp add --transport http --scope user workly https://api.workly.run/mcp claude mcp login workly
codex mcp add workly --url https://api.workly.run/mcp
{
"mcpServers": {
"workly": {
"url": "https://api.workly.run/mcp"
}
}
}- workly · get_queue invoices
- workly · get_task task_01J9ZK3M5Q…
212 tasks have failed with HTTP 503 since 14:02. The latest one's response body is "connection refused: billing-db:5432", so the handler can't reach its database. Separately, 3 tasks failed with 422 because their payloads have no customer_id: those are bad records, not an outage. Fix the database connection and I'll retry the 503s.
- workly · list_workflow_runs daily-refresh
- workly · get_workflow_run wfr_01J9ZP…
- workly · get_group grp_01J9ZP…
It is waiting on the prices step, which handed off to a group of 500 tasks: 412 have succeeded and 88 are being retried, because the price API answers 429 with Retry-After: 600. Nothing has failed. analytics and notify start once the group completes, in about ten minutes.
- workly · retry_failed_tasks invoices "HTTP 503 Service Unavailable"
- workly · wait_for_task task_01J9ZK3M5Q…
Retried the 212 tasks that failed with HTTP 503. The first one succeeded on its first attempt: 200 in 340 ms. I left the 3 tasks that failed with 422 alone: they need their payloads fixed, and a retry would fail the same way.
Keep queues, schedules and workflows in a file next to your code.
Declare them in workly.yaml, review changes in pull requests, and apply them with workly deploy from your laptop or CI. workly plan shows what will change, setting by setting, before anything does.
- Checked in pull requests.
workly validateruns the server's own validation with no server or API key. - One file for every environment. Values like
${API_URL}come from environment variables, so the same file serves staging and production, and tokens in headers stay out of the repo.
version: 1
queues:
stock-prices:
max_concurrency: 10
rate_per_second: 2
financial-data:
max_concurrency: 5
timeout_seconds: 120
schedules:
daily-stock-prices:
cron: "0 22 * * 1-5"
timezone: Europe/Stockholm
url: ${API_URL}/jobs/prices
refresh-financial-data:
cron: "0 6 * * *"
timezone: Europe/Stockholm
url: ${API_URL}/jobs/financials$ workly plan
Plan for workly.yaml on https://api.workly.run:
+ create queue stock-prices
~ update queue financial-data
max_concurrency: 3 → 5
timeout_seconds: 30 → 120
+ create schedule daily-stock-prices
~ update schedule refresh-financial-data
cron: 0 5 * * * → 0 6 * * *
2 to create, 2 to update, 0 unchanged.The dev server is the production server.
workly dev works exactly like production, because it is the same server. There is no emulator to drift from the real thing: what works on your laptop works in your cluster and on workly.run, and moving between them means changing environment variables, not code.
On your laptop
workly devSQLite, no configuration, no Docker. The dashboard and an echo target are on localhost:7337.
Quickstart →In your cluster
workly serveOne container plus Postgres, next to your apps. Endpoints on your private network are just URLs.
Self-hosting guide →Hosted at workly.run
WORKLY_URL=https://api.workly.runThe same server, run for you: backups, upgrades and longer history, with nothing to operate.
Get started free →Let us run it for you.
Hosted Workly is open, with a free Hobby plan: the same server, with backups, upgrades and team access handled for you. Sign in with your email and you have a workspace and an API key in a minute. Self-hosting stays free, forever. See pricing.