Salesforce API (Basic)

1. Introduction to APIs & Salesforce API

What is an API?

• • API (Application Programming Interface) is a way for different software systems to communicate with each other.
  • It defines a set of rules and protocols for requesting and exchanging data.
  • APIs are used to exchange data, features, and functionality.

How APIs work

• • APIs act as an intermediary between applications.
  • When one application wants to access a resource from another application, it sends a request.
  • The application that receives the request is called the server, and the application that sends the request is called the client.
  • The server responds to the request, and the response is sent back to the client.

Why Do We Need Salesforce API?

Salesforce API allows developers to:
✅ Access Salesforce data programmatically
✅ Automate business processes
✅ Integrate Salesforce with other applications like ERP, e-commerce, and mobile apps
✅ Improve efficiency by reducing manual data entry

Real-Life Example of API Usage

• • APIs make it easier to develop applications by allowing developers to integrate data and services from other applications.
  • APIs make it easier to share data and functions between applications, departments, business partners, and third parties.
  • APIs help to keep internal system details hidden, which helps with system security.
  • Imagine you use Shopify to sell products and Salesforce to manage customer relationships.
  • You want to automatically update customer records in Salesforce when an order is placed on Shopify.
  • Instead of manually entering data, Shopify can send data to Salesforce using its API.

---

2. Types of Salesforce APIs

Salesforce offers multiple APIs for different purposes.

1. REST API (Best for web and mobile applications)

🔹 Lightweight, easy to use, and widely adopted
🔹 Uses standard HTTP methods:

• • GET → Retrieve data
  • POST → Create records
  • PUT/PATCH → Update records
  • DELETE → Remove records
    🔹 Returns responses in JSON (easier to parse) or XML

Example REST API Request (Using Postman or Python)

import requests

url = "https://your-instance.salesforce.com/services/data/v61.0/query/"
headers = {"Authorization": "Bearer YOUR_ACCESS_TOKEN"}
params = {"q": "SELECT Id, Name FROM Account"}

response = requests.get(url, headers=headers, params=params)
print(response.json())

✔️ Use Case: Fetching Salesforce records from a mobile app

---

2. SOAP API (Best for enterprise-level integrations)

🔹 More structured and secure, but requires XML
🔹 Used in legacy systems and enterprise applications
🔹 Uses WSDL (Web Service Definition Language) for defining operations

Example SOAP Request Structure

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
                  xmlns:urn="urn:partner.soap.sforce.com">
   <soapenv:Header>
      <urn:SessionHeader>
         <urn:sessionId>YOUR_SESSION_ID</urn:sessionId>
      </urn:SessionHeader>
   </soapenv:Header>
   <soapenv:Body>
      <urn:query>
         <urn:queryString>SELECT Id, Name FROM Account</urn:queryString>
      </urn:query>
   </soapenv:Body>
</soapenv:Envelope>

✔️ Use Case: Integrating Salesforce with older enterprise systems

---

3. Bulk API (Best for large data operations)

🔹 Used to process millions of records asynchronously
🔹 Operates in batches instead of one-by-one requests
🔹 Supports CSV-based uploads

Example Use Case

• • Migrating 100,000 records from an old CRM to Salesforce
  • Exporting millions of Salesforce records for analytics

✔️ Best Practice: Use Bulk API 2.0 for better performance

---

4. Streaming API (Best for real-time updates)

🔹 Pushes updates automatically when data changes
🔹 Uses Event-Driven Architecture (Pub/Sub model)
🔹 Works with Platform Events & Change Data Capture (CDC)

Example Use Case

• • A sales manager wants real-time notifications when a big deal is closed.
  • Instead of polling for updates, Streaming API automatically sends notifications to subscribed systems.

---

5. GraphQL API (Best for optimized data retrieval)

🔹 Unlike REST, it fetches only the needed fields (no over-fetching)
🔹 Single request can retrieve related records
🔹 Reduces API call count and improves efficiency

Example GraphQL Query

query {
  Account(id: "001xx000003DHPz") {
    Name
    Contacts {
      FirstName
      LastName
      Email
    }
  }
}

✔️ Use Case: Efficiently retrieving customer details for a dashboard

---

3. Authentication & Security in Salesforce APIs

Salesforce requires authentication before API access.

1. OAuth 2.0 (Recommended method)

• • Uses Access Tokens for secure authentication
  • Supports multiple grant types (Authorization Code, Client Credentials, JWT, etc.)

Steps for OAuth 2.0 Authentication

1. 1. App requests an access token from Salesforce.
   2. Salesforce verifies credentials and grants a token.
   3. App uses the token to make API calls.

✔️ Best Practice: Use OAuth Refresh Tokens to avoid frequent logins.

---

2. Session ID & Basic Authentication (Legacy Methods)

• • Session ID: Used when making API calls from Salesforce UI.
  • Basic Authentication: Uses username/password (less secure).

✔️ Best Practice: Avoid storing passwords in API requests.

---

4. Demonstration

Live REST API Demo Using Postman

• • Step 1: Obtain an OAuth 2.0 Access Token
  • Step 2: Use GET request to fetch Account records
  • Step 3: Show JSON response

Real-World Integration Example

• • Sync Abacux ERP with Salesforce to update inventory in real time.

---

5. Best Practices & Q&A (5 minutes)

Salesforce API Best Practices

✔️ Use Bulk API for large data loads
✔️ Enable IP Whitelisting & Named Credentials
✔️ Use Event-driven Streaming API instead of polling
✔️ Optimize queries to reduce API call limits
✔️ Always handle API rate limits & errors

---

Conclusion

🔹 Salesforce APIs enable seamless integration with other platforms.
🔹 Choose the right API based on your needs (REST, SOAP, Bulk, Streaming, GraphQL).
🔹 Implement OAuth 2.0 authentication for security.
🔹 Follow best practices to improve efficiency.