AutoGineer
Generated banner for Upstash Ratelimit JS
Generated logo for Upstash Ratelimit JS

Upstash Ratelimit JS

UpstashOfficialCreated by Upstash

  • Skill
  • Tool integration
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

Rate limiting for serverless and edge apps with the @upstash/ratelimit TypeScript/JavaScript SDK backed by Upstash Redis. Use when adding a rate limiter or throttling to an API route, Next.js middleware, Vercel Edge, Cloudflare Workers, or any HTTP endpoint; returning 429 Too Many Requests; choosing between fixed window, sliding window, and token bucket algorithms; limiting per user, IP, API key, or tenant with prefixes and custom keys; protecting login, signup, form, or AI endpoints from abuse, bots, and brute force; using deny lists, ephemeral caching, analytics, timeouts, and multi-region rate limits; or estimating the Redis command cost of rate limiting. Also use when the user says rate limit, rate-limiting, throttle, quota, request limits, or traffic protection.
— the description by Upstash

AutoGineer summary

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

The upstash-ratelimit-js skill provides guidance and documentation for integrating the @upstash/ratelimit SDK into TypeScript and JavaScript applications. It supports various rate-limiting algorithms, including fixed window, sliding window, and token bucket, to help developers manage traffic, prevent abuse, and enforce quotas across serverless and edge environments like Vercel Edge and Cloudflare Workers.

What it does

  • Provides implementation patterns for rate limiting API routes and middleware.
  • Supports multiple algorithms including fixed window, sliding window, and token bucket.
  • Enables traffic control based on user IDs, IP addresses, API keys, or tenant identifiers.
  • Offers guidance on protecting endpoints like login, signup, and AI services from abuse.
  • Includes documentation on Redis command costs and operational considerations.
  • Facilitates the use of advanced features like deny lists, analytics, and multi-region configurations.

When to use it

  • When you need to implement request throttling or quotas for your HTTP endpoints.
  • When protecting sensitive endpoints from brute force or bot abuse.
  • When building serverless or edge applications that require stateful rate limiting.
  • When you need to choose between different rate-limiting algorithms for specific traffic patterns.
  • When you need to estimate the Redis command costs associated with your rate-limiting strategy.

Advantages

  • Native support for serverless and edge runtime environments.
  • Flexible configuration for custom keys and request prefixes.
  • Comprehensive documentation on algorithms and traffic protection patterns.
  • Integration with Upstash Redis for distributed state management.

Usage examples

“How do I implement a sliding window rate limit for a user in my Next.js API route?”
The agent provides a code snippet using the Ratelimit class with the slidingWindow algorithm, showing how to check the success boolean to determine if a request should be throttled.
“What are the differences between the available rate-limiting algorithms?”
The agent explains the behavior of fixed window, sliding window, and token bucket algorithms as described in the algorithms.md file.

Install

  1. Download the skill as a ZIP:

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

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

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

Documentation by Upstash

Rate Limit TS SDK

Bundled docs and source

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

Quick Start

  • Install the SDK and connect to Redis.

  • Create a rate limiter and apply it to incoming operations.

Example:

import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";

const redis = new Redis({ url: "<url>", token: "<token>" });
const limiter = new Ratelimit({ redis, limiter: Ratelimit.slidingWindow(5, "10s") });

const { success } = await limiter.limit("user-id");
if (!success) {
  // throttled
}

Other Skill Files

  • algorithms.md: Describes all available rate‑limiting algorithms and how they behave.

  • pricing-cost.md: Explains pricing, Redis cost implications, and operational considerations.

  • features.md: Lists SDK features such as prefixes, custom keys, and behavioral options.

  • methods-getting-started.md: Full method reference for the SDK's API and getting started guide.

  • traffic-protection.md: Guidance on applying rate limiting for traffic shaping, abuse prevention, and protection patterns.

Files

methods-getting-started.md

Upstash Ratelimit Methods (TypeScript)

This document provides a focused, practical reference for all Ratelimit methods. Each section includes direct examples, usage patterns, and common pitfalls.

limit

Primary method for checking and consuming tokens.

const { success, remaining, reset, reason, pending } = await ratelimit.limit(
  identifier,
  {
    rate: 2,          // optional: consume N tokens
    ip: req.ip,       // optional: used for deny‑list checks
    userAgent: ua,    // optional
    country: geo?.country,
  }
);

if (!success) return "blocked";

// In Cloudflare/Vercel Edge, flush async work
context.waitUntil(pending);

Notes:

  • rate lets a request consume more than 1 token.

  • reason can be: timeout, cacheBlock, denyList, or undefined.

  • When analytics or MultiRegion is enabled, always handle pending in serverless environments.

blockUntilReady

Waits for a request to become allowed instead of rejecting immediately.

const { success } = await ratelimit.blockUntilReady("id", 30_000);
if (!success) return "still blocked after timeout";

resetUsedTokens

Clears the state for an identifier.

await ratelimit.resetUsedTokens("user123");

Useful when granting temporary resets or admin overrides.

getRemaining

Read-only view of remaining quota.

const { remaining, reset } = await ratelimit.getRemaining("user123");

Common use cases:

  • Dashboard queries

  • Showing users their remaining quota

setDynamicLimit

Overrides the global limit at runtime.

await ratelimit.setDynamicLimit({ limit: 5 });   // set
await ratelimit.setDynamicLimit({ limit: false }); // remove

Notes:

  • Requires dynamicLimits: true in constructor.

  • Applies to all future rate checks.

getDynamicLimit

Fetch the currently active dynamic limit.

const { dynamicLimit } = await ratelimit.getDynamicLimit();

Returns null when no override is active.

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.

Security

No issues found by our static scan· No issues found

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-ratelimit-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-ratelimit-js.zip