Hub and Spoke Topic: Salesforce

Quick Answer

Salesforce doesn’t have native webhook functionality, but you can achieve similar real-time data synchronization through three main approaches: outbound messages (SOAP-based), custom Apex REST endpoints, or third-party webhook apps.

The most practical solution for most businesses is using outbound messages combined with middleware or tools like Coefficient for Salesforce or any other system . This guide covers both traditional setup methods and modern no-code alternatives that eliminate the complexity of custom development while providing enterprise-grade reliability.

Prerequisites and Requirements

Before you begin setting up Salesforce webhook integrations, ensure you have:

Salesforce Account Requirements:

• Active Salesforce account with sufficient permissions to create and edit integrations
• API access enabled (ensure your edition supports API access and your user profile has API permissions)
• Administrative access to Setup menu for creating outbound messages and flows

Technical Knowledge:

• Working understanding of Salesforce object model and workflow automation
• Basic familiarity with webhooks, APIs, and HTTP protocols
• For custom endpoints: Apex development skills (optional for advanced integrations)

External Endpoint Setup:

• Secure external endpoint configured to receive webhook calls (HTTPS required)
• Ability to handle SOAP XML format for outbound messages or JSON for custom solutions

API Limits to Consider:

License / Edition	Daily API Request Limit	Concurrent Requests (over 20s)	Other Limits
Developer/Trial	15,000	5	10 min timeout per call
Enterprise (15 licenses)	115,000 (100,000 + 1,000/license)	25
Performance/Unlimited	Higher (varies by contract)	25
Bulk API batch	15,000 batch submissions/day	N/A	10,000 records or 10MB/file per batch
Streaming API	200,000 events/day (Enterprise)	N/A	50 PushTopics/org (Enterprise)
Apex Callouts	100 callouts per execution context	N/A	Timeout: up to 120sec/callout

Important: Exceeding daily API limits will cause all integrations—including webhooks—to stop working until limits reset.

Step-by-Step Salesforce Webhook Setup

Method 1: Using Outbound Messages (Recommended for Beginners)

Step 1: Create the Outbound Message

Navigate to Setup in your Salesforce org. In the Quick Find box, search for “Outbound Messages” and select it from the results.

Click “New Outbound Message” and choose your target object (e.g., Account, Contact, Lead). This determines what data will be sent when the webhook triggers.

Configure your outbound message settings:

• Name: Give your webhook a descriptive name
• Endpoint URL: Enter your external system’s webhook URL (must be HTTPS)
• User to send as: Select the Salesforce user context for the message
• Fields to send: Choose which object fields to include in the webhook payload

Save your configuration. Salesforce will generate WSDL documentation for your endpoint to handle the incoming SOAP messages.

Step 2: Create a Workflow Rule or Flow

For workflow rules, navigate to Setup > Process Automation > Workflow Rules. Create a new rule targeting the same object as your outbound message.

Set your evaluation criteria (e.g., “when a record is created or edited”) and define entry conditions that determine when the webhook should fire.

Add a workflow action of type “Outbound Message” and select the message you created in Step 1.

Alternatively, use Flow Builder for more advanced logic:

• Create a Record-Triggered Flow
• Set the trigger to “After Save”
• Add an Action element and select your outbound message
• Configure any additional logic or conditions

Step 3: Test Your Integration

Activate your workflow rule or flow. Create or modify a record that meets your criteria to trigger the webhook.

Monitor the webhook delivery in Setup > Environments > Monitoring > Outbound Messages. This shows delivery status and retry attempts.

Verify that your external endpoint receives the SOAP message correctly. If messages fail, check your endpoint’s SSL certificate and response handling.

Method 2: Custom Apex REST Endpoints (Advanced)

Step 1: Create a Salesforce Site

In Setup, navigate to Sites and Domains > Sites. Create a new site with a descriptive label.

Note the domain name and path, as these form your webhook URL. Configure site settings and permissions carefully to maintain security.

Step 2: Build the Apex REST Class

Create an Apex class with the @RestResource annotation:

Copy Code

@RestResource(urlMapping=’/webhook/myintegration/*’)

global class MyWebhookHandler {

    

    @HttpPost

    global static String handleWebhook() {

        // Parse incoming request

        RestRequest req = RestContext.request;

        String requestBody = req.requestBody.toString();

        

        // Process the webhook data

        try {

            // Your business logic here

            return ‘Success’;

        } catch (Exception e) {

            return ‘Error: ‘ + e.getMessage();

        }

    }

}

Step 3: Configure Site Permissions

Set appropriate permissions for your site to access the Apex class while maintaining security. Enable the specific Apex class in your site’s settings.

Test your endpoint using the URL format: https://yoursite.force.com/services/apexrest/webhook/myintegration

Common Integration Issues

No Native Webhook Support & Integration Complexity

Issue Explanation: Unlike platforms with point-and-click webhook setup, Salesforce has no direct, out-of-the-box webhook listener functionality. To handle inbound webhook calls, users must either build custom Apex REST endpoints, utilize middleware/microservices, or adopt third-party AppExchange products. This requirement increases integration complexity and the necessary skill set—especially for declarative (code-free) Salesforce users.

Solution: Consider using pre-built solutions like Coefficient for spreadsheet integrations or AppExchange apps that provide webhook functionality without custom development.

API Limits Causing Intermittent Failures

Issue Explanation: Every Salesforce org is subject to strict daily API call and concurrency limits. Integrations that regularly push or pull data at scale may rapidly exhaust these quotas. Once limits are hit, ALL API-driven integrations—including webhooks, connected apps, ETLs, or even user automations—will start failing until limits reset.

Solution: Monitor API usage in Setup > System Overview > API Usage. Consider upgrading your Salesforce edition or optimizing integration frequency to stay within limits.

Field Mapping and Data Compatibility Mismatches

Issue Explanation: Webhooks often require field mapping between external payloads and Salesforce object schema. Issues arise if Salesforce objects have required fields not populated by the webhook, data types are mismatched, or picklist values are restricted.

Solution: Carefully map all required fields before deployment. Use validation rules and exception handling to manage data type mismatches gracefully.

Workflow Timing and Data Consistency Problems

Issue Explanation: Complex real-time integrations can suffer from timing issues or loss of context. When webhooks trigger screen flows or update records during concurrent Salesforce operations, variables may be lost, or UI interruptions can prevent agents from completing critical tasks.

Solution: Use platform events combined with flows to preserve context and reduce UI interference. Consider queueing mechanisms for high-volume scenarios.

No-code Webhook Workflows for Google Sheets or Excel

Building custom webhook integrations between Salesforce and spreadsheets traditionally requires weeks of development work and ongoing maintenance. Coefficient transforms this process into a 5-minute setup that anyone can handle.

Instead of wrestling with complex API documentation, custom code, and security configurations, Coefficient provides a direct bridge between your Salesforce data and spreadsheets. Whether you’re using Excel or Google Sheets, you get enterprise-grade reliability without the enterprise-level complexity.

How Coefficient’s Webhooks Work:

Webhooks let you trigger live data pulls into Coefficient from any system you use, which means your external systems can now tell Coefficient exactly when to refresh a data import. Whether data changes in Salesforce, your spreadsheet can react in real-time.

Instead of waiting for a scheduled sync or refreshing manually, you can keep dashboards and reports up to date the moment your source data changes.

Step-by-Step Setup:

1. Import Data: Begin by importing data from Salesforce into your spreadsheet using the Coefficient sidebar
2. Access Import Settings: Locate your Salesforce import in the “Imports” section
3. Open the Menu: Click the three-dot menu icon next to the import’s name
4. Select Edit: Choose “Edit” from the dropdown menu
5. Find Webhook URL: In the edit screen, click the three-dot menu again and select “Webhook URL”
6. Choose Your Refresh Scope:
   • Refresh this import only: For single-import triggers
   • Refresh all imports in sheet: For comprehensive spreadsheet updates
7. Implement the Webhook: Paste the copied URL into your Salesforce outbound message or flow configuration

When specified events occur in Salesforce, your spreadsheet automatically refreshes with the latest data—no manual intervention required.

Custom Connector Webhooks vs. Coefficient Comparison

Aspect	Custom Development	Coefficient
Setup Time	2-4 weeks	5 minutes
Development Cost	$5,000-$15,000	$29-$299/month
Maintenance	Ongoing dev resources	Fully managed
Security	Must implement yourself	Enterprise-grade built-in
Monitoring	Build your own	24/7 automated monitoring
Scaling	Handle infrastructure yourself	Auto-scaling included
Updates	Maintain API changes	Automatic updates

Take Control of Your Data Flow

Setting up Salesforce webhooks doesn’t have to drain your development budget or delay critical business processes. While traditional approaches require extensive technical expertise and ongoing maintenance, modern solutions like Coefficient eliminate these barriers entirely.

Ready to transform hours of manual data updates into automated, real-time synchronization? Get started with Coefficient today and experience the power of effortless Salesforce-to-spreadsheet integration.

Your team will spend less time wrestling with data transfers and more time making the strategic decisions that drive business growth.

FAQs

Does Salesforce have a webhook?

Salesforce doesn’t have native webhook support out-of-the-box. Instead, it offers outbound messages (SOAP-based) and requires custom Apex development for modern REST webhooks. However, you can achieve webhook-like functionality through outbound messages or third-party AppExchange solutions like Coefficient for seamless integrations.

What are webhooks used for?

Webhooks enable real-time data synchronization between systems by automatically sending data when specific events occur. In Salesforce contexts, they’re commonly used for updating external databases when records change, triggering email campaigns, syncing CRM data with marketing tools, and maintaining real-time dashboards and reports.

What is the difference between API and webhooks?

APIs require your system to actively request data (pull-based), while webhooks automatically send data when events occur (push-based). An API requires requests from the client (pulling data), while a webhook sends data automatically when an event occurs (pushing data). Webhooks are more efficient for real-time updates since they eliminate the need for constant polling.

Does Salesforce have an API?

Yes, Salesforce provides extensive API access including REST API, SOAP API, Bulk API, and Streaming API. These APIs allow you to create, read, update, and delete Salesforce data programmatically. API access varies by Salesforce edition, with developer and trial accounts receiving 15,000 daily API calls and enterprise accounts receiving significantly more based on user licenses.

Quick Answer

Salesforce API integration requires creating Connected Apps, configuring OAuth 2.0 authentication, and managing complex API limits that vary by edition and license count. The process involves handling custom field mapping, implementing retry logic for rate limits, and building robust error handling for production reliability. 

Custom integrations typically take 2-4 weeks and cost $5,000-$15,000, with ongoing maintenance for API changes and scaling challenges. 

Coefficient for Google Sheets and Coefficient for Excel eliminate this complexity, connecting your Salesforce data to spreadsheets in minutes with automatic field mapping, built-in error handling, and enterprise-grade security—no coding required.

Prerequisites and Requirements

Before you begin:

• Active Salesforce Account: Enterprise, Unlimited, Developer, or Performance edition with API access enabled
• Administrative Access: Required for creating and managing Connected Apps and OAuth settings
• Connected App Credentials: Consumer Key and Consumer Secret from configured Connected App
• OAuth 2.0 Configuration: Standard authentication method for secure API access
• User Authentication: Username, password, and security token for API authentication
• Field Mapping Knowledge: Understanding of custom fields and objects your integration will use

API Limits:

• Daily API Calls: Based on edition and license count (e.g., Enterprise with 15 users = 115,000 requests/day)
• Concurrent Requests: Maximum 25 long-running requests (20+ seconds) for production orgs
• API Timeouts: 10-minute timeout limit for REST/SOAP API calls
• Bulk Operations: Separate limits for Bulk API asynchronous requests and query timeouts
• Error Responses: REQUEST_LIMIT_EXCEEDED or “API limit exceeded” when limits are hit

Step-by-Step Salesforce API Integration Setup

Step 1: Create Your Connected App

Navigate to Salesforce Setup. Every integration starts here.

Go to Platform Tools > Apps > App Manager and click New Connected App.

Configure these essential settings:

• Connected App Name: Choose something descriptive like “Data Integration App”
• API Name: Auto-generated from your app name
• Contact Email: Administrative contact for the integration

Enable OAuth Settings is crucial. Check this box to unlock API access.

Step 2: Configure OAuth and Security

Set your Callback URL carefully. Use https://login.salesforce.com/services/oauth2/callback for basic setups.

OAuth Scopes determine what your integration can access. Start with:

• Full access (full) for comprehensive data access
• Perform requests on your behalf at any time (refresh_token, offline_access) for persistent connections

Security settings matter. Navigate to Manage > OAuth Policies and select Relax IP restrictions for development. Tighten this for production.

Step 3: Obtain Your API Credentials

After saving your Connected App, note these critical values:

• Consumer Key (Client ID)
• Consumer Secret (Client Secret)

Store these securely. They’re your keys to Salesforce data.

Security token required. Reset your security token from My Settings > Personal > Reset My Security Token. You’ll need this for password-based authentication.

Step 4: Authenticate and Get Access Token

OAuth 2.0 authentication involves exchanging credentials for an access token. Here’s the process:

For password flow (development only):

Copy Code

POST https://login.salesforce.com/services/oauth2/token

Content-Type: application/x-www-form-urlencoded

grant_type=password&

client_id=YOUR_CONSUMER_KEY&

client_secret=YOUR_CONSUMER_SECRET&

username=YOUR_USERNAME&

password=YOUR_PASSWORD_AND_SECURITY_TOKEN

Production environments should use Authorization Code flow for better security.

Step 5: Make Your First API Request

With your access token, you can query Salesforce data:

Copy Code

GET https://YOUR_INSTANCE.salesforce.com/services/data/v58.0/query/?q=SELECT+Id,Name+FROM+Account+LIMIT+5

Authorization: Bearer YOUR_ACCESS_TOKEN

Test carefully. Start with simple queries to verify connectivity before building complex integrations.

Step 6: Handle Responses and Pagination

Salesforce returns data in JSON format. Large result sets use pagination:

json

Copy Code

{

“totalSize”: 2500,

“done”: false,

“nextRecordsUrl”: “/services/data/v58.0/query/01gD0000002HU6KIAW-2000”,

“records”: […]

}

Use nextRecordsUrl to fetch additional records. Don’t ignore pagination—you’ll miss data.

Step 7: Implement Error Handling and Retry Logic

Salesforce API calls can fail for various reasons. Build robust error handling:

python

Copy Code

import time

import requests

from random import uniform

def salesforce_request_with_retry(url, headers, max_retries=3):

for attempt in range(max_retries):

try:

response = requests.get(url, headers=headers)

if response.status_code == 200:

return response.json()

elif response.status_code == 429:

# Rate limited

wait_time = (2 ** attempt) + uniform(0, 1)

time.sleep(wait_time)

continue

else:

response.raise_for_status()

except requests.exceptions.RequestException as e:

if attempt == max_retries – 1:

raise e

time.sleep(2 ** attempt)

return None

Monitor API usage religiously. Set up alerts before hitting limits to prevent integration failures.

Common Integration Issues

Struggles With Custom Fields and Data Mapping

Salesforce’s flexibility becomes a nightmare during integration. Unlimited custom fields sound great until you need to map them across systems.

Standard integration tools focus on Salesforce’s default fields, leaving custom objects and fields as manual work. Every customer requires unique field mapping analysis—sometimes taking days to align schemas properly.

The “death by a thousand paper cuts” problem is real. Reddit users consistently report that custom field mapping breaks “simple” integrations. One organization onboarding can require extensive schema redesign.

Community consensus: Generic integration solutions fail when faced with real-world custom configurations. Each unique setup demands extra development effort, making supposedly plug-and-play integrations anything but simple.

API Limits Sabotage Scaling and Stability

Salesforce’s API limits protect platform stability but routinely trip up growing organizations. Daily quotas force integrations to pause or drop data during peak activity periods.

Concurrency limits shut down processes unexpectedly during large migrations. One Reddit thread described hitting both RAM and API exhaustion during an 8-year data sync, forcing extreme batching to avoid failures.

Mid-sized organizations hit walls regularly. Integration reliability becomes a constant concern as teams approach daily limits with normal business operations.

Stack Overflow discussions consistently mention “hitting the wall” on integration scaling, where solutions that worked fine in testing break under production load.

Poor Error Handling and Inconsistent Integrations

Robust error handling is the exception, not the rule, in Salesforce integrations. Silent failures, cryptic error messages, and ignored timeouts leave operations teams guessing about data integrity.

The “invisible killer” problem: Major breakdowns aren’t always obvious. Missing data or incorrect syncs mean lost revenue and broken workflows, discovered only during audits or customer complaints.

Authentication failures and sync interruptions often lack proper logging, making troubleshooting a detective exercise rather than systematic debugging.

Community feedback emphasizes that integrations without clear logs and retry logic set users up for “subtle but severe failures” that damage business operations over time.

Vendor Over-Promise and Resource Shortfalls

Third-party vendors frequently claim “turnkey Salesforce integration” but deliver bare-minimum functionality. Essential features like deduplication, field validation, and error handling become “future enhancements.”

The gap between marketing and reality forces teams into extensive custom development or manual workarounds. “Seemed great on paper” integrations leave users supporting brittle processes months after implementation.

Deep community frustration targets both vendors and integration standards. Users resort to custom development or abandon third-party solutions entirely when promised automation delivers only partial functionality.

Reddit threads detail experiences where “enterprise-ready” integrations provided minimal automation, forcing extensive manual intervention to maintain data quality.

Building a Salesforce API Integration for Google Sheets or Excel?

Stop fighting with API complexity. Coefficient for Google Sheets and Coefficient for Excel connect your Salesforce data to spreadsheets instantly—no coding, no Connected Apps, no authentication headaches.

Setup takes minutes, not weeks:

1. Install Coefficient from Google Workspace Marketplace or Microsoft AppSource
2. Connect Salesforce with secure one-click OAuth (enterprise security built-in)
3. Import any data using visual selectors or direct SOQL queries
4. Schedule automatic updates to keep spreadsheets current with Salesforce changes

Custom fields? No problem. Coefficient automatically detects and maps all your custom objects and fields. No schema analysis required.

Real-time sync keeps everything current. Changes in Salesforce flow instantly to your spreadsheets. No more stale data or manual refresh cycles.

Build dashboards using familiar spreadsheet tools. Create pivot tables from live Salesforce data. Generate reports that update automatically. Your team gets the insights they need without learning new platforms.

Custom Salesforce API Integration to Spreadsheets vs. Coefficient.io Comparison

Aspect	Custom Development	Coefficient.io
Setup Time	2-4 weeks	5 minutes
Development Cost	$5,000-$15,000	$29-$299/month
Maintenance	Ongoing dev resources	Fully managed
Security	Must implement yourself	Enterprise-grade built-in
Monitoring	Build your own	24/7 automated monitoring
Scaling	Handle infrastructure yourself	Auto-scaling included
Updates	Maintain API changes	Automatic updates

Connect Your Data Today

Salesforce API integration works—if you have months and thousands of dollars to spend. But your business needs data now, not after a development project.

Your team deserves better than choosing between complexity and insights. Coefficient delivers both without compromise.

Ready to connect Salesforce to your spreadsheets? Start your free trial and watch your data come alive in minutes.

FAQs

How to integrate a 3rd party API in Salesforce?

Integrate third-party APIs in Salesforce by creating External Services, Custom Apex classes with HTTP callouts, or Platform Events for event-driven integration. You’ll need to configure Remote Site Settings for external endpoints and handle authentication (API keys, OAuth) within your implementation. For spreadsheet integrations, Coefficient simplifies this process with pre-built connectors that require no coding.

Which API to use in Salesforce?

Choose based on your use case: REST API for lightweight web/mobile integrations and simple CRUD operations, SOAP API for enterprise systems requiring structured XML, Bulk API for processing large data volumes efficiently, and Streaming API for real-time updates. REST API is most common for modern integrations due to its simplicity and JSON support.

What are the 4 types of REST API?

The four main REST API operation types are: GET (retrieve data from server), POST (create new resources), PUT (update existing resources completely), and DELETE (remove resources). These HTTP methods correspond to Create, Read, Update, Delete (CRUD) operations and form the foundation of RESTful web services architecture.

Does Salesforce support REST API?

Yes, Salesforce fully supports REST API as one of its primary integration methods. Salesforce REST API uses standard HTTP methods, returns JSON responses, and provides access to all Salesforce objects and functionality. It’s the recommended approach for modern integrations, mobile applications, and web services due to its lightweight nature and wide platform support.

Quick answer

Salesforce enforces a 100,000 daily API request limit for Enterprise Edition orgs, plus 1,000 additional requests per user license. The system also caps concurrent long-running requests at 25 (5 for developer orgs) and limits each API call to 10 minutes maximum.

Beyond basic limits, Salesforce restricts Bulk API to 15,000 batches per day with 10,000 records per batch. Report APIs get 1,200 async requests per hour, while Apex callouts max out at 100 per transaction.

Hit these limits? You’ll face blocked requests until usage drops. Coefficient’s managed Salesforce connection bypasses these headaches entirely, giving you real-time CRM data in spreadsheets without quota management or complex retry logic.

Salesforce rate limits

API rate limits

Salesforce uses a sophisticated multi-tier limiting system that catches most integrations off guard:

• Daily request limit: 100,000 base requests per 24 hours (Enterprise Edition) plus 1,000 per user license
• Concurrent requests: Maximum 25 long-running API requests (20+ seconds) in production; 5 in developer orgs
• API timeout: Hard 10-minute maximum per REST or SOAP call
• Bulk API batches: 15,000 batch submissions per day (shared between Bulk API 1.0 and 2.0)
• Streaming API: 50 PushTopics per org, 1,000 subscribers per topic, 200,000 events daily
• Asynchronous requests: 1,200 async requests per hour for specific APIs

API usage limits

Salesforce enforces additional restrictions that compound rate limiting challenges:

• Rolling 24-hour window: Daily quotas measured continuously, not calendar days
• Batch constraints: Maximum 10,000 records per batch, 10MB payload limit
• Report API specifics: 500 synchronous report runs per hour, 20 concurrent sync requests
• Apex callout limits: 100 outbound HTTP requests per transaction maximum
• Debug header restriction: Separate 1,000-call daily limit for debugging-enabled requests
• Per-user OAuth limits: Connect REST API applies hourly limits per user per application

Methods to prevent Salesforce rate limits

• Monitor usage patterns religiously. Track API consumption across all integrations using Salesforce’s usage monitoring tools. Set alerts at 80% capacity to avoid hitting hard limits during peak business hours or month-end reporting cycles.
• Implement smart batching and caching strategies. Use Bulk API for large data operations (respecting the 15,000 daily batch limit) and cache frequently accessed data locally. Optimize SOQL queries to reduce unnecessary API calls and leverage composite requests when possible.
• Use Coefficient for seamless Salesforce integration. Rather than building complex rate limit handling, Coefficient’s Salesforce connector manages all API complexity automatically. You get real-time CRM data without worrying about quotas, timeouts, or error handling.

Step-by-step walkthrough to avoid rate limits using Coefficient

Coefficient eliminates Salesforce API rate limit complexity by handling connections intelligently behind the scenes. You get live CRM data in familiar spreadsheets without managing quotas, implementing retry logic, or monitoring usage patterns.

Setup takes minutes, not weeks:

1. Install Coefficient from Google Workspace Marketplace or Microsoft AppSource
2. Connect Salesforce with secure one-click OAuth (enterprise security built-in)
3. Import any data using visual selectors, SOQL queries, or formula’s 

4. Schedule automatic updates to keep spreadsheets current with Salesforce changes

No quota monitoring needed. No complex error handling. No API expertise required. Coefficient optimizes requests, manages retries, and handles data synchronization automatically while you focus on sales analysis and CRM reporting.

Common use cases that trigger API rate limits

• Sales reporting dashboards with real-time updates. Revenue teams pulling opportunity data, lead scores, and pipeline metrics throughout the day often exhaust the 100,000 daily request limit, especially in high-user orgs.
• Data migration and bulk synchronization projects. Moving historical records or syncing with external systems frequently hits both daily API limits and the 15,000 Bulk API batch restriction simultaneously.
• Multi-app integration environments. When marketing automation, support tools, and business intelligence platforms all access Salesforce concurrently, combined usage often exceeds both daily quotas and concurrent request limits.

Stop fighting API limits

Salesforce rate limiting doesn’t have to derail your CRM workflows. While building custom integrations requires careful quota management and sophisticated error handling, Coefficient provides instant access to live Salesforce data without technical complexity.

Ready to eliminate API rate limit headaches? Get started with Coefficient and connect Salesforce in minutes, not hours.

FAQs

What is the 24-hour API limit in Salesforce?

Salesforce provides 100,000 API requests per 24 hours for Enterprise Edition orgs, plus 1,000 additional requests per user license. For example, an org with 50 users gets 150,000 daily requests. This limit operates on a rolling 24-hour window, not calendar days, and additional requests can be purchased if needed.

What is the rate limit of an API?

API rate limits vary significantly by provider and service tier. Salesforce uses 100,000+ daily requests with concurrent limits, while QuickBooks enforces 500 per minute. HubSpot typically allows 100 requests per 10 seconds, and Google APIs range from 1,000 to 1 million requests per day depending on the service.

What is the bulk API rate limit in Salesforce?

Salesforce Bulk API allows up to 15,000 batch submissions per 24 hours, shared between Bulk API 1.0 and 2.0. Each batch can contain maximum 10,000 records with a 10MB payload limit. These limits are separate from standard API quotas but still count toward overall org usage monitoring.

What is API rate limit 429?

HTTP 429 “Too Many Requests” indicates you’ve exceeded an API’s rate limit. This triggers when you surpass allowed requests per time period (like Salesforce’s daily quota) or concurrent request limits. The response typically includes retry-after headers suggesting when to attempt the request again.