# Salesforce API Limits: Daily Allocations and Best Practices

Canonical: https://www.taskrhino.ca/salesforce-alternatives/api-limits/

> Salesforce API limits explained: daily request allocations by edition, concurrent and Bulk API caps, how to monitor usage, and how to avoid the limit.

Published: 2026-02-05  
Updated: 2026-10-29  
Author: Rakesh Patel  
Categories: Guide

**Key takeaways**

-   Enterprise Edition allows 100,000 API requests per rolling 24 hours plus 1,000 per Salesforce licence: 125,000 for 25 users.
-   Unlimited and Performance Editions add 5,000 per Salesforce licence instead of 1,000 per licence.
-   In production, only 25 long-running requests (20 seconds or longer) can run at once; shorter requests have no concurrency limit.
-   Bulk API and Bulk API 2.0 share one pool of 15,000 batches per rolling 24 hours.
-   Self-hosted Twenty CRM has no vendor API quota; Twenty Cloud caps API traffic per minute instead (50 requests/minute on Pro).

If you're running integrations with Salesforce, you've probably hit a wall called API limits. These restrictions control how often your connected apps can talk to Salesforce, and for Enterprise Edition users, they can become a serious bottleneck.

One moment, everything works fine. Next, your marketing automation stops. Data syncs fail. Dashboards go stale. When your business depends on real-time data flowing between systems, [Salesforce API limits](https://developer.salesforce.com/docs/atlas.en-us.salesforce_app_limits_cheatsheet.meta/salesforce_app_limits_cheatsheet/salesforce_app_limits_platform_api.htm) become more than a technical issue. They become a business risk.

This guide breaks down the exact API limits for Enterprise Edition, shows you how to monitor usage, and shares practical strategies to stay within bounds. We'll also explore Twenty CRM as a cost-effective alternative that gives growing businesses more flexibility without the enterprise overhead.

## What are Salesforce API Limits?

Whenever an app or system talks to Salesforce, it makes an **API call**. For example:

-   Pulling contact data? That’s an API call.
-   Updating a deal? Another call.
-   Syncing records to your data warehouse? More calls.

Salesforce counts all these calls and sets a limit on how many you can make. These are called **API limits**.

### Why Salesforce enforces limits on using APIs

Salesforce runs on shared infrastructure. Thousands of companies use the same servers and resources. Without limits, one company could use too many resources and slow things down for everyone else.

#### API limits exist to:

-   **Protect performance:** No one org can hog resources
-   **Keep things fair:** Everyone gets their share
-   **Maintain stability:** Prevent runaway scripts from crashing the system

While these limits make sense for Salesforce, businesses with complex integrations can hit these limits quickly, causing real headaches.

### Soft limits vs. hard limits

Not all API limits behave the same way. Understanding the difference between **soft limits** and **hard limits** is key to avoiding unexpected failures and keeping your integrations running smoothly.

-   **Soft limits:** You can temporarily exceed your daily allocation, but Salesforce monitors usage closely. If calls keep climbing, protection mechanisms kick in and start blocking requests.
-   **Hard limits:** These are strict. If you hit the concurrent request cap or exceed the timeout threshold, your API calls fail instantly. There are no warnings and no grace period.

The tricky part is that soft-limit issues often grow silently. By the time errors appear, the problem may have been building for hours, making it harder to diagnose and fix. Integration failures nobody planned for are one of the [reasons Salesforce CRM projects don’t deliver expected results](https://www.taskrhino.ca/salesforce-alternatives/why-crm-projects-underperform/).

Now that you understand how API limits work, let’s look at the **Salesforce Enterprise Edition API limits** in detail so you can plan your integrations accordingly.

## 4 Key Types of Salesforce API Limits You Need to Understand

In Salesforce’s limits guide, Enterprise Edition sits between Professional (which needs API access enabled) and Unlimited/Performance. It provides robust features for larger teams, but like all editions, it comes with limits on how many API calls you can make.

In this section, we’ll break down the four main types of API limits in Enterprise Edition—daily requests, concurrent requests, bulk API, and specialized limits, so you can plan integrations effectively and avoid unexpected failures.

### 1\. Daily API request limits

Salesforce Enterprise Edition gives you a daily pool of API calls, made up of two parts:

-   **Base amount:** 100,000 requests per 24-hour rolling window
-   **Per-user bonus:** 1,000 extra requests for each licensed user

In other words, your total daily limit is calculated like this:

**Total Daily Limit =** 100,000 + (number of licences x calls per licence type)

Here’s what that looks like for different team sizes:

| **Team Size** | **Calculation** | **Daily Limit** |
| --- | --- | --- |
| 10 users | 100,000 + 10,000 | 110,000 requests |
| 25 users | 100,000 + 25,000 | 125,000 requests |
| 50 users | 100,000 + 50,000 | 150,000 requests |
| 100 users | 100,000 + 100,000 | 200,000 requests |

Key stat

125,000 daily API requests for an Enterprise org with 25 Salesforce licences (100,000 + 25 × 1,000).

These API calculations reveal only part of Salesforce's cost structure. Many organizations discover they're paying for unused licences just to increase API limits, or purchasing expensive add-on packages when integrations scale. Our [guide to Salesforce alternatives](https://www.taskrhino.ca/salesforce-alternatives/) covers platforms to weigh against this cost structure.

#### API limits vary by Salesforce edition and licence type

While Enterprise Edition follows the formula above for standard Salesforce licences, other editions and licence types have different allocations:

**By Salesforce edition:**

-   Developer Edition: Fixed at 15,000 requests per day (no per-user calculation)
-   Enterprise Edition (and Professional Edition with API access enabled): 100,000 + (1,000 × number of Salesforce licences)
-   Unlimited/Performance Edition: 100,000 + (5,000 × number of Salesforce licences)

By Licence Type (within Enterprise Edition): Different user licence types contribute different amounts to your daily pool:

-   Salesforce/Salesforce Platform licences: 1,000 calls each
-   Lightning Platform - One App: 200 calls each
-   Customer Community licences: 0 calls
-   Customer Community Plus: 200 calls each
-   Partner Community: 200 calls each
-   External Identity licences: Varies by tier
    -   25,000 tier: 70,000 calls
    -   250,000 tier: 750,000 calls
    -   1,000,000 tier: 4,000,000 calls

Why this matters: If your org uses multiple licence types, your actual daily limit may differ from the simple calculation. Check your specific licence mix in Setup > Company Information to see your exact allocation.

**Important:** The limit is per rolling 24-hour period, and the documentation states that limits are “enforced against the aggregate of all API calls made to the org in a 24-hour period,” not per user.

Definition

A rolling 24-hour window counts API calls over the past 24 hours from any moment, not per calendar day, so a burst of calls this morning still counts against your total until the same time tomorrow.

### 2\. Concurrent request limits

Salesforce also controls how many API requests can run at the same time. These limits vary by org type to ensure platform stability.

| Org Type | Long-Running Request Limit (20+ seconds) |
| --- | --- |
| Developer Edition and Trial orgs | 5 |
| Production orgs and Sandboxes | 25 |

What this means:

-   Long-running requests: Calls that take 20 seconds or longer are capped at 5 (Developer/Trial) or 25 (Production)
-   Short requests: There's no limit on concurrent requests that complete in under 20 seconds

What happens when you hit the limit: new long-running requests fail with a REQUEST\_LIMIT\_EXCEEDED error until fewer than the allowed number are running. When multiple integrations try connecting at once, these failures can cascade quickly, potentially disrupting your workflows.

Important for testing: If you're developing and testing integrations in a Developer Edition or Trial org, remember you're limited to just 5 concurrent long-running requests—much lower than the 25 you'll have in production.

### 3\. Bulk API limits

Salesforce’s Bulk API is built for processing large volumes of data efficiently, but it has rules in place to keep operations stable and predictable. This prevents any single job from overwhelming the system or causing failures across other integrations. Here’s a breakdown:

| Limit Type | Allocation | What It Means |
| --- | --- | --- |
| **Daily batches** | 15,000 per 24 hours | You can run up to 15,000 bulk operations in one day. |
| **Records per batch** | 10,000 maximum | Each batch can include up to 10,000 records. |
| **Payload size** | 10 MB per batch | The total size of data in a batch can’t exceed 10 MB. |

**Important note:** Bulk API 1.0 and 2.0 share the same **daily batch pool**. Using both versions doesn’t give you extra capacity: your total daily allocation remains the same (in Bulk API 2.0, only ingest jobs use batches).

#### Why these limits exist:

-   **Stability:** Prevents one large data job from slowing down Salesforce for everyone else.
-   **Predictability:** Helps you plan data loads without unexpected failures or timeouts.

### 4\. Other limits worth knowing

In addition to daily, concurrent, and Bulk API limits, several specialized APIs have their own caps that can affect how your integrations run:

| API Type | Limit |
| --- | --- |
| **Streaming API topics** | 50 per org (100 on Unlimited and Performance) |
| **Streaming API events** | 200,000 per 24 hours (1,000,000 on Unlimited and Performance) |
| **Report API (async)** | 1,200 per hour |
| **Apex callouts** | 100 per transaction |
| **SOQL queries** | 100 per synchronous transaction (200 asynchronous) |
| **Request timeout** | 10 minutes maximum |

These limits can add up quickly. For example, if a marketing platform, analytics tool, support system, and custom app are all making API calls at the same time, your allocation can be used up well before the day is over, sometimes as early as mid-morning.

To prevent early limit exhaustion, monitor API usage to catch issues before failures occur. Tracking usage also helps identify [hidden costs in Salesforce](https://www.taskrhino.ca/salesforce-alternatives/hidden-costs/), such as extra integration maintenance, middleware expenses, and added development required when API limits restrict automation.

## How to Check and Monitor Your API Usage: 3 Ways

Knowing your API limits is only half the battle. To avoid unexpected outages, you need to actively monitor usage so you can spot spikes before they disrupt your workflows.

### 1\. Using Salesforce setup

The simplest way to get a snapshot of your usage is right in Salesforce:

1.  Go to **Setup** in your Salesforce org
2.  Type **System Overview** in Quick Find
3.  Look at **API Requests – Last 24 Hours**
4.  Compare usage against your total allocation

This gives you a quick view of where you stand. The downside? It won’t show trends over time or alert you if usage suddenly spikes.

### 2\. Using the REST API limits endpoint

Salesforce provides a **Limits endpoint** that returns live API usage data. Here’s how you can use it:

-   **Get access:** Use a valid Salesforce session or OAuth token. This is the same token you use to call other Salesforce APIs.
-   **Call the endpoint:** Use the code: **GET /services/data/v59.0/limits/**, **Authorization: Bearer YOUR\_ACCESS\_TOKEN** and take help of tools like **Postman**, **cURL**, or your programming language’s HTTP library.
-   **Review the returned data:** The endpoint provides real-time usage stats, including: **DailyApiRequests:** How many daily requests are used vs. remaining, **ConcurrentAsyncGetReportInstances:** Active report calls, **DailyBulkApiBatches:** Bulk API and Bulk API 2.0 batches
-   **Optional:** Connect to dashboards or scripts to track trends and set alerts before hitting limits.

### 3\. Setting up proactive alerts

Waiting until you hit 100% usage can be costly—your integrations may already be failing. Set alerts around **80% of your limits** so you can take action before it’s too late.

TaskRhino tip

Turn on API Usage Notifications in Setup so a designated user gets an email when usage passes a set percentage, such as 80%.

Options include:

-   **API Usage Notifications:** Built into Setup; emails a designated user when requests pass a percentage you set
-   **Salesforce Event Monitoring:** Built-in, but may have additional costs
-   **Third-party monitoring tools:** Datadog, New Relic, and others
-   **Custom Apex jobs:** Scheduled scripts that check usage and send email alerts
-   **Integration platforms:** MuleSoft, Workato, or others often include built-in monitoring

For businesses growing fast, like those using **Twenty CRM** alongside Salesforce, proactive monitoring ensures your integrations stay smooth and uninterrupted. By catching issues early, you keep data flowing across marketing, sales, and analytics tools without hitting API walls.

## 4 Best Practices to Avoid Hitting Salesforce API Limits

Keeping your API usage under control ensures integrations run smoothly without constant worry. Here are proven practices for teams to avoid hitting their usage limit:

### 1\. Optimize how often you call

Small changes can dramatically reduce consumption:

-   **Batch requests:** Combine multiple operations into single calls where possible
-   **Stop polling:** Replace frequent checks with webhooks or Streaming API
-   **Cache data:** Store commonly accessed information locally
-   **Sync incrementally:** Only request records that changed, not everything

Switching from frequent polling to webhooks or the Streaming API can cut API usage sharply.

### 2\. Use Bulk API for large operations

Salesforce suggests Bulk API 2.0 for any data operation with more than 2,000 records, such as:

-   Data imports and exports
-   Mass updates across records
-   Initial loads for new integrations
-   Scheduled large-scale syncs

Bulk API handles thousands of records per batch. Updating 10,000 records takes one batch instead of 10,000 individual calls.

### 3\. Audit your connected apps

Many organizations don't realize how many tools connect to Salesforce. Each one consumes API calls.

Run a thorough audit:

1.  Check connected apps in Setup
2.  Identify which integrations use the most calls
3.  Consolidate tools doing similar work
4.  Remove integrations no longer in use
5.  Work with vendors on more efficient sync patterns

Sometimes a single poorly configured integration accounts for most of the usage, so finding it solves most of the problem.

### 4\. Build in resilience

Design integrations to handle spikes gracefully:

-   Queue requests during high-traffic periods
-   Use exponential backoff for retries
-   Prioritize critical operations over background tasks
-   Schedule batch jobs during off-peak hours

**Feeling Limited by Salesforce API Limits?**

Twenty CRM is a modern, open-source alternative from $9 per user/month (USD), or free to self-host. TaskRhino helps you evaluate, implement, and migrate.

[**Schedule a Free Consultation**](https://www.taskrhino.ca/contact-us/)

Even with careful monitoring and optimization, Salesforce API limits remain a structural constraint. You're constantly managing workarounds—batching calls, reducing polling frequency, watching usage dashboards—just to prevent integration failures. For growing businesses, this ongoing limit management becomes another hidden operational cost on top of already expensive Salesforce licensing.

This is exactly why companies are reconsidering whether Salesforce's architecture still makes sense for their needs. That’s where Twenty CRM offers a different path.

## How Twenty CRM Avoids the API Limit Headache

Self-hosted Twenty CRM avoids vendor API quotas because you control the infrastructure. For some growing businesses, constant API limit management feels like fighting the platform instead of using it. This constraint is one of several reasons [why companies are leaving Salesforce for open-source CRM alternatives](https://www.taskrhino.ca/salesforce-alternatives/open-source/) that offer more flexibility. 

Twenty CRM represents a different architectural approach. As an open-source platform, you can self-host with no vendor-imposed API quotas, or use Twenty Cloud, which caps API traffic per minute (50 requests/minute on Pro, 100 on Organization) rather than per day.

**This means:**

-   **No vendor ceilings when self-hosted:** Run high-frequency integrations without hitting vendor caps that shut down your operations mid-day
-   **Your infrastructure, your rules:** Scale API capacity based on your actual needs, not what a vendor's pricing tier allows
-   **Developer-friendly APIs:** Full REST and GraphQL access designed for modern integration patterns, not legacy SOAP limitations
-   **Predictable costs:** Cloud hosting at $9/user/month (USD, billed yearly) (API capped at 50 requests/minute on Pro) or free for self-hosted deployments with no API caps

Moving from Salesforce's API-limited architecture to Twenty CRM requires careful planning to ensure integrations continue running smoothly. [TaskRhino's Twenty CRM service](https://www.taskrhino.ca/twenty-crm-implementation/) handles the complete [Salesforce to Twenty migration process](https://www.taskrhino.ca/data-migration/salesforce-to-twenty-crm/), including rebuilding your integrations without the constraints that caused problems in Salesforce. 

TaskRhino configures Twenty CRM's API infrastructure to handle your specific integration requirements. For the wider picture beyond APIs, see our [Twenty CRM vs Salesforce comparison](https://www.taskrhino.ca/twenty-crm-implementation/twenty-crm-vs-salesforce/).

## Avoid API Limit Frustrations with Twenty CRM

Salesforce Enterprise Edition comes with real, enforceable API limits:

-   **Daily limit:** 100,000 requests + 1,000 per user
-   **Concurrent limit:** Caps on simultaneous and long-running requests
-   **Bulk API:** 15,000 batches per day

For teams that rely on real-time data flows, these limits can lead to integration failures, stale data, and unexpected costs. While careful monitoring, batching, and optimization can help, managing these constraints often becomes a full-time operational challenge and a source of frustration for growing businesses.

**Twenty CRM** offers a modern alternative. Self-hosted, its open-source platform has no vendor-imposed API ceilings, and Twenty Cloud uses per-minute caps rather than daily quotas, giving you:

-   **Freedom to integrate** at your own pace without worrying about hitting hard limits
-   **Full data ownership and control**, so your CRM adapts to your business, not the other way around
-   **Faster time to value**, with a simpler data model to set up and integrate
-   **Significant cost savings**, with cloud-hosted plans starting at $9/user/month or free for self-hosted deployments

For organizations that have outgrown the complexity and limitations of legacy CRMs, **TaskRhino** can help you migrate to Twenty CRM with data validation, proper workflow setup, and ongoing support. 

## How TaskRhino Makes Migration Seamless

For organizations hitting daily API limits across marketing automation, support systems, and data warehouses, our implementation process includes:

-   **Integration architecture assessment:** We map your current API usage patterns and design a Twenty CRM setup that eliminates bottlenecks
-   **Phased cutover:** Your Salesforce integrations keep running until their Twenty CRM replacements are tested
-   **Custom API development:** We build the specific integrations your business needs without artificial limits
-   **Ongoing optimization:** We tune your Twenty CRM deployment so it keeps up as your integrations grow

Integration testing is included throughout to ensure data flows correctly across all your systems. If you are looking for a [Twenty CRM implementation service](https://www.taskrhino.ca/twenty-crm-implementation/), get in touch with us. 

**Ready to Leave API Limits Behind and Migrate to a Flexible CRM?**

Partner with TaskRhino to smoothly migrate to Twenty CRM, gain full control over your data, and enjoy faster integrations without vendor-imposed restrictions.

[**Schedule Your Free Migration**](https://www.taskrhino.ca/contact-us/) 

## Frequently Asked Questions

**What is the API limit for Salesforce Enterprise Edition?**

### 

Enterprise Edition provides 100,000 API requests per 24-hour rolling period, plus 1,000 additional requests for each user licence. An org with 25 users gets 125,000 daily requests. This covers all REST, SOAP, and Bulk API calls from connected applications.

**How do I check my Salesforce API usage?**

### 

Go to Setup, search for "System Overview," and find the "API Requests, Last 24 Hours" section. For automated monitoring, query the /services/data/v59.0/limits/ REST endpoint to get real-time usage data including requests used, remaining allocation, and concurrent consumption.

**Can I purchase more Salesforce API calls?**

### 

Yes. You can buy extra API calls or additional user licences through the Your Account app or your account executive. Upgrading to a higher edition (Advanced is $395/user/month for new buyers since September 2026) also increases allocations. Both options add significant cost to your existing fees.

**What happens when I exceed my API limit?**

### 

On paid orgs, Salesforce lets calls continue for a limited amount beyond the daily allocation to absorb occasional spikes, but a hard cap applies. Once it is reached, API calls return a REQUEST\_LIMIT\_EXCEEDED error, and every connected application that uses the API (marketing automation, data syncs, support tools, custom integrations) fails until usage falls back within the rolling 24-hour window.

**How is Twenty CRM different from Salesforce?**

### 

Twenty CRM is an open-source platform offering full CRM capabilities at $9/user/month (or free for self-hosted). It provides complete data ownership and less vendor lock-in, and self-hosted deployments have no vendor API quota. The open-source model gives you flexibility that proprietary platforms can’t match.

**How long does it take to migrate from Salesforce to Twenty CRM?**

### 

It depends on data volume, customizations and the number of integrations to rebuild. A data and integration audit comes first, followed by data transfer, workflow setup, integration testing and team training. Complex organizations with extensive customizations need more time for thorough testing.