Upstash QStash is the cheapest standalone HTTP message-delivery service in its class. Pay-as-you-go at a single dollar per 100K messages undercuts every managed background-jobs platform for plain fire-and-forget delivery, and the free 500 messages per day covers hobby projects without a card. Teams stay until their workloads either outgrow simple delivery (multi-step durable workflows, idempotency, fan-out) or until they need webhook-specific tooling QStash never built (replays from history, payload transformations, signature verification with rotation). The cost flips for four distinct exit reasons.
Where alternatives win
Hookdeck is the webhook-specialist alternative with replays, filtering, transformations, and signature verification built into the dashboard; the right pick when your actual workload is webhooks at production volume and the recovery story matters more than the per-message rate.
Inngest is the durable-workflow upgrade with TypeScript-first Step Functions, automatic retries, fan-out and fan-in, and a local-dev replay loop; the right pick when QStash's HTTP-only model stops fitting and the workload became multi-step.
Trigger.dev keeps the durable-execution shape but bills per run rather than per event plus invocation, so the monthly cost is predictable across fan-out patterns; the right pick when TypeScript-first managed workflows on a smaller entry tier matter more than ecosystem breadth.
Hatchet is MIT-licensed and runs on Postgres rather than Redis, with TypeScript, Python, and Go SDKs; the right pick when self-host on infrastructure you already operate beats adding another managed vendor.
By Subrupt EditorialPublished Reviewed
QStash users do one thing well: POST a payload to a single HTTP endpoint and trust QStash to deliver it later with retries and exponential backoff. No SDK, no event-step abstraction, no worker process. Scheduled jobs, async API responses, decoupling expensive work from request handlers. Pay-as-you-go at the lowest published rate in the category is why most teams picked it. Almost everyone stays cheap.
Two situations force a rethink. The first is workload shape: the job that started as one POST grows into a multi-step workflow with idempotency requirements, fan-out across user accounts, and recovery semantics QStash never built. The second is webhook density: the team is firing and receiving thousands of webhooks daily and needs replays from history, payload transformations, and observability QStash never built.
The four picks below cover those distinct exits. Hookdeck is the webhook-specialist replacement with replays and transformations. Inngest is the durable-workflow upgrade with TypeScript Step Functions. Trigger.dev sits adjacent to Inngest with predictable per-run pricing on a smaller entry tier. Hatchet is the OSS escape that runs on Postgres rather than another vendor's infrastructure. Three managed options, one self-host route.
Quick map by exit reason. Webhook-heavy with replays and transformations: Hookdeck. Multi-step durable workflows with TypeScript Step Functions: Inngest. Predictable per-run pricing on a smaller entry tier: Trigger.dev. OSS self-host on Postgres you already run: Hatchet.
Affiliate disclosure: Subrupt earns a commission when you switch to a service through our recommendation links. This never changes the price you pay. We only recommend services where there's a real cost or feature advantage for you, and our picks are based on the data on this page, not on which programs pay the most.
Quick pick by use case
If you only have thirty seconds, find your situation below and skip to that pick.
Replays from history, payload transformations, filtering, and signature verification all live in the dashboard; Developer free covers 10K events monthly with SOC2.
MIT-licensed core, Postgres backend (no Redis required), polyglot SDKs (TypeScript, Python, Go); full data ownership when self-hosted.
Skip these picks if: You fire simple HTTP webhooks at modest volume and the free 500-per-day tier already covers usage without per-message fees ever appearing on a bill.
At a glance: Upstash QStash alternatives
Quick comparison across pricing floor, best fit, and switching effort. Tap a row to jump to the full pick.
Best for OSS self-host on Postgres infrastructure you already run
$0, MIT-licensed, self-hosted on Postgres
Medium
Feature comparison
Feature
Hookdeck
Inngest
Trigger.dev
Hatchet
HTTP-only delivery (no SDK)POST to a URL and trust the platform with delivery; no client SDK required
✓
✗
✗
✗
Webhook replays + transformationsRe-fire historical deliveries; transform payloads in the dashboard without custom handlers
✓
✗
✗
✗
Durable Step FunctionsMulti-step workflows with idempotency, checkpointing, and replay from last successful step
✗
✓
✓
✓
TypeScript SDK
✓
✓
✓
✓
Python + Go SDKsFirst-party SDKs beyond TypeScript
~
✗
✗
✓
OSS self-host optionPermissive license; self-host without managed vendor
✗
~
✗
✓
Scheduled / delayed delivery
✓
✓
✓
✓
Pricing model
minimum + per-event overage
per-event quota tiers
per-run quota tiers
OSS free or per-event managed
Entry paid tier
$39/mo
$30/mo
$10/mo
$50/mo
Cost at your volume
Approximate cost per pick at typical messages/mo.
Pick
Starter (100K)100,000 messages/mo
Growing (1M)1,000,000 messages/mo
Scale (10M)10,000,000 messages/mo
Hookdeck
$39/mo
$42/mo
$72/mo
Inngest
$30/mo
$300/mo
Custom
Trigger.dev
$50/mo
Custom
Custom
Hatchet
$50/mo
Custom
Custom
Modeled at three production-traffic levels. QStash reference for context: $1 at 100K, $10 at 1M, $100 at 10M on pay-as-you-go. Hookdeck Team minimum applies at every level with per-event overage scaling linearly past the 10K included. Inngest and Trigger.dev hit tier caps at Pro (250K events and 500K runs respectively) and require enterprise sales beyond. Hatchet Cloud Pro covers 250K events; self-hosted OSS removes per-event cost in exchange for operational responsibility.
Hookdeck is what QStash would look like after four more years of webhook-specific tooling. You POST to a Hookdeck source URL, and Hookdeck delivers to your destination with the same retries-and-backoff QStash provides, plus filtering rules, body transformations, signature verification, and a replay UI that lets you re-fire any historical delivery on demand.
The trade: Hookdeck's Developer free tier covers 10K events monthly, an order of magnitude less than QStash's roughly 15K monthly equivalent on the free PAYG tier. Team paid pricing starts at a fixed monthly minimum that runs roughly four times QStash's pay-as-you-go rate at 100K messages and bundles 10K included before per-event billing kicks in. The product is heavier than QStash on UI surface: sources, destinations, connections, and transformations all live in the dashboard rather than as a single POST endpoint.
The upside: For teams whose actual workload is webhooks at production volume, the feature surface is what you would build on top of QStash if QStash never shipped them. Replays from history justify the price differential alone for teams who have had a downstream service eat 2,000 events during an outage. SOC2 compliance on the free tier, signature verification with secret rotation, multi-source fan-out on Team, and the Terraform provider plus audit logs on Growth are the kinds of things production teams actually want.
Strengths
+Replay any historical delivery from the dashboard
+Filtering and payload transformations without writing custom handlers
+Signature verification with secret rotation built in
+SOC2 compliance included on the Developer free tier
Trade-offs
−Free tier dropped to 10K events (was 100K through 2024)
−Team minimum starts above QStash PAYG at low monthly volume
$39/mo minimum, 10K events included + $0.33 per 100K extra
Growth
$499/mo minimum, 30-day retention, SLA + SSO
Pricing verified
2026-05-12
Migration steps
Sign up at hookdeck.com on the Developer free tier (10K events monthly, no card).
Create a Source for each upstream that currently POSTs to QStash; QStash itself can remain a source during the parallel period for verification.
Define a Destination per downstream URL and wire each source to its destinations with optional filtering or transformation rules.
Move QStash POST callers to point at Hookdeck source URLs; QStash continues to receive in parallel until counts match.
Confirm delivery counts match between QStash logs and Hookdeck's event history; cut over and cancel QStash.
Not for: Hookdeck is the wrong fit for low-volume hobby projects where QStash's free 500-per-day tier already covers usage and webhook-specific features go unused; QStash or a raw fetch call cover that shape better.
Inngest is the most popular durable-execution platform for TypeScript and the natural step up when QStash's HTTP-only delivery stops fitting. Where QStash delivers one message and the handler is responsible for everything after, Inngest provides Step Functions: write a single workflow function and Inngest persists each step, retries on failure, and replays from the last successful checkpoint.
The trade: Inngest requires an SDK and a hosted serve endpoint; you cannot fire-and-forget from any language the way QStash's plain HTTP API allows. The Free tier covers 50K events monthly, and the cliff from Basic to Pro is roughly tenfold per month, which is the most-cited reason teams shop Inngest alternatives. Per-event-plus-invocation accounting can surprise teams whose workflows fan one event into many invocations across their library.
The upside: For SaaS teams whose workloads outgrew simple HTTP delivery, Step Functions are the right shape. Idempotency, retries with exponential backoff, fan-out and fan-in, concurrency control per workflow, and rate limiting are all built in. The local-dev replay loop, where every production run can be replayed against your local code, is one of the strongest debug experiences in this category. For serverless stacks on Vercel, Netlify, or Cloudflare Workers, the serverless-first design means no worker processes to operate.
Strengths
+Durable Step Functions with idempotency built in
+TypeScript-first SDK with strong local-dev replay
+Concurrency control and rate limiting per workflow
+Free tier covers 50K events monthly without a card
Trade-offs
−Basic-to-Pro pricing cliff is roughly tenfold
−Per-event-plus-invocation accounting can surprise teams with fan-out workflows
−Requires SDK; no plain HTTP fire-and-forget
Free
$0, 50K events/mo
Basic
$30/mo, 250K events
Pro
$300/mo, 5M events
Pricing verified
2026-05-12
Migration steps
Sign up at inngest.com on the free tier (50K events monthly, no card).
Install @inngest/sdk in your app and create an Inngest client plus a serve endpoint route handler.
Refactor each QStash callsite: replace POST to QStash with inngest.send() and convert the receiver into an Inngest function.
For multi-step workflows, wrap each side effect in step.run() to get the durable-execution semantics QStash never provided.
Validate retries, idempotency, and the local-dev replay loop; cut over and cancel QStash.
Not for: Inngest is the wrong fit for teams whose entire workload is firing one webhook at one downstream URL; QStash, Hookdeck, or a raw fetch call cover that shape better.
Trigger.dev sits between QStash and Inngest. The SDK shape is close to Inngest (TypeScript-first, durable workflows, retries) but the pricing model is per-run rather than per-event-plus-invocation, which makes monthly cost more predictable for teams whose workflows fan one event into many steps.
The trade: TypeScript is the only first-class SDK, which rules Trigger.dev out for Python or Go teams. The Free tier covers 10K runs monthly versus Inngest's 50K events, so the free tier is less generous on paper, though run-counting is more conservative than event-counting at fan-out so the practical gap is smaller. Less ecosystem maturity and fewer integrations than Inngest as of mid-2026.
The upside: Hobby at the entry paid tier runs roughly a third of Inngest Basic and covers 50K runs. The run-by-run drill-down dashboard is one of the more polished debugging surfaces in the durable-execution category, with React waiting tokens for human-in-the-loop steps and scheduled tasks built in for teams who relied on QStash's schedule feature. For TypeScript-only teams crossing into durable workflows for the first time, the migration path is the least confusing of the durable-execution picks.
Strengths
+Predictable per-run pricing (no event-plus-invocation surprises)
+Hobby tier runs roughly a third of Inngest Basic's monthly rate
+Run-by-run drill-down dashboard for debugging
+React waiting tokens and scheduled tasks built in
Trade-offs
−TypeScript-only SDK (no Python or Go)
−Free tier covers 10K runs versus Inngest's 50K events
−Less mature ecosystem than Inngest as of mid-2026
Free
$0, 10K runs/mo
Hobby
$10/mo, 50K runs
Pro
$50/mo, 500K runs
Pricing verified
2026-05-12
Migration steps
Sign up at trigger.dev on the free tier (10K runs monthly).
Install @trigger.dev/sdk and define your first task in a task file (export const myTask = task(...)).
Refactor each QStash POST into a tasks.trigger() call and convert the receiver into the task body.
For QStash schedules, replace with Trigger.dev's schedules.create() API; for one-off delayed delivery, use the delay option on tasks.trigger().
Validate run history and retry behavior in the dashboard; cut over and cancel QStash.
Not for: Trigger.dev is the wrong fit for polyglot stacks (Python, Go, Ruby) or for teams whose workload is plain HTTP delivery without workflow primitives; Inngest covers TypeScript and Python, and QStash or Hookdeck cover plain delivery.
Hatchet is the only OSS pick on this list. The core is MIT-licensed, the backend is Postgres (not Redis), and the SDKs cover TypeScript, Python, and Go. For teams already running Postgres in production who would rather not add a new managed vendor, Hatchet is the route that keeps the queue inside infrastructure you already operate.
The trade: Self-host means operational responsibility for Postgres scaling, worker process management, and observability tooling that managed vendors include free. Hatchet Cloud Pro is available as a managed escape, but the entry tier runs higher than Inngest Basic at comparable volume. Polyglot SDKs (Python and Go beyond TypeScript) are still maturing relative to durable-execution leaders.
The upside: Full control. No vendor lock-in. The Postgres backend means you can query queue state directly with SQL, attach Postgres replication for HA, and back the queue up with the same tooling that backs up the rest of the data layer. For teams whose principle is fewer vendors and more control, Hatchet on Postgres is a smaller cognitive load than running BullMQ on Redis or RabbitMQ on its own cluster. The MIT license also means no Business Source License surprises if the commercial offering ever changes shape.
Strengths
+MIT-licensed OSS core (no Business Source restrictions)
+Postgres backend (no separate Redis or RabbitMQ to operate)
+Polyglot SDKs: TypeScript, Python, and Go
+Full data ownership when self-hosted
Trade-offs
−Self-host means Postgres scaling and worker management on your team
−Cloud Pro tier costs more than Inngest Basic at comparable volume
−Polyglot SDKs less mature than TypeScript-first competitors
OSS Hatchet
$0, MIT-licensed, self-hosted on Postgres
Cloud Free
$0, 10K events/mo managed
Cloud Pro
$50/mo, 250K events
Pricing verified
2026-05-12
Migration steps
Decide self-host versus Cloud. For self-host, deploy via the Helm chart or docker-compose against existing Postgres.
Install @hatchet-dev/typescript-sdk (or the Python or Go equivalent) in your app.
Refactor each QStash callsite as a Hatchet workflow: define the workflow once, call hatchet.run() in place of QStash POSTs.
Run worker processes (same code, deployed as workers) to pick up queued workflows.
Validate retry behavior and Postgres queue state with SQL queries; cut over and cancel QStash.
Not for: Hatchet is the wrong fit for teams who explicitly want zero infrastructure and zero ops responsibility; managed picks (Inngest, Trigger.dev, Hookdeck) cover that shape better.
Paid plans from $50.00/mo
When to stay with Upstash QStash
Stay with QStash if your workload is simple HTTP delivery at modest volume, the per-message pay-as-you-go pricing fits your budget rhythm, and you do not need durable Step Functions, webhook-specific tooling like replays and transformations, or OSS self-host on infrastructure you already operate.
QStash alternatives split along three vectors: workload shape (plain HTTP delivery versus durable Step Functions versus webhook-specialist tooling), pricing model (per-message PAYG versus per-event quota tiers versus per-run quota tiers versus minimum-plus-overage), and hosting (managed-only versus OSS self-host on Postgres). The four picks below cover each combination so the right answer depends on which two of the three vectors matter most for your stack.
Pricing was pulled from each vendor's site on 2026-05-12 and cross-checked against vendor docs. Costs were modeled on a representative workload at three message-volume levels (100K, 1M, and 10M messages monthly) to surface where the QStash PAYG model stops winning. We weight pricing predictability and free-tier generosity highly because QStash users picked QStash specifically for those properties; alternatives that lose predictability also lose the audience.
Last refreshed 2026-05-12.
Update history1 update
Initial published entry. Pricing verified: Hookdeck Developer free 10K events, Team $39/mo minimum, Growth $499/mo; Inngest Free 50K events, Basic $30/mo, Pro $300/mo; Trigger.dev Free 10K runs, Hobby $10/mo, Pro $50/mo; Hatchet Cloud Free 10K events, Cloud Pro $50/mo, OSS MIT free. Hookdeck catalog pricing corrected: free tier dropped from 100K to 10K events; Team minimum rose from $50/mo to $39/mo with usage-based overage past 10K included.
Frequently asked questions about Upstash QStash alternatives
When does QStash stop being the right tool?
Three signals. First, when one POST grows into a multi-step workflow with idempotency requirements, fan-out across users, or recovery semantics QStash never built; durable-execution platforms like Inngest or Trigger.dev fit that shape. Second, when webhook density rises and the team needs replays from history, payload transformations, or signature verification with rotation; Hookdeck is the webhook-specialist replacement. Third, when the principle of fewer vendors matters more than managed convenience and you would rather run the queue on Postgres you already operate; Hatchet is the OSS escape.
Can I migrate QStash schedules to these picks without rewriting the schedule logic?
Mostly yes. Inngest has scheduled functions defined inline with the workflow. Trigger.dev has a schedules.create() API and built-in cron syntax. Hookdeck has scheduled triggers on a Source. Hatchet has cron triggers on workflows. The migration is conceptual mapping rather than full rewrite for one-shot schedules. Recurring multi-step scheduled workflows benefit from the move because the destination platforms persist state between runs in ways QStash schedules cannot.
Is Hookdeck's free tier really only 10K events now? I thought it was 100K.
Yes. Hookdeck restructured pricing in 2024-2025 and the Developer free tier dropped from 100K to 10K events monthly with 3-day retention. The Team paid tier shifted from a flat monthly fee to a lower base of $39/mo that includes 10K events plus per-event overage past that, so the entry price went down but the included usage shrank. The Subrupt catalog reflected the older numbers until this entry's review; pricing is now verified against hookdeck.com on the review date.
Does Hatchet really need its own Postgres database?
Yes, but it can share an existing Postgres if you would rather. Hatchet uses Postgres as its queue backend rather than Redis, which is the defining technical choice. For teams already running Postgres in production, this is the smaller operational ask. For teams who have only ever run Redis-backed queues (BullMQ, Sidekiq, Resque), Hatchet's model takes a couple of days to internalize. The upside is queue state is queryable with SQL, replicable with standard Postgres tooling, and backed up by the same systems that back up the rest of your data layer.
Why is Trigger.dev cheaper than Inngest at the entry paid tier?
Two reasons. First, per-run accounting is more conservative than Inngest's per-event-plus-invocation accounting at fan-out, so the same workload counts as fewer billable units on Trigger.dev. Second, Trigger.dev's Hobby tier is positioned as the on-ramp to durable workflows for indie developers; the price reflects that positioning. Inngest's Basic tier targets growing SaaS at a higher band. The math flips at high volume because Inngest Pro covers 5M events and Trigger.dev needs enterprise contracts past 500K runs.
Ready to switch?
Our top Upstash QStash alternative: Hookdeck
Hookdeck is the webhook-specialist alternative with replays, filtering, transformations, and signature verification built into the dashboard; the right pick when your actual workload is webhooks at production volume and the recovery story matters more than the per-message rate.
The team behind subrupt.com. We track subscriptions, surface cheaper alternatives, and publish comparisons where the score formula is on the page so you can recompute it yourself. We do not claim 30,000 hours of testing. What we claim is live pricing from our database, a transparent composite score, and honest savings math against a category baseline.
Get notified of price drops for Upstash QStash
We'll email you when Upstash QStash or its alternatives lower their prices.
Track Upstash QStash and find more savings
Add Upstash QStash to your dashboard to monitor spending and discover even more alternatives.