How to Prevent Hitting Usage Quotas with LLM Calls in n8n

1// Common LLM provider limits (Tier 1 / default)
2// OpenAI GPT-4o: 500 RPM, 30,000 TPM, $100/mo default cap
3// OpenAI GPT-4o-mini: 500 RPM, 200,000 TPM
4// Anthropic Claude 3.5 Sonnet: 50 RPM, 40,000 TPM
5// Mistral Large: 30 RPM, varies by plan
6
7// Check your actual limits:
8// OpenAI: platform.openai.com → Settings → Limits
9// Anthropic: console.anthropic.com → Settings → Limits
10// Mistral: console.mistral.ai → Billing

1// Rate limiting strategy using Code node + Wait node
2
3// Code node before LLM: calculate required delay
4const staticData = $getWorkflowStaticData('global');
5const RPM_LIMIT = 50; // Your provider's RPM limit
6const MIN_DELAY_MS = Math.ceil(60000 / RPM_LIMIT); // 1200ms for 50 RPM
7
8const now = Date.now();
9const lastCallTime = staticData.lastLlmCallTime || 0;
10const elapsed = now - lastCallTime;
11const waitTime = Math.max(0, MIN_DELAY_MS - elapsed);
12
13staticData.lastLlmCallTime = now + waitTime;
14
15return [{
16  json: {
17    ...($input.first().json),
18    _waitMs: waitTime
19  }
20}];
21
22// Wait node after Code node:
23// Wait Amount: {{ $json._waitMs }}
24// Unit: Milliseconds

1-- PostgreSQL: Create usage tracking table
2CREATE TABLE IF NOT EXISTS llm_usage_tracking (
3  id SERIAL PRIMARY KEY,
4  provider VARCHAR(50) NOT NULL,
5  model VARCHAR(100),
6  prompt_tokens INTEGER DEFAULT 0,
7  completion_tokens INTEGER DEFAULT 0,
8  total_tokens INTEGER DEFAULT 0,
9  estimated_cost_usd NUMERIC(10, 6),
10  workflow_id VARCHAR(255),
11  created_at TIMESTAMP DEFAULT NOW()
12);
13
14CREATE INDEX idx_usage_provider_date
15  ON llm_usage_tracking(provider, created_at);

1// Code node — JavaScript
2// Extract and normalize token usage from LLM response
3
4const response = $input.first().json;
5
6// Provider-specific token extraction
7let provider = 'unknown';
8let model = 'unknown';
9let promptTokens = 0;
10let completionTokens = 0;
11
12if (response.usage?.prompt_tokens !== undefined) {
13  // OpenAI / Mistral format
14  provider = response.model?.includes('gpt') ? 'openai' : 'mistral';
15  model = response.model || 'unknown';
16  promptTokens = response.usage.prompt_tokens;
17  completionTokens = response.usage.completion_tokens;
18} else if (response.usage?.input_tokens !== undefined) {
19  // Anthropic format
20  provider = 'anthropic';
21  model = response.model || 'unknown';
22  promptTokens = response.usage.input_tokens;
23  completionTokens = response.usage.output_tokens;
24}
25
26// Cost estimation (approximate, per 1M tokens)
27const COSTS = {
28  'gpt-4o': { input: 2.50, output: 10.00 },
29  'gpt-4o-mini': { input: 0.15, output: 0.60 },
30  'claude-3-5-sonnet-20241022': { input: 3.00, output: 15.00 },
31  'mistral-large-latest': { input: 2.00, output: 6.00 }
32};
33
34const pricing = COSTS[model] || { input: 5.00, output: 15.00 };
35const estimatedCost = (promptTokens * pricing.input + completionTokens * pricing.output) / 1000000;
36
37return [{
38  json: {
39    provider,
40    model,
41    prompt_tokens: promptTokens,
42    completion_tokens: completionTokens,
43    total_tokens: promptTokens + completionTokens,
44    estimated_cost_usd: estimatedCost,
45    workflow_id: $workflow.id
46  }
47}];

1-- Postgres node query: Monthly spending check
2SELECT
3  provider,
4  SUM(total_tokens) as monthly_tokens,
5  SUM(estimated_cost_usd) as monthly_cost_usd,
6  COUNT(*) as total_calls
7FROM llm_usage_tracking
8WHERE created_at >= date_trunc('month', NOW())
9GROUP BY provider;
10
11-- Code node after query: Check against limits
12// const SPENDING_CAPS = {
13//   openai: 100,      // $100/month
14//   anthropic: 50,    // $50/month
15//   mistral: 30       // $30/month
16// };
17// const WARNING_THRESHOLD = 0.80; // 80%
18// const CRITICAL_THRESHOLD = 0.95; // 95%

1// Code node — JavaScript
2// Fallback model selection after rate limit error
3
4const FALLBACK_CHAIN = [
5  { provider: 'openai', model: 'gpt-4o', priority: 1 },
6  { provider: 'openai', model: 'gpt-4o-mini', priority: 2 },
7  { provider: 'anthropic', model: 'claude-3-5-haiku-20241022', priority: 3 }
8];
9
10const staticData = $getWorkflowStaticData('global');
11const rateLimitedModels = staticData.rateLimitedModels || {};
12const now = Date.now();
13
14// Clean expired rate limit flags (reset after 60 seconds)
15for (const [model, timestamp] of Object.entries(rateLimitedModels)) {
16  if (now - timestamp > 60000) {
17    delete rateLimitedModels[model];
18  }
19}
20
21// Find first available model
22const available = FALLBACK_CHAIN.find(
23  m => !rateLimitedModels[m.model]
24);
25
26if (!available) {
27  // All models rate limited — wait and retry primary
28  return [{ json: { _waitMs: 30000, model: FALLBACK_CHAIN[0].model, isFallback: false } }];
29}
30
31return [{
32  json: {
33    model: available.model,
34    provider: available.provider,
35    isFallback: available.priority > 1,
36    fallbackLevel: available.priority
37  }
38}];