Index of every page on this site: llms.txt
All skills
Run it yourself

Implement sophisticated rate limiting with sliding windows, token buckets, and quotas. Use when protecting APIs from excessive requests. Trigger with phrases like "add rate limiting", "limit API requests", or "implement rate limits".

Use this Skill: https://skilld.dev/gh/jeremylongshore/tons-of-skills-marketplace/rate-limiting-apis

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

referencesexamples.md

≈1.3k tokens on demand. Your agent reads this file only when SKILL.md points to it.

API Rate Limiting Examples

Sliding Window (Redis Sorted Sets)

async function slidingWindowRateLimit(identifier, limit, windowSeconds) {
  const key = `ratelimit:${identifier}`;
  const now = Date.now();
  const windowStart = now - windowSeconds * 1000;

  const pipeline = redis.pipeline();
  pipeline.zremrangebyscore(key, 0, windowStart);
  pipeline.zadd(key, now, `${now}:${Math.random()}`);
  pipeline.zcard(key);
  pipeline.expire(key, windowSeconds);

  const results = await pipeline.exec();
  const count = results[2][1];
  return {
    allowed: count <= limit,
    remaining: Math.max(0, limit - count),
    resetAt: Math.ceil((windowStart + windowSeconds * 1000) / 1000),
    limit,
  };
}

Rate Limit Middleware with Headers

function rateLimitMiddleware({ limit = 100, windowSeconds = 60, keyFn } = {}) {
  return async (req, res, next) => {
    if (req.skipRateLimit) return next();
    const id = keyFn ? keyFn(req) : req.user?.id || req.headers['x-api-key'] || req.ip;
    const result = await slidingWindowRateLimit(id, limit, windowSeconds);

    res.set('X-RateLimit-Limit', String(result.limit));
    res.set('X-RateLimit-Remaining', String(result.remaining));
    res.set('X-RateLimit-Reset', String(result.resetAt));
    res.set('RateLimit-Policy', `${limit};w=${windowSeconds}`);

    if (!result.allowed) {
      const retryAfter = Math.ceil((result.resetAt * 1000 - Date.now()) / 1000);
      res.set('Retry-After', String(retryAfter));
      return res.status(429).json({
        type: 'https://api.example.com/errors/rate-limit',
        title: 'Too Many Requests', status: 429,
        detail: `Rate limit of ${limit} per ${windowSeconds}s exceeded`,
        retryAfter,
      });
    }
    next();
  };
}

Tiered Limits per Plan

const tierLimits = {
  free:       { default: 100,  login: 5,  search: 20  },
  pro:        { default: 1000, login: 20, search: 200 },
  enterprise: { default: 10000, login: 100, search: 2000 },
};

app.get('/api/users',
  rateLimitMiddleware({
    limit: (req) => tierLimits[req.apiTier || 'free'].default,
    windowSeconds: 60,
    keyFn: (req) => req.headers['x-api-key'] || req.ip,
  }),
  listUsers
);

Token Bucket (Redis Lua)

async function tokenBucket(identifier, rate, burstSize) {
  const script = `
    local key = KEYS[1]
    local rate = tonumber(ARGV[1])
    local burst = tonumber(ARGV[2])
    local now = tonumber(ARGV[3])
    local data = redis.call('HMGET', key, 'tokens', 'last_refill')
    local tokens = tonumber(data[1]) or burst
    local last = tonumber(data[2]) or now
    tokens = math.min(burst, tokens + (now - last) * rate)
    local allowed = 0
    if tokens >= 1 then tokens = tokens - 1; allowed = 1 end
    redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
    redis.call('EXPIRE', key, 120)
    return {allowed, math.floor(tokens)}
  `;
  const [allowed, remaining] = await redis.eval(script, 1,
    `bucket:${identifier}`, rate, burstSize, Date.now() / 1000);
  return { allowed: allowed === 1, remaining };
}

Login Brute-Force Protection

const LOCKOUTS = [15 * 60, 60 * 60, 24 * 60 * 60];

async function loginProtection(req, res, next) {
  const ip = req.ip;
  const lockTTL = await redis.ttl(`login:locked:${ip}`);
  if (lockTTL > 0) {
    return res.status(429).json({ detail: 'Account locked', retryAfter: lockTTL });
  }

  req.onLoginFailure = async () => {
    const failures = await redis.incr(`login:failures:${ip}`);
    await redis.expire(`login:failures:${ip}`, 86400);
    const idx = failures >= 20 ? 2 : failures >= 10 ? 1 : failures >= 5 ? 0 : -1;
    if (idx >= 0) await redis.setex(`login:locked:${ip}`, LOCKOUTS[idx], 'locked');
  };
  req.onLoginSuccess = () => redis.del(`login:failures:${ip}`, `login:locked:${ip}`);
  next();
}

curl: Rate Limit Behavior

# Normal request
curl -i http://localhost:3000/api/users -H "X-API-Key: key_free_123"
# X-RateLimit-Limit: 100
# X-RateLimit-Remaining: 99
# X-RateLimit-Reset: 1710000060

# After exceeding limit
# HTTP/1.1 429 Too Many Requests
# Retry-After: 45
# {"type":"...rate-limit","detail":"Rate limit of 100 per 60s exceeded","retryAfter":45}

# Pro tier
curl -i http://localhost:3000/api/users -H "X-API-Key: key_pro_456"
# X-RateLimit-Limit: 1000

Rate Limit Tests

describe('Rate Limiting', () => {
  it('allows within limit', async () => {
    for (let i = 0; i < 5; i++) {
      const res = await request(app).get('/api/users').set('X-API-Key', 'test');
      expect(res.status).toBe(200);
      expect(res.headers['x-ratelimit-remaining']).toBe(String(4 - i));
    }
  });
  it('rejects over limit', async () => {
    for (let i = 0; i < 5; i++) await request(app).get('/api/users').set('X-API-Key', 'test');
    const res = await request(app).get('/api/users').set('X-API-Key', 'test');
    expect(res.status).toBe(429);
    expect(res.headers['retry-after']).toBeDefined();
  });
});

Tons of Skills by Intent Solutions | jeremylongshore.com

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts2mo3 checks · Risk SAFE
  • Gen Agent Trust Hub2mo

    This skill provides instructions for implementing API rate limiting and involves analyzing web access logs. Reading untrusted log data presents a minor risk of indirect prompt injection if logs contain adversarial instructions. All external links point to legitimate documentation or well-known software libraries.

  • Socket2mo

    No alerts

  • Snyk2mo

    Risk: LOW · No issues

Signed by skilld at 820dfc8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated last month
What it can do
Reads files Edits files Runs commands
version
1.26.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
tags
[
  "api",
  "rate-limiting"
]
All 6 allowed tools
ReadWriteEditGrepGlobBash(api:ratelimit-*)
Other metadata
compatibility
Designed for Claude Code

README badge

README badge for jeremylongshore/tons-of-skills-marketplace/rate-limiting-apis