Workly

QStash alternative

An HTTP task queue you can also run yourself.

QStash got the model right: your route is the consumer, and the queue calls it, with retries, delays and schedules. Workly works the same way, but it's open source. Run it on your laptop, next to your services, or hosted at workly.run, and when a task fails, see every attempt and retry the whole group once it's fixed.

Same model. You choose where it runs.

QStash runs only on Upstash. Workly is one Apache-2.0 server, and the API, SDKs and dashboard are the same wherever it runs.

On your laptop

workly dev runs the production server on SQLite, with the dashboard. No tunnel, no license limits.

In your infrastructure

One binary plus Postgres, next to your services, delivering to private addresses too. Free, forever.

Hosted

workly.run runs the same server. Moving between them means changing WORKLY_URL and the API key.

Workly and QStash compared.

Both push HTTP requests, deliver at least once, sign every request and deduplicate on enqueue. The differences are in where it runs, where the settings live, and what's kept afterwards.

QStashWorkly
DeliveryHTTP push to your endpointHTTP push to your endpoint
Runs onUpstash's service, in its EU or US regionYour laptop, any cloud or cluster, or hosted at workly.run
SourceProprietaryOpen source, Apache-2.0
Local developmentqstash dev: an in-memory server, licensed for development and testing onlyworkly dev: the same server as production, on SQLite, with the dashboard
EndpointsPublic URLs; locally, the dev server or a tunnelSelf-hosted, anything it can reach, private networks included. Hosted: public URLs
SettingsPer message, in headers: retries, delay, timeout, flow controlPer queue, in workly.yaml or the API; a task can override attempts and timeout
Retries4 attempts by default (3 retries), exponential up to a day, or your own formula; honours Retry-After5 attempts by default, backoff with jitter; honours Retry-After; you choose whether 4xx is retried
Rate limitsFlow Control: rate per period and parallelism, per key you chooserate_per_second and max_concurrency per queue
OrderingQueues deliver one at a time, in orderNo ordering guarantee; set max_concurrency: 1 for one at a time
After the last retryDead letter queue, kept 3 days to 3 months by planKept as failed with every attempt, grouped by error; an alert by email or Slack; retry one or a whole group once the fix is in
CallbacksPer message: a callback with each response, and a failure callbackPer task or schedule: a callback with the outcome each time it finishes; the response stays in its attempt history
DeduplicationDeduplication ID or content hash, for 10 minutesidempotency_key, for as long as the task is kept, and a stable Workly-Task-Id header
SchedulesCron, UTC unless prefixed with CRON_TZ=Cron with a timezone, overlap policy, run history and run-now
Fan-out and fan-inURL Groups send one message to many endpoints; fan-in is in Upstash WorkflowTask groups: enqueue many, get one callback with the counts when all have finished; workflows can wait for one before the next step
WorkflowsUpstash Workflow, a separate product: steps written as code in one function, with sleeps, waits for events and results between stepsDAGs of HTTP steps in workly.yaml or the API, each step a task in your queues; retry a failed run from where it stopped
VisibilityConsole logs with responses, kept 3 to 14 days by plan; Prometheus and Datadog with Prod Pack (+$200 a month)Dashboard with every attempt, failures grouped by error, MCP that can retry and pause, and Prometheus metrics when self-hosted
Request length15 minutes on the free plan, 2 hours pay-as-you-go, up to 12 hours on fixed plansUp to 30 minutes per attempt
Price1,000 messages a day free, then $1 per 100k; each retry counts as a messageFree to self-host. Hosted: 100k tasks a month free; a task counts once, however many attempts

QStash behaviour and limits from Upstash's documentation and pricing page, November 2026.

Settings move from each message to the queue.

With QStash, every publish says how to retry and how fast to deliver. With Workly, the queue says it once, in a file you deploy with your app, and every enqueue to it follows. Change the rate in one place, not in every caller.

QStash
import { Client } from "@upstash/qstash";

const qstash = new Client(); // QSTASH_TOKEN

// Every call carries its own settings
await qstash.publishJSON({
  url: "https://api.example.com/tasks/send-email",
  body: { userId },
  retries: 5,
  deduplicationId: `welcome-${userId}`, // for 10 minutes
  flowControl: { key: "emails", rate: 5, parallelism: 10 },
});
Workly
import { Workly } from "@worklydev/sdk";

const workly = new Workly(); // WORKLY_URL, WORKLY_API_KEY

// The queue holds the settings; the call names it
await workly.tasks.enqueue("emails", {
  url: "https://api.example.com/tasks/send-email",
  payload: { userId },
  idempotencyKey: `welcome-${userId}`, // for as long as the task is kept
});
workly.yaml
# workly.yaml, applied with `workly deploy`
version: 1
queues:
  emails:
    max_attempts: 5
    rate_per_second: 5
    max_concurrency: 10

And schedules know what ran.

Both run cron in your timezone. Workly also decides what happens when last night's run is still going, keeps each run with its attempts, and has a button to run one now.

QStash
await qstash.schedules.create({
  destination: "https://api.example.com/tasks/nightly-report",
  cron: "CRON_TZ=Europe/Stockholm 0 3 * * *",
});
Workly
# workly.yaml
version: 1
schedules:
  nightly-report:
    cron: "0 3 * * *"
    timezone: Europe/Stockholm
    url: https://api.example.com/tasks/nightly-report
    overlap: skip  # if last night's run is still going

See why a task failed, then fix them all at once.

Every task keeps its attempts: status code, error, response body and timing. Failed tasks are grouped by error, so after a bad deploy you fix the handler and retry the whole group, from the dashboard, the CLI or your coding agent over MCP. Queue depth, delivery rate and the age of the oldest due task are in the dashboard too.

A failed task in the Workly dashboard, explaining why it failed, with every attempt's response.

When QStash is the better choice.

You need an SLA and a SOC 2 report today

With Prod Pack, QStash has a 99.99% uptime SLA, a SOC 2 Type 2 report and encryption at rest, in an EU or a US region. If a security review needs those now, QStash has them.

You need what Workly does not have

Ordered queues, URL Groups that fan one message out to many endpoints, the response body in each callback, and requests that run for hours. Workly has none of these; its callbacks report the outcome, and its attempts stop at 30 minutes.

Volume is small or spiky

Pay-as-you-go pricing scales to zero: a quiet month costs cents. Hosted Workly is free up to 100k tasks a month, but beyond that it is a monthly plan.

Questions

Both deliver HTTP requests. What is the difference?
Where it runs and what you see. QStash runs only on Upstash. Workly is open source: run it next to your services, on your laptop with the same server as production, or hosted at workly.run. And Workly keeps every attempt of every task, groups failures by error and lets you retry a group once the fix is in.
Can I self-host QStash?
No. The QStash CLI runs a development server, but its license allows only development, testing and CI, and it keeps everything in memory. Workly is the same Apache-2.0 server everywhere: in development, self-hosted in production, or hosted.
Does Workly work from Vercel, Cloudflare Workers or Lambda?
Yes. Enqueueing is one HTTP request, and the TypeScript SDK runs anywhere with fetch. Your handlers are ordinary routes, and the signature check works with any Fetch API request. Keep each attempt under the platform’s own time limit, and Workly’s 30 minutes.
What about Upstash Workflow, Inngest or Trigger.dev?
Those run multi-step functions written as code, with sleeps, waits for events and state passed between steps. Workly's workflows are a DAG of your endpoints declared up front: each step is an ordinary task, a step can fan out over a task group, and a failed run retries from where it stopped, but there are no conditions or outputs between steps. If your steps branch or carry state, those tools fit better.
How much changes in my handlers?
Little. Both deliver a POST to your route and expect a 2xx. Swap Upstash's signature check for Workly's verifySignature, and use the Workly-Task-Id header where you used Upstash-Message-Id to make handlers idempotent.
How do I move over gradually?
Endpoint by endpoint. Create a queue for one, enqueue to it with Workly instead of publishing to QStash, and accept both signatures on the route while messages already in QStash drain. Move schedules once their tasks are on Workly.

Try it in five minutes.

pip install "workly[cli]" and workly dev give you a server and dashboard on your laptop, with nothing else to start. Or sign in to hosted Workly and get a workspace and an API key in a minute, free on the Hobby plan.