Create the Inngest Client

The Inngest client object is used to configure your application, enabling you to create functions and send events.

import { Inngest } from "inngest";

const inngest = new Inngest({
  id: "my-application",
});

Configuration

Defining Event Payload Types

You can leverage TypeScript or Zod to define your event payload types. When you pass types to the Inngest client, events are fully typed when using them with inngest.send() and inngest.createFunction(). This can more easily alert you to issues with your code during compile time.

import { EventSchemas, Inngest, type LiteralZodEventSchema } from "inngest";
import { z } from "zod";

// Define each event individually
const productPurchasedEvent = z.object({
  name: z.literal("shop/product.purchased"),
  data: z.object({ productId: z.string() }),
});

// You can use satisfies to provide some autocomplete when writing the event
const productViewedEvent = z.object({
  name: z.literal("shop/product.viewed"),
  data: z.object({ productId: z.string() }),
}) satisfies LiteralZodEventSchema;

// Or all together in a single object
const eventsMap = {
  "app/account.created": {
    data: z.object({
      userId: z.string(),
    }),
  },
  "app/subscription.started": {
    data: z.object({
      userId: z.string(),
      planId: z.string(),
    }),
  },
};

export const inngest = new Inngest({
  schemas: new EventSchemas()
    .fromZod([productPurchasedEvent, productViewedEvent])
    .fromZod(eventsMap),
});

Reusing event types v2.0.0+

You can use the GetEvents<> generic to access the final event types from an Inngest client.

import { EventSchemas, Inngest, type GetEvents } from "inngest";

export const inngest = new Inngest({
  schemas: new EventSchemas().fromRecord<{
    "app/user.created": { data: { userId: string } };
  }>(),
});

type Events = GetEvents<typeof inngest>;
type AppUserCreated = Events["app/user.created"];

For more information on this and other TypeScript helpers, see TypeScript - Helpers.

Cloud Mode and Dev Mode

An SDK can run in two separate "modes:" Cloud or Dev.

• Cloud Mode
  • 🔒 Signature verification ON
  • Defaults to communicating with Inngest Cloud (e.g. https://api.inngest.com)
• Dev Mode
  • ❌ Signature verification OFF
  • Defaults to communicating with an Inngest Dev Server (e.g. http://localhost:8288)

You can force either Dev or Cloud Mode by setting INNGEST_DEV or the isDev option.

If neither is set, the SDK will attempt to infer which mode it should be in based on environment variables such as NODE_ENV. Most of the time, this inference is all you need and explicitly setting a mode isn't required.

Best Practices

Share your client across your codebase

Instantiating the Inngest client in a single file and sharing it across your codebase is ideal as you only need a single place to configure your client and define types which can be leveraged anywhere you send events or create functions.

import { Inngest } from "inngest";

export const inngest = new Inngest({ id: "my-app" });

import { inngest } from "./client";

export default inngest.createFunction(...);

Handling multiple environments with middleware

If your client uses middleware, that middleware may import dependencies that are not supported across multiple environments such as "Edge" and "Serverless" (commonly with either access to WebAPIs or Node).

In this case, we'd recommend creating a separate client for each environment, ensuring Node-compatible middleware is only used in Node-compatible environments and vice versa.

This need is common in places where function execution should declare more involved middleware, while sending events from the edge often requires much less.

// inngest/client.ts
import { Inngest } from "inngest";
import { nodeMiddleware } from "some-node-middleware";

export const inngest = new Inngest({
  id: "my-app",
  middleware: [nodeMiddleware],
});

// inngest/edgeClient.ts
import { Inngest } from "inngest";

export const inngest = new Inngest({
  id: "my-app-edge",
});

Also see Referencing functions, which can help you invoke functions across these environments without pulling in any dependencies.