Unlocking Efficiency with Salesforce Composite API

If you're working with Salesforce, chances are you're dealing with a lot of records and performing multiple operations on them. Whether it’s creating, updating, or deleting records, these tasks can become cumbersome when executed individually, especially when you need to handle multiple operations at once. This is where the Salesforce Composite API comes into play. In this blog post, we’ll explore how the Composite API can streamline your operations, save API calls, and boost the efficiency of your Salesforce integrations.

Simplifying Salesforce Integrations with the Composite Connector

Salesforce is a robust platform, but working with its API can be challenging, especially when handling multiple related operations. The Salesforce Composite Connector provides a powerful solution by enabling developers to combine multiple API calls into a single request. This not only improves performance but also ensures data consistency across operations. Let us explore the features, benefits, and practical use cases of the Salesforce Composite Connector.

What is the Salesforce Composite Connector?

The Salesforce Composite Connector leverages the Salesforce Composite API, which allows multiple operations to be performed in a single API call. By grouping related requests into one transaction, it optimizes efficiency, reduces API call limits, and ensures that either all operations succeed or none are committed.

Salesforce is a massive player in the ever-changing customer relationship management (CRM) space, offering organizations powerful tools to optimize their processes. The Salesforce Composite API is one of the essential elements that enables this effectiveness.

In web services and software development, a Salesforce composite API is an API (Application Programming Interface) that combines and unifies several distinct APIs and services into a cohesive interface. By offering a higher-level interface that integrates the functionality of numerous services, a composite API seeks to simplify and expedite interactions with multiple underlying APIs.

Comprehending the Salesforce Composite API: One of the Salesforce platform’s most valuable features is the Composite API, which enables administrators and developers to do several tasks with only one call. This method enhances efficiency and lowers the possibility of mistakes by drastically lowering the quantity of API requests. 

Table of Contents

• Essential Features of Salesforce Composite API 
• What is meant by a composite resource?
• How does an aggregated resource function?
• What applications does the composite resource have?
• Benefits of the Salesforce Composite API
• The Best Ways to Use the Salesforce Composite API
• Summary

Essential Features of Salesforce Composite API 

Aggregation: Salesforce Composite APIs combine services from many endpoints or sources. They can compile data from several APIs into a single resource or answer. Thus, you can obtain the information from the Account and the associated Contacts with only one API call.

Orchestration: These APIs frequently use intricate workflows and logic to coordinate requests and responses from the underlying APIs. They may use data transformation, conditional branching, and other orchestration techniques to accomplish a specific goal or job. It is possible to use an external field to find an Account and then use that Account to create a contact.

Simplification: Simplifying the interaction with a collection of APIs is the primary goal of Salesforce composite APIs. Developers can submit a single request to the composite API, which handles the underlying complexity, saving them from having to handle complicated coordination and several calls. Composite API is the best option if you want to create an account, a person’s name, language, a contact point phone number, and a contact point consent all at once.

Security and Authentication: Salesforce Composite APIs frequently take care of the underlying APIs’ authorization and authentication, making sure that users and apps are authorized to access the combined resources. Individual authentication for every internal API is optional and the composite API itself handles that.

Salesforce Composite APIs are handy when apps need to communicate with several different services or data sources to complete a given activity. Microservices architectures frequently employ them, wherein distinct microservices offer particular functionality, and a composite API merges these microservices to provide clients with a higher-level service.

Overall, by reducing the complexity of interacting with numerous APIs and services, composite APIs assist developers in creating applications that are more effective, scalable, and user-friendly.

Composite: Returns a list of additional composite resources with a GET request or executes many REST API calls in a single POST request. Use Composite to Send Many Requests.

Carries out several REST API calls in a single call: One request’s output might be input for another request later. One response body contains both the HTTP statuses of the requests and the response bodies. Regarding your API restrictions, the sequence of requests as a whole counts as one call.

Obtain a Composite Resources List: Obtains a list of other composite resource URIs.

What is meant by a composite resource?

The composite resource is a unique kind of REST API resource that combines several requests into one. It can carry out sophisticated logic that requires several steps, obtain data from numerous objects, and conduct CRUD operations on multiple records. Composite and Composite are the two sub-resources that make up the composite resource.

In a single call, the composite sub-resource completes several REST API requests. By employing reference IDs, the output of one request can be utilized as the input for another. One response body contains both the HTTP statuses of the requests and the response bodies. A call to the composite sub-resource can accommodate up to 25 sub-requests.

In a single call, the composite sub-resource performs several CRUD actions on several connected sObjects. The sub-requests are arranged into graphs, each showing a group of related sObjects. The coordination of the relationships and the efficient atomic processing of the records are handled by the composite sub-resource. A call to the composite sub-resource can accommodate 500 sub-requests.

How does an aggregated resource function?

To access the composite resource, you must submit a POST request in the API version. An array of sub-requests, each including the method, URL, referenced, and body (if applicable) of a separate REST API request, should be contained in the request body. Here’s an example of a straightforward composite request that establishes a contact and an account:

The response body will include various results, all of which correlate to the sub-request in the same order. The reference Id, HTTP status code, and body (if relevant) fields will be present in each result. For instance, the following is the answer to the earlier request:

What applications does the composite resource have?

In many situations, the composite resource might be helpful when making several REST API calls in one call. Here are a few instances:

Bulk data loading: To reduce the number of API calls and enhance efficiency, insert, edit, or remove several entries in a single call using the composite resource.

Data synchronization: Salesforce and an external system, like a web service or mobile app, can synchronise their data using the composite resource. Reference IDs can be used to connect interdependent entries, like parent-child connections.

Complex logic: The composite resource can carry out multi-step, complex logic operations like opening a case, adding it to a queue, and sending an email alert. Reference IDs can transfer data between sub-requests, like email addresses or case IDs.

Benefits of the Salesforce Composite API

Increased Performance: By reducing the number of network requests, the Composite API lowers latency and boosts overall performance. Multiple actions can be combined into a single request to expedite data processing and conserve precious server resources.

Atomicity and Consistency: The Composite API guarantees atomicity, which is the condition that every operation in a request is completed successfully or not at all. This protects your Salesforce database from inconsistent or partial updates by ensuring data consistency and integrity.

Increased Developer Productivity: Developers may do more with fewer API calls when they use the Composite API. By taking a more efficient approach, you can focus on creating reliable apps by streamlining the coding process, lowering complexity, and increasing development productivity.

Decreased API Consumption: The Composite API lets you do several tasks with a single request, so you can cut down on the amount of API calls you make. This helps save costs, especially for businesses that need to use a lot of APIs.

Transaction Control: Using the Salesforce Composite API’s transactional control feature, you can perform every action in a request as a single transaction. This implies that you can preserve data consistency and integrity by rolling back changes if a transactional mistake arises.

The Best Ways to Use the Salesforce Composite API

Sequential Tasks: When utilising the Composite API, it is essential to bundle related activities (e.g., generating or changing many records of the same object). This method increases efficiency and reduces the amount of API queries.

Error Handling: To successfully collect and handle errors, implement strong 

Error handling systems: You can detect and address issues at the level of individual operations with the help of the sub-responses included in the Composite API response for each action.

Governor Limits Examination: Although API consumption is optimized using the Composite API, Salesforce’s governor limits must be considered. To prevent reaching those restrictions, be aware of the limitations of various operations and adjust your requests appropriately.

Performance Optimization: Reduce superfluous data transfer by carefully choosing which information to retrieve in your requests. To further improve performance, consider asynchronous processing for tasks that don’t need to be completed immediately.

Throttling and Backoff Strategy: Be aware of Salesforce’s API rate limitations to avoid throttling. When API restrictions are reached, use a backoff approach to handle the situation so your application may automatically retry after a predetermined time.

Key Features

1. Batch Processing: Execute multiple independent subrequests in a single call.
2. Transaction Management: Ensure atomicity; all operations succeed or fail as a unit.
3. Cross-object Operations: Handle interactions between multiple Salesforce objects seamlessly.
4. Reduced API Usage: Consolidate multiple calls into one, conserving API limits.

Why Use the Composite Connector?

1. Efficiency

Instead of making separate API calls for each operation, the Composite Connector bundles them together. This reduces latency and enhances performance, especially for high-traffic systems.

2. API Limit Conservation

Salesforce imposes strict limits on the number of API calls an organization can make. By combining multiple operations into a single call, the Composite Connector helps you stay within these limits.

3. Data Integrity

All operations in a composite request are executed within a single transaction. If one operation fails, none of the changes are committed, ensuring data consistency.

4. Simplified Development

The Composite Connector allows developers to create and manage complex workflows with less code and fewer API interactions.

However, while using the Composite API, certain errors or issues can occur. Here’s a list of potential errors, their causes, and resolutions:

1. HTTP 400: Bad Request

Cause:

• Invalid request body, such as a malformed JSON payload.
• Missing or incorrect field mappings in the request.
• A required field is not provided.

Resolution:

• Validate your JSON payload using a linter or JSON validator.
• Ensure all required fields for each operation are included.
• Verify object and field names for correctness.

2. HTTP 401: Unauthorized

Cause:

• Invalid or expired access token.
• Insufficient API permissions for the user.

Resolution:

• Ensure your access token is valid and refreshed if necessary.
• Verify the user has the required permissions to perform the API call (e.g., "API Enabled," "Modify All Data").

3. HTTP 403: Forbidden

Cause:

• The user does not have the necessary permissions to access certain objects or fields.
• Field-level security (FLS) or object-level permissions are restricting access.

Resolution:

• Check field-level security and object permissions for the user profile.
• Ensure the user has access to the objects and fields used in the Composite API call.

4. HTTP 404: Not Found

Cause:

• Incorrect resource URI or object API name.
• A record referenced in the request doesn’t exist.

Resolution:

• Double-check resource URIs, object API names, and record IDs.
• Ensure the record exists in Salesforce.

5. DML Errors (e.g., DUPLICATE_VALUE, FIELD_CUSTOM_VALIDATION_EXCEPTION)

Cause:

• Record duplication due to uniqueness constraints (e.g., a duplicate email).
• Custom validation rules blocking the operation.
• Missing required fields in the record.

Resolution:

• Handle uniqueness constraints properly (e.g., add Upsert instead of Insert).
• Review and adjust custom validation rules as needed.
• Ensure all required fields for the DML operation are provided.

6. Sub-request Errors

Cause:

• One or more sub-requests in the composite batch fails, returning an error in the response.
• Dependencies between sub-requests are not properly managed (e.g., missing reference IDs).

Resolution:

• Check the errors field in the Composite API response for details about failed sub-requests.
• If there are dependencies between sub-requests, ensure proper usage of reference IDs (e.g., @{refId.fieldName}).

7. Response Size Limit Exceeded

Cause:

• The response from the Composite API exceeds the maximum size limit of 6 MB.

Resolution:

• Break down the request into smaller batches.
• Optimize query filters to limit the size of returned data.

8. Request Size Limit Exceeded

Cause:

• The total request size exceeds the maximum limit of 2 MB.

Resolution:

• Minimize the payload size by:
  • Reducing the number of subrequests in a batch.
  • Optimizing fields included in the request.

9. Too Many Subrequests

Cause:

• A Composite API batch request contains more than 25 sub-requests.

Resolution:

• Limit each batch to a maximum of 25 sub-requests.
• Divide large batches into smaller groups.

10. Cyclic Reference Errors

Cause:

• Circular dependencies between subrequests (e.g., sub-request A depends on sub-request B, which depends on A).

Resolution:

• Reorganize the sub-requests to remove cyclic dependencies.
• Use proper sequencing for dependent sub-requests.

11. Missing Reference ID

Cause:

• The reference ID specified in the request is not defined or is incorrect.

Resolution:

• Ensure that all referenceId values are unique within the request and properly referenced in dependent sub-requests.

12. Rate Limits Exceeded

Cause:

• You’ve exceeded your Salesforce API request limits (e.g., daily request limits or concurrency limits).

Resolution:

• Monitor your API usage and stay within limits.
• Consider optimizing your calls by combining multiple requests or reducing frequency.

Debugging Tips:

• Use tools like Postman or Workbench to test and debug requests.
• Enable debug logs in Salesforce for detailed error tracking.
• Use the allOrNone parameter to control how partial successes/failures are handled.

Types of Composite API Methods

1. Batch

Executes up to 25 independent sub-requests in a single API call. Each sub-request operates independently, and partial successes are possible.

2. Tree

Used to create records with parent-child relationships. For example, creating an Account and its associated Contacts in one transaction.

3. Graph

Executes a series of interdependent operations where the output of one request can be used as input for another.

Example Payload for a Composite API Call

Here’s an example of a JSON payload to create a parent Account and child Contact:

{
"compositeRequest": [
{
"method": "POST",
"url": "/services/data/v57.0/sobjects/Account",
"referenceId": "newAccount",
"body": {
"Name": "Sample Account"
}
},
{
"method": "POST",
"url": "/services/data/v57.0/sobjects/Contact",
"referenceId": "newContact",
"body": {
"LastName": "Doe",
"AccountId": "@{newAccount.id}"
}
}
]
}

Summary

The composite resource can carry out sophisticated logic that requires several steps, get data from numerous objects, and conduct CRUD actions on multiple records.

You may optimize your REST API requests to Salesforce with the help of the composite resource, which is a vital tool. It saves you time and bandwidth by enabling you to process several requests in a single call. In addition, it maintains the atomicity of operations and coordinates relevant records.