jeremylongshore/tons-of-skills-marketplace / plugins/api-development/api-rate-limiter/skills/rate-limiting-apis
rate-limiting-apis
VerifiedImplement 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".
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.6 KB |
| references/errors.md | markdown | 1.0 KB |
| references/examples.md | markdown | 5.1 KB |
| references/implementation.md | markdown | 1.5 KB |
references/examples.md
View on GitHub# API Rate Limiting Examples
## Sliding Window (Redis Sorted Sets)
```javascript
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
```javascript
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
```javascript
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)
```javascript
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
```javascript
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
```bash
# 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
```javascript
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](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)*
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |