AutoGineer
Generated banner for Upstash Qstash JS
Generated logo for Upstash Qstash JS

Upstash Qstash JS

UpstashOfficialCreated by Upstash

  • Skill
  • Tool integration
  • Automation and integrations
  • MIT
  • Low risk
  • Has scripts
Download ZIP

From the author

Work with the @upstash/qstash TypeScript/JavaScript SDK, an HTTP-based message queue, task scheduler, and background job system for serverless and edge runtimes (Next.js, Vercel, Cloudflare Workers, Deno, Node.js). Use when publishing messages to HTTP endpoints or URL groups, running background jobs without a long-running worker process, scheduling with cron expressions, delaying messages, building FIFO queues with parallelism and flow control, configuring retries and callbacks, handling a dead letter queue (DLQ), deduplicating messages, fanning out to multiple endpoints, verifying QStash webhook signatures (Next.js App Router, Pages Router, and Edge Runtime), running a local QStash dev server, or migrating regions. Also use when the user asks for a serverless cron job, async task queue, job scheduler, delayed delivery, webhook delivery with retries, or event-driven messaging between services.
— the description by Upstash

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The QStash JavaScript SDK provides a robust interface for interacting with Upstash's HTTP-based messaging and scheduling platform. Designed for serverless and edge environments like Next.js, Cloudflare Workers, and Deno, this skill enables developers to implement asynchronous task processing, cron-style scheduling, and reliable event-driven communication without maintaining persistent worker infrastructure.

What it does

  • Publishes HTTP messages to individual endpoints or URL groups
  • Schedules recurring tasks using cron expressions
  • Manages FIFO queues with configurable parallelism and flow control
  • Verifies incoming webhook signatures for secure communication
  • Handles advanced messaging patterns like retries, callbacks, and dead letter queues
  • Supports message deduplication and multi-region configurations

When to use it

  • When building serverless applications requiring background job processing
  • When you need to schedule delayed or recurring tasks in edge runtimes
  • When implementing event-driven architectures between microservices
  • When you need reliable webhook delivery with automatic retries
  • When you need to ensure ordered message processing with flow control

Advantages

  • Native support for serverless and edge runtimes
  • Simplifies complex background job orchestration
  • Built-in security via webhook signature verification
  • Flexible configuration for retries, delays, and dead letter queues
  • Supports local development workflows

Usage examples

“How do I publish a JSON message to a webhook using QStash?”
The agent provides a code snippet using the Client.publishJSON method, demonstrating how to initialize the client with an environment token and send a payload to a specific URL.
“How can I verify that a webhook request came from QStash?”
The agent explains how to use the Receiver class to validate incoming request signatures, including platform-specific guidance for frameworks like Next.js.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/upstash/upstash-qstash-js/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip upstash-qstash-js.zip -d .agents/skills

Documentation by Upstash

QStash JavaScript SDK

QStash is an HTTP-based messaging and scheduling solution for serverless and edge runtimes. This skill helps you use the QStash JS SDK effectively.

Bundled docs and source

Before writing or debugging SDK code, check node_modules/@upstash/qstash/docs/ for bundled docs and node_modules/@upstash/qstash/src/ for readable TypeScript source. Read and search the relevant files when present; otherwise use the references in this skill.

When to use this skill

Use this skill when:

  • Publishing HTTP messages to endpoints or URL groups

  • Creating scheduled or delayed message delivery

  • Managing FIFO queues with configurable parallelism

  • Verifying incoming webhook signatures from QStash

  • Implementing callbacks, DLQ handling, or message deduplication

Quick Start

Installing the SDK
npm install @upstash/qstash
Basic Publishing
import { Client } from "@upstash/qstash";

const client = new Client({
  token: process.env.QSTASH_TOKEN!,
});

const result = await client.publishJSON({
  url: "https://my-api.example.com/webhook",
  body: { event: "user.created", userId: "123" },
});

Core Concepts

For fundamental QStash operations, see:

For verifying incoming messages:

  • Receiver Verification - Core signature verification with the Receiver class

  • Platform-Specific Verifiers:

    • Next.js - App Router, Pages Router, and Edge Runtime

For advanced features:

Platform Support

QStash JS SDK works across various platforms:

  • Next.js (App Router and Pages Router)

  • Cloudflare Workers

  • Deno

  • Node.js (v18+)

  • Vercel Edge Runtime

  • SvelteKit, Nuxt, SolidJS, and other frameworks

Note on Workflow SDK: For building complex durable workflows that chain multiple QStash messages together, consider using the separate QStash Workflow SDK (@upstash/workflow). The Workflow SDK empowers you to orchestrate multi-step processes with automatic state management, retries, and fault tolerance. This Skills file focuses on the core QStash messaging SDK.

Best Practices

  • Always verify incoming QStash messages using the Receiver class

  • Use environment variables for tokens and signing keys

  • Set appropriate retry counts and timeouts for your use case

  • Use queues for ordered processing with controlled parallelism

  • Implement DLQ handling for failed message recovery

Files

fundamentals/queues-and-flow-control.md

Queues and Flow Control

Queues

Queues provide FIFO (First-In-First-Out) ordered message delivery with configurable parallelism.

Basic Queue Usage
import { Client } from "@upstash/qstash";

const client = new Client({ token: process.env.QSTASH_TOKEN! });

// Enqueue a message
await client.queue({ queueName: "orders" }).enqueueJSON({
  url: "https://api.example.com/process-order",
  body: { orderId: "123", items: ["item1", "item2"] },
});

Messages are delivered in order, one at a time by default.

Ordering Guarantees

  • Messages delivered in FIFO order

  • Next message waits for current message to be delivered or fail

  • Next message waits for callbacks to complete

  • Retries don't break ordering (next waits for all retries)

Configuring Parallelism

Control how many messages process concurrently:

// Create or update queue with parallelism
await client.queue({ queueName: "orders" }).upsert({
  parallelism: 5, // Process up to 5 messages concurrently
});

// Then enqueue messages
await client.queue({ queueName: "orders" }).enqueueJSON({
  url: "https://api.example.com/process",
  body: { task: "data" },
});

Note: Queue parallelism is being deprecated. Use Flow Control for rate limiting (see below).

Managing Queues
// Get queue details
const queue = await client.queue({ queueName: "orders" }).get();
console.log(queue.parallelism);
console.log(queue.lag); // Messages waiting
console.log(queue.paused);

// List all queues
const queues = await client.queue().list();

// Pause queue (stops processing new messages)
await client.queue({ queueName: "orders" }).pause();

// Resume queue
await client.queue({ queueName: "orders" }).resume();

// Delete queue
await client.queue({ queueName: "orders" }).delete();
All Message Options Work
await client.queue({ queueName: "orders" }).enqueueJSON({
  url: "https://api.example.com/process",
  body: { order: "data" },
  delay: 60,
  retries: 5,
  timeout: 30,
  callback: "https://api.example.com/callback",
  deduplicationId: "order-123",
});

See Publishing Messages for all options.

Flow Control

Control message processing rate and concurrency without queues. More flexible than queue parallelism.

Basic Flow Control
await client.publishJSON({
  url: "https://api.example.com/webhook",
  body: { userId: "user-123", event: "action" },
  flowControl: {
    key: "user-123", // Group messages by key
    parallelism: 2, // Max 2 concurrent requests for this key
    rate: 10, // Max 10 requests
    period: 60, // Per 60 seconds
  },
});
Flow Control Options

key (required): Groups messages for rate limiting

  • Example: user-${userId}, api-${service}, tenant-${tenantId}

parallelism (optional): Max concurrent active requests with same key

  • Example: parallelism: 3 = max 3 requests in-flight

rate (optional): Max requests to activate within period

  • Example: rate: 100 with period: 60 = 100 requests per minute

period (optional): Time window for rate limit in seconds or duration string

  • Default: 1 (1 second)

  • Examples: 60, "1m", "5s", "1h"

Queues vs Flow Control

Use Queues when:

  • Need strict FIFO ordering

  • Messages must process sequentially

  • Single destination with controlled throughput

Use Flow Control when:

  • Rate limiting by user, tenant, or other key

  • Need flexible concurrency control

  • No strict ordering required

  • Works with any publish/schedule operation

Best Practices

  • Use descriptive queue names: order-processing, email-sending

  • Use descriptive flow control keys: user-${id}, tenant-${id}

  • Start with low parallelism and increase based on capacity

  • Monitor queue lag to detect processing bottlenecks

  • Use Flow Control for multi-tenant rate limiting

  • Pause queues during maintenance, not deletion

  • Use deduplication to prevent duplicate enqueues

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

What our scanner noticed· Low risk

  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Upstash
Publisher
Upstash (Official)
Source
upstash/skills · skills/upstash-qstash-js · commit 9f9e3e5
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Upstash.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download upstash-qstash-js.zip