Salesforce API Rate Limits:
Optimization Strategies
for High-Volume Integrations

{
  "message": "TooManyRequests: Total number of requests exceeded daily limit.",
  "errorCode": "REQUEST_LIMIT_EXCEEDED"
}

// 10 separate API calls
await createAccount(accountData);           // Call 1
await createContact(contactData);           // Call 2
await createOpportunity(opportunityData);   // Call 3
await updateAccount(accountId, updates);    // Call 4
await query('SELECT Id FROM Lead');         // Call 5
// ... 5 more calls

const compositeRequest = {
  allOrNull: false,
  compositeRequest: [
    {
      method: 'POST',
      url: '/services/data/v60.0/sobjects/Account',
      referenceId: 'newAccount',
      body: { Name: 'Acme Corp', Industry: 'Technology' }
    },
    {
      method: 'POST',
      url: '/services/data/v60.0/sobjects/Contact',
      referenceId: 'newContact',
      body: {
        FirstName: 'John',
        LastName: 'Smith',
        AccountId: '@{newAccount.id}' // Reference previous result
      }
    },
    {
      method: 'POST',
      url: '/services/data/v60.0/sobjects/Opportunity',
      referenceId: 'newOpportunity',
      body: {
        Name: 'New Deal',
        AccountId: '@{newAccount.id}',
        StageName: 'Prospecting',
        CloseDate: '2025-12-31'
      }
    },
    {
      method: 'PATCH',
      url: '/services/data/v60.0/sobjects/Account/@{newAccount.id}',
      referenceId: 'updateAccount',
      body: { Description: 'Updated via Composite API' }
    },
    {
      method: 'GET',
      url: '/services/data/v60.0/query?q=SELECT+Id+FROM+Lead+LIMIT+10',
      referenceId: 'leadQuery'
    }
  ]
};

// Single API call executes all operations
const response = await fetch(
  `${instanceUrl}/services/data/v60.0/composite`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(compositeRequest)
  }
);

// Every request queries Salesforce, even for unchanged data
const getProductInfo = async (productId) => {
  // This API call happens every time, even if product hasn't changed
  const response = await fetch(
    `${instanceUrl}/services/data/v60.0/sobjects/Product2/${productId}`,
    { headers: { 'Authorization': `Bearer ${accessToken}` } }
  );
  return await response.json();
};

// Called 1000 times per hour = 1000 API calls

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 3600 }); // 1 hour TTL

const getProductInfo = async (productId) => {
  // Check cache first
  const cached = cache.get(`product_${productId}`);
  if (cached) {
    console.log('Cache hit - no API call needed');
    return cached;
  }

  // Cache miss - query Salesforce
  const response = await fetch(
    `${instanceUrl}/services/data/v60.0/sobjects/Product2/${productId}`,
    { headers: { 'Authorization': `Bearer ${accessToken}` } }
  );
  const data = await response.json();

  // Store in cache
  cache.set(`product_${productId}`, data);
  return data;
};

// First call: 1 API call (cache miss)
// Next 999 calls in same hour: 0 API calls (cache hits)

// Subscribe to Product update events
client.subscribe('/data/Product2ChangeEvent', (message) => {
  const productId = message.data.payload.Id;

  // Invalidate cache when product changes
  cache.del(`product_${productId}`);
  console.log(`Cache invalidated for product ${productId}`);
});

// Updating 50,000 account records with REST API
for (const account of accounts) {
  await fetch(
    `${instanceUrl}/services/data/v60.0/sobjects/Account/${account.Id}`,
    {
      method: 'PATCH',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ Industry: 'Technology' })
    }
  );
  // Each update: 1 API call
}

// Total: 50,000 API calls

// Step 1: Create bulk job (1 API call)
const jobResponse = await fetch(
  `${instanceUrl}/services/data/v60.0/jobs/ingest`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ operation: 'update', object: 'Account' })
  }
);
const job = await jobResponse.json();

// Step 2: Upload data in CSV format (1 API call)
const csvData = accounts.map(a => `${a.Id},Technology`).join('\n');
const csv = `Id,Industry\n${csvData}`;

await fetch(
  `${instanceUrl}/services/data/v60.0/jobs/ingest/${job.id}/batches`,
  {
    method: 'PUT',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'text/csv'
    },
    body: csv
  }
);

// Step 3: Close job to start processing (1 API call)
await fetch(
  `${instanceUrl}/services/data/v60.0/jobs/ingest/${job.id}`,
  {
    method: 'PATCH',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ state: 'UploadComplete' })
  }
);

// Step 4-5: Monitor job status (2 API calls)
let jobStatus = await checkJobStatus(job.id);
while (jobStatus.state !== 'JobComplete') {
  await sleep(5000);
  jobStatus = await checkJobStatus(job.id);
}

// Total: 5 API calls for 50,000 records

// BAD: Querying inside loop (1000 API calls)
for (const orderId of orderIds) {
  const order = await query(
    `SELECT Id, Status, Amount FROM Order WHERE Id = '${orderId}'`
  );
  processOrder(order);
}

// Total: 1000 queries = 1000 API calls

// GOOD: Single query with IN clause (1 API call)
const orderIdsString = orderIds.map(id => `'${id}'`).join(',');
const orders = await query(
  `SELECT Id, Status, Amount FROM Order WHERE Id IN (${orderIdsString})`
);

orders.forEach(order => processOrder(order));

// Total: 1 query = 1 API call
// Savings: 999 API calls (99.9% reduction)

// Fetching all fields (slower, more data)
const accounts = await query(
  'SELECT FIELDS(ALL) FROM Account LIMIT 1000'
);
// Returns 50+ fields per record

// Fetch only needed fields
const accounts = await query(
  'SELECT Id, Name, Industry FROM Account LIMIT 1000'
);
// Returns only 3 fields per record — faster, less data transfer
// Faster response, less data transfer
// API call count: same, but efficiency improved
                 

 javascript
// Fetching 50,000 records in multiple queries

let offset = 0;
const batchSize = 2000;
const allRecords = [];

while (offset < 50000) {
  const batch = await query(
    `SELECT Id, Name FROM Account LIMIT ${batchSize} OFFSET ${offset}`
  );
  allRecords.push(...batch);
  offset += batchSize;
}

// Total: 25 queries = 25 API calls

javascript
// Use queryMore with locator
let queryResult = await query(
  'SELECT Id, Name FROM Account'
);

const allRecords = queryResult.records;

while (!queryResult.done) {
  queryResult = await queryMore(queryResult.nextRecordsUrl);
  allRecords.push(...queryResult.records);
}

// Same 50,000 records
// Total: Fewer API calls (depends on batch size)
// More efficient, handles governor limits better

                 

// Check current API usage
const checkAPILimits = async () => {
  const response = await fetch(
    `${instanceUrl}/services/data/v60.0/limits`,
    { headers: { 'Authorization': `Bearer ${accessToken}` } }
  );

  const limits = await response.json();

  const dailyLimit = limits.DailyApiRequests.Max;
  const dailyUsed  = limits.DailyApiRequests.Remaining;
  const percentUsed = ((dailyLimit - dailyUsed) / dailyLimit) * 100;

  console.log(`API Usage: ${percentUsed.toFixed(1)}%`);
  console.log(`Remaining: ${dailyUsed.toLocaleString()} of ${dailyLimit.toLocaleString()}`);

  if (percentUsed > 80) {
    sendAlert({
      severity: 'WARNING',
      message: `API usage at ${percentUsed.toFixed(1)}%`,
      remaining: dailyUsed
    });
  }

  if (percentUsed > 95) {
    sendAlert({
      severity: 'CRITICAL',
      message: `API limit nearly exhausted: ${percentUsed.toFixed(1)}%`,
      remaining: dailyUsed
    });
  }

  return { limit: dailyLimit, used: dailyLimit - dailyUsed, remaining: dailyUsed, percentUsed };
};

// Monitor every 15 minutes
setInterval(checkAPILimits, 15 * 60 * 1000);

const calculateDailyAPIConsumption = (config) => {
  const {
    recordsPerDay,      // How many records processed daily
    apiCallsPerRecord,  // API calls needed per record
    batchSize,          // Records processed per batch (if batching)
    cacheHitRate,       // Percentage of requests served from cache
    compositeUsage      // Are you using Composite API?
  } = config;

  let apiCallsNeeded;

  if (compositeUsage) {
    apiCallsNeeded = Math.ceil(recordsPerDay / 25);
  } else if (batchSize > 1) {
    apiCallsNeeded = Math.ceil(recordsPerDay / batchSize) * apiCallsPerRecord;
  } else {
    apiCallsNeeded = recordsPerDay * apiCallsPerRecord;
  }

  // Apply cache effectiveness
  const effectiveAPICalls = apiCallsNeeded * (1 - cacheHitRate);
  return Math.ceil(effectiveAPICalls);
};

// Example calculation
const estimate = calculateDailyAPIConsumption({
  recordsPerDay:     10000,
  apiCallsPerRecord: 3,
  batchSize:         1,
  cacheHitRate:      0,
  compositeUsage:    false
});

console.log(`Estimated daily API calls: ${estimate.toLocaleString()}`);
// Output: Estimated daily API calls: 30,000

const compareOptimizations = (baseline, optimized) => {
  const savings = baseline - optimized;
  const percentReduction = (savings / baseline) * 100;

  console.log(`Baseline:  ${baseline.toLocaleString()} calls/day`);
  console.log(`Optimized: ${optimized.toLocaleString()} calls/day`);
  console.log(`Savings:   ${savings.toLocaleString()} calls/day`);
  console.log(`Reduction: ${percentReduction.toFixed(1)}%`);

  return { savings, percentReduction };
};

// Example: E-commerce integration optimization
compareOptimizations(150000, 45000);
// Baseline:  150,000 calls/day
// Optimized:  45,000 calls/day
// Savings:   105,000 calls/day
// Reduction: 70.0%