Salesforce API Limits: Daily Allocations and Best Practices

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. Integration failures nobody planned for are one of the reasons Salesforce CRM projects don’t deliver expected results.

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 licenses x calls per license type)

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

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. Our guide to Salesforce alternatives covers platforms to weigh against this cost structure.

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

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.

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:

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:

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, 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:

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.

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:

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

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

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 Salesforce to Twenty migration process, 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.

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, get in touch with us. 

Frequently Asked Questions