1import { task } from "@trigger.dev/sdk";
 2
 3export const processData = task({
 4  id: "process-data",
 5  retry: {
 6    maxAttempts: 10,
 7    factor: 1.8,
 8    minTimeoutInMs: 500,
 9    maxTimeoutInMs: 30_000,
10  },
11  run: async (payload: { userId: string; data: any[] }) => {
12    console.log(`Processing ${payload.data.length} items`);
13    return { processed: payload.data.length };
14  },
15});

 1import { schemaTask } from "@trigger.dev/sdk";
 2import { z } from "zod";
 3
 4export const validatedTask = schemaTask({
 5  id: "validated-task",
 6  schema: z.object({
 7    name: z.string(),
 8    email: z.string().email(),
 9  }),
10  run: async (payload) => {
11    // Payload is automatically validated and typed
12    return { message: `Hello ${payload.name}` };
13  },
14});

1import { tasks } from "@trigger.dev/sdk";
2import type { processData } from "./trigger/tasks";
3
4const handle = await tasks.trigger<typeof processData>("process-data", {
5  userId: "123",
6  data: [{ id: 1 }],
7});

 1export const parentTask = task({
 2  id: "parent-task",
 3  run: async (payload) => {
 4    // Trigger and wait - returns Result object, NOT direct output
 5    const result = await childTask.triggerAndWait({ data: "value" });
 6    if (result.ok) {
 7      console.log("Output:", result.output);
 8    } else {
 9      console.error("Failed:", result.error);
10    }
11
12    // Or unwrap directly (throws on error)
13    const output = await childTask.triggerAndWait({ data: "value" }).unwrap();
14  },
15});

 1import { idempotencyKeys } from "@trigger.dev/sdk";
 2
 3export const paymentTask = task({
 4  id: "process-payment",
 5  run: async (payload: { orderId: string }) => {
 6    // Scoped to current run - survives retries
 7    const key = await idempotencyKeys.create(`payment-${payload.orderId}`);
 8
 9    await chargeCustomer.trigger(payload, {
10      idempotencyKey: key,
11      idempotencyKeyTTL: "24h",
12    });
13  },
14});

 1await myTask.trigger(payload, {
 2  delay: "1h",           // Delay execution
 3  ttl: "10m",            // Cancel if not started within TTL
 4  idempotencyKey: key,
 5  queue: "my-queue",
 6  machine: "large-1x",   // micro, small-1x, small-2x, medium-1x, medium-2x, large-1x, large-2x
 7  maxAttempts: 3,
 8  tags: ["user_123"],    // Max 10 tags
 9  debounce: {            // Consolidate rapid triggers
10    key: "unique-key",
11    delay: "5s",
12    mode: "trailing",    // "leading" (default) or "trailing"
13  },
14});

 1// Rapid triggers with same key = single execution
 2await myTask.trigger({ userId: "123" }, {
 3  debounce: {
 4    key: "user-123-update",
 5    delay: "5s",
 6  },
 7});
 8
 9// Trailing mode: use payload from LAST trigger
10await myTask.trigger({ data: "latest" }, {
11  debounce: {
12    key: "my-key",
13    delay: "10s",
14    mode: "trailing",
15  },
16});

1const results = await myTask.batchTriggerAndWait([
2  { payload: { userId: "1" } },
3  { payload: { userId: "2" } },
4]);
5
6for (const result of results) {
7  if (result.ok) console.log(result.output);
8}