Hangfire

Hangfire is a .NET and .NET Core background-processing framework for teams that want queued and scheduled work to remain part of their application rather than a separate service. It is strongest for self-hosted .NET deployments that need durable jobs, retries, and operational visibility; teams outside that ecosystem should look elsewhere.

Overview

Hangfire runs fire-and-forget, delayed, recurring, and continuation jobs without requiring a Windows Service or another process. Persistent storage keeps jobs beyond the lifetime of an application instance. SQL Server and Redis are officially supported, while other storage options come from the community, so your team must select, provision, and maintain a compatible backend.

Processing uses at-least-once semantics and retries jobs after unhandled exceptions or application termination. That is useful for recovering interrupted work, but it also means job code must tolerate duplicate execution. Multiple machines can process the same workload, with synchronization handled automatically, making the self-hosted model suitable for distributed application deployments.

The built-in web dashboard exposes processing activity and each job's state. It accepts local requests by default; remote access requires authorization configuration. This limits accidental exposure, but organizations wanting remote operations access must implement and maintain that access control.

Key features

• Flexible job model: Immediate, delayed, recurring, and continuation jobs cover common application workflows without adding a separate scheduler.
• Durable persistence: Official SQL Server and Redis support helps jobs survive restarts; community storage implementations broaden options but do not carry the same official support status.
• Resilience and distribution: Automatic retries and at-least-once delivery improve recovery, while synchronized workers on different machines support horizontal processing. Idempotent job design remains essential.
• Operational dashboard: The web interface makes job states and background activity visible. Local-only access is the default, so remote monitoring is not a zero-configuration feature.
• .NET integration: Documentation covers ASP.NET, ASP.NET Core, console applications, Windows Services, WCF, Nancy, and ServiceStack.
• Paid extensions: Hangfire Pro adds batches and batch continuations. Hangfire Ace adds throttling for concurrency and rate limits. Throttling is officially supported with Hangfire.SqlServer, Hangfire.Pro.Redis, and Hangfire.InMemory storage, which narrows the supported combinations for teams using another backend.

Pricing

Hangfire Core is open source under LGPLv3 and free for commercial use. There is no free trial for Pro, although purchases have a 30-day refund period. Licenses are perpetual, with annual billing for the paid plans.

The Open plan's storage choices exclude Redis, and community support is the trade-off for its zero price. Startup adds Redis and Pro but still omits dedicated support. Business is the first tier with Ace and formal helpdesk support; Enterprise adds licensing flexibility and priority handling.

Platforms

Hangfire is available through an API and web dashboard for self-hosted deployments on Linux and Windows. Its deployment model is self-hosted, so infrastructure, storage, upgrades, and dashboard authorization remain your responsibility.

Who it's for

Choose Hangfire when your product is built on .NET or .NET Core and background work must persist through restarts, run on several machines, or follow recurring schedules. The Open plan suits smaller teams comfortable with SQL Server or In-Memory storage and community support. Startup, Business, and Enterprise fit organizations that need Redis, private package distribution, paid extensions, source access, or escalating support commitments.

It is a weaker choice for teams seeking a managed queue, a non-.NET-first stack, or a dashboard that can be opened remotely without configuring authorization. At-least-once delivery also makes it unsuitable for job logic that cannot safely handle repetition.

Pros and cons

Pros

• Free commercial Core: LGPLv3 licensing avoids a per-job charge for the basic processor.
• Durable, recoverable work: Persistent storage, retries, and multi-machine processing address common failure and scale concerns.
• Clear extension path: Pro batches and Ace throttling let growing teams add capabilities without replacing the core system.

Cons

• Self-hosting burden: You operate the application environment, storage, upgrades, and remote dashboard authorization.
• Paid advanced features: Batches, continuations, and throttling are unavailable on Open.
• Duplicate execution risk: At-least-once processing requires idempotent job design.
• Support varies sharply: Open has community support, Startup has no dedicated support, and only higher plans include formal assistance.

Alternatives

IronWorker is worth choosing when you want a freemium service with a free trial and a published Basic allowance of one concurrency, five hours per month, 512 MB RAM, 30-minute runtime, and 50 scheduled tasks.

Django Q2 is the better fit for a Linux, macOS, or self-hosted Django-oriented stack seeking MIT-licensed free software.

Faktory suits teams wanting an OSS option under AGPL or enterprise add-on packs priced at $99 a month.

Gearman is a free, BSD-licensed open-source alternative for API, Linux, self-hosted, or Windows deployments.

Google Tasks is for personal task lists, subtasks, due dates, and notifications across Android, iOS, and web rather than application background processing.

Graphile Worker fits PostgreSQL-oriented teams wanting MIT-licensed open source, with a Worker Pro launch offer from $25 a month.

Inngest is preferable when a hosted workflow service with published seat, execution, event, and trace-history allowances is a better match.

pg-boss is a free MIT-licensed choice that runs in your own database with no per-job charges.

Verdict

Hangfire is a strong choice for .NET teams that want persistent, schedulable background work, automatic recovery, and a built-in dashboard while retaining control of deployment. Choose the Open plan for capable core processing at no license cost; move to paid tiers when batches, throttling, source access, or structured support justify the annual fee. Look elsewhere if you need a managed service, a non-.NET ecosystem, or processing semantics that do not require protection against duplicate runs.