Kaizen #167 - Configuration and Initialization of Zoho CRM Python SDK (V7) for different client types

Kaizen #167 - Configuration and Initialization of Zoho CRM Python SDK (V7) for different client types


Hello everyone!

Welcome back to another week of Kaizen!

Zoho CRM Python SDK allows developers to integrate Python applications with Zoho CRM. In today's Kaizen post, we will explore how to initialize and configure the SDK for both self-clients and server-based clients.

A self-client is an application type used when you want to access your own CRM account data or set up app-to-app communication in the backend without user interaction. Self clients operate solely in the backend, making them suitable for automating tasks or data synchronization. In this scenario, the developer is both the resource owner and the client. Self-clients are ideal for scenarios such as syncing data between Zoho CRM and a legacy product management system. 

A server-based client is designed for applications that will be used by multiple Zoho CRM organizations, typically solving specific use cases for various users. These applications require both a dedicated backend server and a web UI. Server-based clients handle the authorization process and application logic, redirecting users to Zoho for authorization via a web browser. Users grant permission for the app to access their CRM data, and the application consumes this data on behalf of authorized users. This type of client is suitable for developing apps that provide specialized functionality to multiple Zoho CRM accounts, such as lead management systems or custom reporting tools.

For more information on the different client types, refer to our Kaizen post on Client Types in Zoho Developer Console.

Prerequisites

Before we go into detail about the SDK initialization process, ensure that you have the following prerequisites:
  • A Zoho CRM account and access to the Zoho API Console.
  • An IDE (e.g., PyCharm) installed in your system. In this post, we will be using PyCharm for the illustration purposes.
  • Python 3.x installed on your system or the client app.

Zoho CRM Python SDK Configuration

Configuration
Description
environment
mandatory
Specify the Zoho CRM domain and environment to make API calls to. Options include USDataCenter, EUDataCenter, INDataCenter, CNDataCenter, AUDataCenter, with environments like PRODUCTION(), DEVELOPER(), SANDBOX().

token
mandatory

Contains user authentication details. Used to create an OAuthToken instance with client credentials and tokens.
Supports different authentication flows:
Grant Token Flow: Uses a grant token to generate and persist access and refresh tokens.
Refresh Token Flow: Uses a refresh token to generate and persist access tokens.
Access Token Flow: Directly uses an access token for making API calls.
ID Flow : Uses the ID from the persisted token file/DB to make API calls. This method is applicable only after the SDK has been initialized at least once using a grant token, access token, or refresh token. It is not valid for the initial setup but can simplify subsequent operations by bypassing the need for other token details.
store
optional
Manages token persistence, which is the storage and retrieval of authentication tokens. Options include:
DBStore: Stores tokens in a database (e.g., MySQL).
FileStore: Stores tokens in a file.
Custom Store: Allows the implementation of custom storage logic.
If not specified, defaults to file storage in the current working directory.
logger
optional
Configures SDK logging. Allows setting log level (e.g., INFO, DEBUG, ERROR) and file path for SDK operation logs. Helps in troubleshooting and monitoring operations.
sdk_config
optional
Contains additional SDK-wide settings:
auto_refresh_fields: Enables/disables automatic refreshing of module fields. If set to true, the SDK will refresh modules and fields metadata every hour. If set to false, the metadata should be manually refreshed.
pick_list_validation: Enables/disables validation of picklist field values.
If set to true, the SDK checks user inputs against the defined picklist values. Invalid inputs, i.e., values not present in the picklist, will cause the SDK to throw an error.
 connect_timeout: Sets the maximum time to wait for connection establishment.
read_timeout: Sets the maximum time to wait for data retrieval.
resource_path
optional
Specify the directory path for storing module field information cache. 

Initializing Python SDK for Self-Clients

To initialize the SDK for a self-client:
1. Register the Client: In the Zoho API Console, create a self-client by navigating to the Self-Client section. This client is used for applications accessing only your own CRM data.

2. Generate Grant Token: After registering the client, manually generate a grant token from the API Console. Specify the necessary scopes, such as ZohoCRM.modules.ALL, based on the data you need to access.
Note: The grant token is valid for a short duration, typically 3–10 minutes, and is used to generate access and refresh tokens, using which one can access the CRM data.



3. Install the Python SDK
Install the Zoho CRM Python SDK in your Python project. The latest SDK version supports V7 of Zoho CRM APIs. 

4. Exchange Grant Token for Access and Refresh Tokens
Use the SDK in your code to exchange the grant token for access and refresh tokens. The SDK provides built-in methods to handle this process, and it will automatically manage token generation and persistence after initialization.



5. Access CRM Data:
With the tokens in place, your backend application can access and interact with Zoho CRM data programmatically, enabling tasks like data synchronization.
Here is a sample code for initializing Python SDK for a self-client.



Initializing Python SDK for Server-Based Clients

Before initializing the SDK for a server-based client, you must register your application in the Zoho API Console.


After registering the client, you can proceed with initializing the SDK for the server-based client. When using a server-based client with the Zoho CRM Python SDK, you have two options for handling authentication:
  • Generate the grant token manually and let the SDK manage the rest, including access token generation and refresh operations.
  • Write custom code to handle the entire OAuth process, from grant token generation to subsequent API calls. This approach is commonly used in server-based applications where automation and granular control over the flow are essential.
In the sample code, we demonstrate a complete implementation of initialization for a server-based client. The code includes generating the grant token for the required scopes, initializing the SDK with the tokens, and fetching records from Zoho CRM.

Understanding the Sample Code

The code defines an HTTP server that automates the OAuth process and interacts with Zoho CRM APIs. Here's a breakdown of its key functionalities:
Grant Token Generation:
When the user accesses http://127.0.0.1:8081/login, the server redirects them to Zoho's authorization page with the necessary OAuth scopes that is defined in the code.
After successful authorization, Zoho redirects the user to the redirect URL configured for the client in the API console, with a grant token and other parameters. The code parses this redirected URL to extract the grant token and the associated location.
SDK Initialization:
Using the extracted grant token, the SDK generates access and refresh tokens. These tokens are securely stored in a data store (FileStore in this case) using a unique identifier that corresponds to the user-org combination.


If no existing entry for the user-org combo is found in the token store, a new record is created with the user's grant, access, refresh tokens, and other details. When the same user logs in again, the SDK checks the token store for an existing entry. If an entry exists, the grant, access, and refresh tokens are updated while retaining the ID and user details. This ensures that no duplicate entries are created in the token store. Please note that in the background, the SDK retrieves the organization and user information to uniquely map the tokens. Without these scopes, the SDK cannot determine which user-org combination a token belongs to. Consequently, multiple entries might be created for the same user

API Call to Fetch Leads:
If the initialization is successful, the user will be redirected to http://127.0.0.1:8081/records. At this endpoint, the server uses the get_records method to fetch Leads data from the account. The response is processed, and the lead details (ID, Last Name, Company) are displayed as an HTML table.


We hope you found this post helpful and informative. By now, you should have a clear understanding of how to initialize and configure the Zoho CRM Python SDK for both self-clients and server-based clients.

Stay tuned for more insights, tutorials, and practical examples in our upcoming Kaizen posts. Your feedback matters to us. Let us know your thoughts or questions in the comments below. Until next time, happy coding!


Idea
Previous Kaizen: Kaizen #166 - Handling Query Variables in Zoho CRM | Kaizen Collection: Directory

Notes
Further Reading: