Salesforce API Limits: A Practical Guide for the Enterprise Edition Guide 

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 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.

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 Different Types of Salesforce API Limits

Salesforce Enterprise Edition sits in the middle of Salesforce’s offerings, between Professional and Unlimited. 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 licenses x calls per license 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

These API calculations reveal only part of Salesforce’s cost structure. Many organizations discover they’re paying for unused licenses just to increase API limits, or purchasing expensive add-on packages when integrations scale. Learn more about how Salesforce structures these expenses beyond the published pricing.

API limits vary by Salesforce edition and license type

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

By Salesforce edition:

• Developer Edition: Fixed at 15,000 requests per day (no per-user calculation)
• Enterprise Edition: 100,000 + (1,000 × number of Salesforce licenses)
• Unlimited/Performance Edition: 100,000 + (5,000 × number of Salesforce licenses)

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

• Salesforce/Salesforce Platform licenses: 1,000 calls each
• Lightning Platform – One App: 200 calls each
• Customer Community licenses: 0 calls
• Customer Community Plus: 200 calls each
• Partner Community: 200 calls each
• External Identity licenses: 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 license types, your actual daily limit may differ from the simple calculation. Check your specific license mix in Setup > Company Information to see your exact allocation.

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

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: If you exceed these limits, new requests either wait in a queue or fail immediately with a REQUEST_LIMIT_EXCEEDED error. 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.
Concurrent batches	5 active at once	No more than 5 batches can run at the same time; others wait in a queue.

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.

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	100 per org
Streaming API events	1,000,000 per 24 hours
Report API (async)	1,200 per hour
Apex callouts	100 per transaction
SOQL queries	100 per transaction
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 ensure your limits are not finished early, you also need to track and monitor your API usage to catch problems before they cause failures.

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, DailyBulkApiRequests: Bulk API consumption
• 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.

Options include:

• 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 one-minute polling to webhooks can cut API usage by 90% or more.

2. Use Bulk API for large operations

Any job touching more than a few hundred records should use Bulk API:

• 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

Often, one poorly configured integration consumes more than all others combined. Finding it solves the whole 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

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

Twenty CRM eliminates API limit headaches 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 that offer more flexibility. 

Twenty CRM represents a different architectural approach. As an open-source platform, you can self-host or deploy in the cloud; there are no vendor-imposed daily quotas blocking your integrations.

This means:

• No artificial ceilings: 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 or free for self-hosted deployments—no surprise charges when your integration usage grows

Moving from Salesforce’s API-limited architecture to Twenty CRM requires careful planning to ensure integrations continue running smoothly. TaskRhino’s Twenty CRM service handles the complete migration process, including rebuilding your integrations without the constraints that caused problems in Salesforce. 

We’ve helped companies running 500,000+ daily API calls eliminate limit-related failures entirely. TaskRhino configures Twenty CRM’s API infrastructure to handle your specific integration requirements. We’ve migrated companies running 500,000+ daily API calls from Salesforce without the constant limit monitoring and optimization overhead.”

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. Its open-source, self-hosted or cloud-ready platform removes vendor-imposed API ceilings, 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 most implementations completed in 2–4 weeks
• 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 smoothly, ensuring zero data loss, proper workflow setup, and ongoing support. 

How TaskRhino Makes Migration Seamless

TaskRhino has migrated dozens of companies from Salesforce to Twenty CRM, including 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
• Zero-downtime migration: Your integrations continue running while we migrate data and rebuild connections in Twenty CRM
• Custom API development: We build the specific integrations your business needs without artificial limits
• Ongoing optimization: Unlike Salesforce consultants who bill hourly to manage your API usage, we ensure your Twenty CRM deployment scales efficiently from day one

Most implementations complete in 2–4 weeks, with integration testing included throughout to ensure data flows correctly across all your systems.