Introducing Durable Endpoints: Durability beyond workflows

Durable execution is a crucial layer of fault tolerance that shields applications from external issues, such as API or internal infrastructure failures. It's a key part of keeping everything running smoothly.

Still, durability has always meant background work: critical workflows running async, safely away from user-facing code. But that creates a tradeoff: AI products ship fast with fragile streaming endpoints, while reliable payment processing or integrations take weeks to harden with queues and workers.

It is time for a new approach. Durable Endpoints makes API endpoints unbreakable, with low latency, minimal API, and no infrastructure work.

What are Durable Endpoints?

Durable Endpoints let you use Inngest's step API directly in your API handlers. Each step automatically gets retries, recovery, and observability, without leaving your endpoint code:

tsx

import { Inngest } from "inngest";
import { endpointAdapter } from "inngest/next";

const inngest = new Inngest({ id: "deep-research", endpointAdapter });

export const GET = inngest.endpoint(async (req: NextRequest) => {
   const { topic, clarifications, researchId } = parseParams(req);

   const queries = await step.run("generate-queries", async () => {
   // Returns queries with reasoning: { query, reasoning, angle }
      return await generateSearchQueries(topic, clarifications);
   });

   // deepResearch() leverages `step.run` for recursive searches
   await deepResearch(researchId, topic, queries, depth, accumulated);

   const report = await step.run("generate-report", async () => {
      return await generateReport(topic, accumulated);
   });

   return Response.json({ report, sources: accumulated.sources });
})

That's it. Your endpoint is now durable. If generate-queries succeeds but generate-report fails, Inngest picks up exactly where it left off, no re-running expensive LLM calls.

Durability is moving into APIs

AI changed the game. Your users are staring at a chat interface, waiting for a response. They need both durability and low latency in a single request. The old model of "fast but fragile" vs "slow but reliable" doesn't cut it anymore.

We're seeing a need for a shift: durability is moving from background workflows into API endpoints.

Durable Endpoints are low-latency and unbreakable API endpoints, with:

Zero wasted keystrokes: Wrap code in step.run(), and you're done. No queues to configure, no workers to deploy.
Automatic recovery: Steps checkpoint as they complete. Failures retry from the last successful step, not from scratch.
Built-in observability: See exactly what's running, what failed, and why. No instrumentation required.
Low latency by design: Powered by Checkpointing for fast execution. Add real-time streaming when you need it.
Works with your existing code: No architectural overhaul. Add durability incrementally where it matters.

See it in action: A Durable DeepResearch in a few hours

DeepResearch-style AI interfaces are notoriously complex: a single research query might trigger 40+ search requests and 20+ LLM calls to aggregate, evaluate, and summarize hundreds of sources. Traditionally, you'd split this into two systems: a streaming Serverless frontend for responsiveness, plus a background job system for reliability.

With Durable Endpoints, it's one cohesive implementation:

The demo above shows a full DeepResearch implementation with recursive queries up to 3 nested levels and advanced reasoning, built in hours, not weeks.

Try the DeepResearch demo locally

Beyond AI: Payment processing and product integrations

While AI use cases drove this feature, durability belongs anywhere failure is expensive:

Payment processing: Stripe calls that must complete, even if your server hiccups mid-transaction
Webhook handlers: Process incoming data reliably without building dead-letter queues
Third-party integrations: API calls to flaky external services that need graceful retry logic
E-commerce transactions: Order flows that can't afford to drop steps

Get started with Durable Endpoints

Durable Endpoints is available now in public beta. Getting started takes minutes:

Install or update the Inngest SDK
Wrap your endpoint handler with inngest.endpoint() from inngest/edge for Bun or inngest/next for Next.js
Use step.run() for operations that need durability

Read the Durable Endpoints documentation