Skip to content
Arcjet Docs

Node.js rate limiting reference

Arcjet rate limiting allows you to define rules which limit the number of requests a client can make over a period of time.

Configuration options

Each rate limit is configured on an exact path with a set of client characteristics and algorithm specific options.

Fixed window rate limit options

Tracks the number of requests made by a client over a fixed time window. Options are explained in the Configuration documentation. See the fixed window algorithm description for more details about how the algorithm works.

// Options for fixed window rate limit
// See https://docs.arcjet.com/rate-limiting/configuration
type FixedWindowRateLimitOptions = {
  mode?: "LIVE" | "DRY_RUN"; // "LIVE" will block requests. "DRY_RUN" will log only
  match?: string; // request path the rate limit applies to
  characteristics?: string[]; // how the client is identified. Defaults to the global characteristics if unset
  window: string; // time window the rate limit applies to
  max: number; // maximum number of requests allowed in the time window
};

Fixed window example

import arcjet, { fixedWindow } from "@arcjet/node";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  characteristics: ["ip.src"], // track requests by IP address
  rules: [
    fixedWindow({
      mode: "LIVE", // will block requests. Use "DRY_RUN" to log only
      match: "/api/hello", // match all requests to /api/hello
      window: "60s", // 60 second fixed window
      max: 100, // allow a maximum of 100 requests
    }),
  ],
});

Sliding window rate limit options

Tracks the number of requests made by a client over a sliding window so that the window moves with time. Options are explained in the Configuration documentation. See the sliding window algorithm description for more details about how the algorithm works.

// Options for sliding window rate limit
// See https://docs.arcjet.com/rate-limiting/configuration
type SlidingWindowRateLimitOptions = {
  mode?: "LIVE" | "DRY_RUN"; // "LIVE" will block requests. "DRY_RUN" will log only
  match?: string; // request path the rate limit applies to
  characteristics?: string[]; // how the client is identified. Defaults to the global characteristics if unset
  interval: number; // the time interval in seconds for the rate limit
  max: number; // maximum number of requests allowed over the time interval
};

Sliding window example

import arcjet, { slidingWindow } from "@arcjet/node";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  characteristics: ["ip.src"], // track requests by IP address
  rules: [
    slidingWindow({
      mode: "LIVE", // will block requests. Use "DRY_RUN" to log only
      match: "/api/hello", // match all requests to /api/hello
      interval: 60, // 60 second sliding window
      max: 100, // allow a maximum of 100 requests
    }),
  ],
});

Token bucket rate limit options

Based on a bucket filled with a specific number of tokens. Each request withdraws a token from the bucket and the bucket is refilled at a fixed rate. Once the bucket is empty, the client is blocked until the bucket refills. Options are explained in the Configuration documentation. See the token bucket algorithm description for more details about how the algorithm works.

// Options for token bucket rate limit
// See https://docs.arcjet.com/rate-limiting/configuration
type TokenBucketRateLimitOptions = {
  mode?: "LIVE" | "DRY_RUN"; // "LIVE" will block requests. "DRY_RUN" will log only
  match?: string; // request path the rate limit applies to
  characteristics?: string[]; // how the client is identified. Defaults to the global characteristics if unset
  refillRate: number; // number of tokens to add to the bucket at each interval
  interval: number; // the interval in seconds to add tokens to the bucket
  capacity: number; // the maximum number of tokens the bucket can hold
};

Token bucket example

See the token bucket example for how to specify the number of tokens to request.

import arcjet, { tokenBucket } from "@arcjet/node";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  characteristics: ["ip.src"], // track requests by IP address
  rules: [
    tokenBucket({
      mode: "LIVE", // will block requests. Use "DRY_RUN" to log only
      match: "/api/hello", // match all requests to /api/hello
      refillRate: 10, // refill 10 tokens per interval
      interval: 60, // 60 second interval
      capacity: 100, // bucket maximum capacity of 100 tokens
    }),
  ],
});

Identifying users

Rate limit rules use characteristics to identify the client and apply the limit across requests. The default is to use the client’s IP address. However, you can specify other characteristics such as a user ID or other metadata from your application.

In this example we define a rate limit rule that applies to a specific user ID. The custom characteristic is userId with the value passed as a prop on the protect function. You can use any string for the characteristic name and any string, number or boolean for the value.

import arcjet, { fixedWindow } from "@arcjet/node";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  // Define a custom userId characteristic.
  // See https://docs.arcjet.com/rate-limiting/configuration#characteristics
  characteristics: ["userId"],
  rules: [
    fixedWindow({
      mode: "LIVE",
      window: "1h",
      max: 60,
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  // Pass userId as a string to identify the user. This could also be a number
  // or boolean value
  const decision = await aj.protect(req, { userId: "user123" });
  console.log("Arcjet decision", decision);


  if (decision.isDenied()) {
    res.writeHead(429, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
    );
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

To identify users with different characteristics e.g. IP address for anonymous users and a user ID for logged in users, you can create a custom fingerprint. See the example in the custom characteristics section.

Rules

The arcjet client is configured with one or more rules which take one or many of the above options.

Example - single rate limit

Set a single rate limit rule on the /api/hello API route that applies a 60 request limit per hour per IP address (the default if no characteristics are specified).

import arcjet, { fixedWindow } from "@arcjet/node";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  rules: [
    fixedWindow({
      mode: "LIVE",
      match: "/api/hello",
      window: "1h",
      max: 60,
    }),
  ],
});

Example - dry run mode for new rules

Rate limits can be combined in the arcjet client which allows you to test new configurations in dry run mode first before enabling them in live mode. You can inspect the results of each rule by logging them or using the Arcjet Dashboard.

import arcjet, { fixedWindow } from "@arcjet/node";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  characteristics: ["ip.src"],
  rules: [
    fixedWindow(
      // This rule is live
      {
        mode: "LIVE",
        match: "/api/hello",
        window: "1h",
        max: 60,
      },
      // This rule is in dry run mode, so will log but not block
      {
        mode: "DRY_RUN",
        match: "/api/hello",
        characteristics: ['http.request.headers["x-api-key"]'],
        window: "1h",
        // max could also be a dynamic value applied after looking up a limit
        // elsewhere e.g. in a database for the authenticated user
        max: 600,
      },
    ),
  ],
});

Decision

Arcjet provides a single protect function that is used to execute your protection rules. This requires a request argument which is the request context as passed to the request handler.

This function returns a Promise that resolves to an ArcjetDecision object. This contains the following properties:

  • id (string) - The unique ID for the request. This can be used to look up the request in the Arcjet dashboard. It is prefixed with req_ for decisions involving the Arcjet cloud API. For decisions taken locally, the prefix is lreq_.
  • conclusion (ArcjetConclusion) - The final conclusion based on evaluating each of the configured rules. If you wish to accept Arcjet’s recommended action based on the configured rules then you can use this property.
  • reason (ArcjetReason) - An object containing more detailed information about the conclusion.
  • results (ArcjetRuleResult[]) - An array of ArcjetRuleResult objects containing the results of each rule that was executed.
  • ip (ArcjetIpDetails) - An object containing Arcjet’s analysis of the client IP address. See IP analysis in the SDK reference for more information.

See the SDK reference for more details about the rule results.

You check if a deny conclusion has been returned by a rate limit rule by using decision.isDenied() and decision.reason.isRateLimit().

You can iterate through the results and check whether a rate limit was applied:

for (const result of decision.results) {
  console.log("Rule Result", result);
}

This example will log the full result as well as each rate limit rule:

import arcjet, { fixedWindow, detectBot } from "@arcjet/node";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  characteristics: ["ip.src"],
  rules: [
    fixedWindow({
      mode: "LIVE",
      window: "1h",
      max: 60,
    }),
    detectBot({
      mode: "LIVE",
      allow: [], // "allow none" will block all detected bots
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  const decision = await aj.protect(req);


  for (const result of decision.results) {
    console.log("Rule Result", result);


    if (result.reason.isRateLimit()) {
      console.log("Rate limit rule", result);
    }


    if (result.reason.isBot()) {
      console.log("Bot protection rule", result);
    }
  }


  if (decision.isDenied()) {
    if (decision.reason.isRateLimit()) {
      res.writeHead(429, { "Content-Type": "application/json" });
      res.end(
        JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
      );
      res.end(JSON.stringify({ error: "Forbidden" }));
    } else {
      res.writeHead(403, { "Content-Type": "application/json" });
      res.end(JSON.stringify({ error: "Forbidden" }));
    }
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

Token bucket request

When using a token bucket rule, an additional requested prop should be passed to the protect function. This is the number of tokens the client is requesting to withdraw from the bucket.

import arcjet, { tokenBucket } from "@arcjet/node";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  characteristics: ["ip.src"],
  rules: [
    tokenBucket({
      mode: "LIVE",
      refillRate: 40_000,
      interval: "1d",
      capacity: 40_000,
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  const decision = await aj.protect(req, { requested: 50 });
  console.log("Arcjet decision", decision);


  if (decision.isDenied()) {
    res.writeHead(429, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
    );
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

Rate limit headers

With a rate limit rule enabled, you can access additional metadata in every Arcjet decision result:

  • max (number): The configured maximum number of requests applied to this request.
  • remaining (number): The number of requests remaining before max is reached within the window.
  • window (number): The total amount of seconds in which requests are counted.
  • reset (number): The remaining amount of seconds in the window.

These can be used to return RateLimit HTTP headers (draft RFC) to offer the client more detail.

We provide the @arcjet/decorate package for decorating your responses with appropriate RateLimit headers based on a decision.

import arcjet, { fixedWindow } from "@arcjet/node";
import { setRateLimitHeaders } from "@arcjet/decorate";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  // Tracking by ip.src is the default if not specified
  //characteristics: ["ip.src"],
  rules: [
    fixedWindow({
      mode: "LIVE",
      window: "1h",
      max: 60,
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  const decision = await aj.protect(req);
  console.log("Arcjet decision", decision);


  setRateLimitHeaders(res, decision);


  if (decision.isDenied()) {
    res.writeHead(429, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
    );
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

Error handling

Arcjet is designed to fail open so that a service issue or misconfiguration does not block all requests. The SDK will also time out and fail open after 1000ms when NODE_ENV or ARCJET_ENV is development and 500ms otherwise. However, in most cases, the response time will be less than 20-30ms.

If there is an error condition, Arcjet will return an ERROR conclusion.

import arcjet, { tokenBucket } from "@arcjet/node";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  characteristics: ["userId"], // track requests by a custom user ID
  rules: [
    // Create a token bucket rate limit. Other algorithms are supported.
    tokenBucket({
      mode: "LIVE", // will block requests. Use "DRY_RUN" to log only
      refillRate: 5, // refill 5 tokens per interval
      interval: 10, // refill every 10 seconds
      capacity: 10, // bucket maximum capacity of 10 tokens
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  const userId = "user123"; // Replace with your authenticated user ID
  const decision = await aj.protect(req, { userId, requested: 5 }); // Deduct 5 tokens from the bucket
  console.log("Arcjet decision", decision);


  if (decision.isErrored()) {
    // Fail open by logging the error and continuing
    console.warn("Arcjet error", decision.reason.message);
    // You could also fail closed here for very sensitive routes
    //res.writeHead(503, { "Content-Type": "application/json" });
    //res.end(JSON.stringify({ error: "Service unavailable" }));
  }


  if (decision.isDenied()) {
    res.writeHead(429, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
    );
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

Testing

Arcjet runs the same in any environment, including locally and in CI. You can use the mode set to DRY_RUN to log the results of rule execution without blocking any requests.

We have an example test framework you can use to automatically test your rules. Arcjet can also be triggered based using a sample of your traffic.

See the Testing section of the docs for details.

Examples

Rate limit by IP address

The example below shows how to configure a rate limit on a single API route. It applies a limit of 60 requests per hour per IP address. If the limit is exceeded, the client is blocked for 10 minutes before being able to make any further requests.

Applying a rate limit by IP address is the default if no characteristics are specified.

import arcjet, { fixedWindow } from "@arcjet/node";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  // Tracking by ip.src is the default if not specified
  //characteristics: ["ip.src"],
  rules: [
    fixedWindow({
      mode: "LIVE",
      window: "1h",
      max: 60,
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  const decision = await aj.protect(req);
  console.log("Arcjet decision", decision);


  if (decision.isDenied()) {
    res.writeHead(429, { "Content-Type": "application/json" });
    res.end(
      JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
    );
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

Rate limit by IP address with custom response

The example below is the same as the one above. However this example also shows a customized response rather than the default

import arcjet, { fixedWindow } from "@arcjet/node";
import http from "node:http";


const aj = arcjet({
  key: process.env.ARCJET_KEY!, // Get your site key from https://app.arcjet.com
  // Tracking by ip.src is the default if not specified
  //characteristics: ["ip.src"],
  rules: [
    fixedWindow({
      mode: "LIVE",
      window: "1h",
      max: 60,
    }),
  ],
});


const server = http.createServer(async function (
  req: http.IncomingMessage,
  res: http.ServerResponse,
) {
  const decision = await aj.protect(req);
  console.log("Arcjet decision", decision);


  if (decision.isDenied()) {
    if (decision.reason.isRateLimit()) {
      res.writeHead(429, { "Content-Type": "application/json" });
      res.end(
        JSON.stringify({ error: "Too Many Requests", reason: decision.reason }),
      );
    } else {
      res.writeHead(403, { "Content-Type": "application/json" });
      res.end(JSON.stringify({ error: "Forbidden", reason: decision.reason }));
    }
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello world" }));
  }
});


server.listen(8000);

Rate limit by API key header

APIs are commonly protected by keys. You may wish to apply a rate limit based on the key, regardless of which IPs the requests come from. To achieve this, you can specify the characteristics Arcjet will use to track the limit.

The example below shows how to configure a rate limit on a single API route. It applies a limit of 60 requests per hour per API key, where the key is provided in a custom header called x-api-key. If the limit is exceeded, the client is blocked for 10 minutes before being able to make any further requests.

import arcjet, { fixedWindow } from "@arcjet/node";


const aj = arcjet({
  key: process.env.ARCJET_KEY!,
  characteristics: ['http.request.headers["x-api-key"]'],
  rules: [
    fixedWindow({
      mode: "LIVE",
      window: "1h",
      max: 60,
    }),
  ],
});

Express server route protection

If you’re using Express, you can use Arcjet in the same way as the examples above:

import arcjet, { fixedWindow } from "@arcjet/node";
import express from "express";


const app = express();
const port = 3000;


const aj = arcjet({
  // Get your site key from https://app.arcjet.com and set it as an environment
  // variable rather than hard coding.
  key: process.env.ARCJET_KEY,
  // Tracking by ip.src is the default if not specified
  //characteristics: ["ip.src"],
  rules: [
    // Fixed window rate limit. Arcjet also supports sliding window and token
    // bucket.
    fixedWindow({
      mode: "LIVE", // will block requests. Use "DRY_RUN" to log only
      window: "1m", // 1 min fixed window
      max: 1, // allow a single request (for demo purposes)
    }),
  ],
});


app.get("/", async (req, res) => {
  const decision = await aj.protect(req);


  if (decision.isDenied()) {
    res.writeHead(429, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ error: "Too Many Requests" }));
  } else {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ message: "Hello World" }));
  }
});


app.listen(port, () => {
  console.log(`Example app listening on port ${port}`);
});

Discussion