Zoho CRM + CleverTap: Sync CRM Data for Indian Mobile App Engagement

India’s mobile-first economy has created a unique challenge for growth teams: your best user data lives in Zoho CRM, but the tools that actually reach users on their phones are platforms like CleverTap. When these two systems operate in isolation, you end up sending push notifications to users who already converted, missing lifecycle triggers from CRM deal activity, and building segments that are weeks out of date.

A properly configured Zoho CRM and CleverTap integration closes that gap. CRM profile changes push to CleverTap within seconds. Deal stage transitions become CleverTap events that trigger campaigns automatically. And your mobile engagement becomes genuinely lifecycle-aware rather than just behaviour-based.

This guide covers the full integration architecture: profile sync via CleverTap’s upload API, webhook-based event triggers from Zoho CRM workflows, identity mapping for Indian mobile users, handling duplicate profiles, and building lifecycle campaigns that respond to CRM activity in real time. Examples throughout draw from Indian fintech apps, edtech platforms, and D2C brands.

Why Zoho CRM and CleverTap Need to Talk

CleverTap is built around behavioural data: what users do inside your app. It tracks sessions, events, funnels, and cohorts with precision. But it has no visibility into what happens outside the app: sales calls, support tickets, offline purchases, loan applications, or subscription upgrades handled by your sales team.

Zoho CRM holds exactly that context. A fintech app’s sales team closes an SIP upgrade for a user. An edtech platform’s counsellor converts a free-trial lead to a paid batch. A D2C brand’s operations team marks a high-value customer as VIP after a bulk order. None of this appears in CleverTap unless you pipe it there.

The reverse is equally valuable. When a user triggers a significant in-app event such as completing KYC, finishing a course module, or making a third purchase, that signal should update the CRM Contact record so sales and support teams see it. Without integration, these two data streams never meet.

The integration unlocks several high-value use cases for Indian mobile apps:

• Trigger a CleverTap push notification the moment a Zoho CRM Deal is marked Won, prompting the user to complete onboarding.
• Update a CleverTap user profile with CRM subscription tier so campaigns can exclude active subscribers from acquisition flows.
• Fire a CleverTap in-app message when a CRM Contact’s loan approval status changes, surfacing next steps inside the app.
• Suppress push notifications to users whose CRM records show a pending support escalation.

For Indian apps in particular, where WhatsApp, SMS, and push channels compete for attention, having CRM context in CleverTap helps you choose the right channel at the right moment rather than blasting all channels simultaneously.

Integration Architecture: Three Data Flows

A complete Zoho CRM and CleverTap integration covers three directional data flows. Understanding which flow handles which use case prevents overengineering and clarifies where to build each component.

Flow 1: CRM Profile to CleverTap User Profile

This flow keeps CleverTap user profiles in sync with CRM Contact and Lead records. When a Contact is created or updated in Zoho CRM, a workflow triggers a Deluge function that calls CleverTap’s /1/upload endpoint with profile data. This is a one-way push: CRM is the source of truth for user attributes like subscription plan, city, account manager, and segment.

Flow 2: CRM Events to CleverTap Events

This flow converts CRM activity into CleverTap events. A Deal moving from Proposal to Won, a Contact’s KYC status changing, or a support case being resolved becomes a CleverTap event with properties. Campaign builders can then use these events in journeys, segments, and triggers without any manual data export.

Flow 3: CleverTap Events to CRM Records

This reverse flow uses CleverTap’s webhook export feature to update CRM records when critical in-app events occur. App uninstalls, subscription cancellations, and purchase completions are examples of events that should update the Contact’s lifecycle stage or add activity notes in Zoho CRM. This flow is covered in more detail in the Zoho CRM webhooks guide.

Setting Up CleverTap’s Profile Upload API

CleverTap exposes a REST API at https://api.clevertap.com/1/upload that accepts user profile data in JSON format. Before building the Zoho integration, verify your CleverTap account credentials: you need the Account ID and Passcode from the CleverTap dashboard under Settings > Integration > API Credentials.

Profile Upload Payload Structure

A profile upload request sends an array of user objects. Each object must include an identity field and a profileData object. For Indian mobile apps, use the user’s mobile number in E.164 format as the identity wherever possible since email registration rates are lower in India’s mobile-first market.

{
  "d": [
    {
      "identity": "+919876543210",
      "type": "profile",
      "profileData": {
        "Name": "Rahul Sharma",
        "Email": "rahul.sharma@email.com",
        "Phone": "+919876543210",
        "City": "Bengaluru",
        "crm_lead_id": "8123456",
        "crm_account_type": "Premium",
        "crm_deal_stage": "Onboarding",
        "subscription_plan": "Pro",
        "subscription_value_inr": 2999
      }
    }
  ]
}

The identity value is how CleverTap links this profile update to an existing app user. The CleverTap SDK must set the same identity value on first app launch (typically done when the user registers or logs in). If the identities do not match, CleverTap creates a new anonymous profile rather than updating the existing one.

Deluge Function for Profile Upload

In Zoho CRM, create a Deluge function that constructs and sends this payload. Attach it to a workflow triggered on Contact create or update.

// Zoho CRM Deluge: Push Contact profile to CleverTap
ct_account_id = "YOUR_CT_ACCOUNT_ID";
ct_passcode = "YOUR_CT_PASSCODE";

contact_phone = input.get("Mobile");
contact_name = input.get("Full Name");
contact_email = input.get("Email");
contact_city = input.get("Mailing City");
contact_id = input.get("id");
subscription_plan = input.get("Subscription_Plan");

profile_data = Map();
profile_data.put("Name", contact_name);
profile_data.put("Email", contact_email);
profile_data.put("Phone", contact_phone);
profile_data.put("City", contact_city);
profile_data.put("crm_contact_id", contact_id.toString());
profile_data.put("subscription_plan", subscription_plan);

user_obj = Map();
user_obj.put("identity", contact_phone);
user_obj.put("type", "profile");
user_obj.put("profileData", profile_data);

payload = Map();
payload.put("d", list(user_obj));

headers = Map();
headers.put("X-CleverTap-Account-Id", ct_account_id);
headers.put("X-CleverTap-Passcode", ct_passcode);
headers.put("Content-Type", "application/json");

response = invokeurl
[
    url: "https://api.clevertap.com/1/upload"
    type: POST
    parameters: payload.toString()
    headers: headers
];
info response;

This function runs every time a Contact record is modified in Zoho CRM. For bulk updates, CleverTap’s upload API accepts up to 100 user objects per request, so you can batch records if running initial historical syncs through a scheduled Deluge function.

Mapping Zoho CRM Deal Stages to CleverTap Events

Deal stage transitions carry rich lifecycle meaning. In a fintech app’s Zoho CRM, a Deal moving from Document Collection to Credit Assessment signals that a user is mid-way through loan application. That’s the right moment to trigger a CleverTap in-app message encouraging completion, not a generic re-engagement push.

Configure a separate Zoho CRM workflow on the Deal module that fires when the Stage field changes. The Deluge function for this flow calls CleverTap’s event upload endpoint.

Event Upload Payload

{
  "d": [
    {
      "identity": "+919876543210",
      "type": "event",
      "evtName": "Deal Stage Changed",
      "evtData": {
        "stage_name": "Credit Assessment",
        "previous_stage": "Document Collection",
        "deal_value_inr": 250000,
        "product_category": "Personal Loan",
        "deal_id": "9834512",
        "account_manager": "Priya Nair"
      }
    }
  ]
}

Once this event flows into CleverTap, campaign builders can create journeys that trigger specific messages based on stage_name. A user reaching Credit Assessment gets a reassurance message. A user reaching Disbursed gets an onboarding sequence. The trigger is CRM-sourced, but the delivery is fully automated through CleverTap’s journey builder.

For edtech platforms, the equivalent events might be Counsellor Assigned, Demo Scheduled, Batch Enrolled, and EMI Activated. Each stage change in Zoho CRM fires an event to CleverTap, enabling stage-specific in-app content and push sequences without manual segment exports.

This is the same lifecycle event model that powers effective lifecycle email campaigns, applied to push and in-app channels instead.

User Identity Mapping for Indian Mobile Apps

Identity mapping is the most operationally critical part of this integration. If CleverTap cannot match an uploaded profile to an existing app user, the profile update creates a new anonymous record and your campaign targeting breaks.

Phone vs Email as Identity

In India, mobile-first apps typically have higher phone number registration rates than email. For apps where users log in with an OTP on their mobile number, phone in E.164 format is the most reliable identity field. For B2B SaaS apps and edtech platforms where users register with work or personal email, email is preferable.

The rule is simple: use whichever field your app’s CleverTap SDK sets as identity at login. Check your iOS and Android SDK integration to confirm which field is passed to CleverTap.setMultiValuesForKey("identity", ...). Your Deluge function must use the same field.

Handling Missing or Malformed Phone Numbers

Zoho CRM Contact records often contain phone numbers without country codes, with spaces, or with local formatting like 098765 43210. Before using a phone number as a CleverTap identity, the Deluge function should normalise it.

// Normalise Indian phone number to E.164
raw_phone = input.get("Mobile");
clean_phone = raw_phone.replaceAll(" ", "").replaceAll("-", "").replaceAll("(", "").replaceAll(")", "");
if (clean_phone.startsWith("0")) {
    clean_phone = "+91" + clean_phone.substring(1);
} else if (!clean_phone.startsWith("+")) {
    clean_phone = "+91" + clean_phone;
}
identity = clean_phone;

If neither a valid phone nor email is available on the CRM record, skip the CleverTap push and log the contact ID for manual review. Pushing records without a reliable identity creates orphaned profiles that pollute your CleverTap data.

Identity Merge for Returning Users

Indian apps with high uninstall and reinstall rates often end up with users having multiple device IDs in CleverTap. When a user reinstalls and logs in again, CleverTap should automatically merge the anonymous install profile with the identified profile if the SDK is configured correctly. Ensure your mobile developers have enabled the onUserLogin call in the CleverTap SDK during login, which triggers CleverTap’s internal identity resolution.

On the CRM side, if you detect that a Contact has two CleverTap identities (for example, because they registered with both email and phone at different times), you can use CleverTap’s merge profiles API to consolidate them, passing the confirmed CRM phone as the canonical identity.

CRM Workflow to Push Notification Automation

One of the highest-value use cases for this integration is triggering push notifications directly from Zoho CRM workflow automation. Instead of scheduling broadcast campaigns or manually exporting segments, CRM events fire targeted notifications automatically.

Example: Loan Approval Notification for Fintech Apps

When a loan application Deal in Zoho CRM moves to the Approved stage, the workflow fires a Deluge function that pushes a CleverTap event. The CleverTap journey builder has a trigger configured on the Deal Stage Changed event where stage_name = "Approved". Within seconds of the CRM update, the user receives a push notification: “Your loan of Rs 2,50,000 is approved. Open the app to complete disbursement.”

The notification is personalised with deal value from the CleverTap event properties. No manual segment export, no overnight batch job, no risk of notifying users before their approval is confirmed in the CRM.

Example: Course Seat Confirmation for Edtech Apps

An edtech platform’s counsellor marks a Deal as Enrolled in Zoho CRM after collecting the first EMI. The workflow triggers a CleverTap event Enrollment Confirmed with properties including course_name, batch_start_date, and mentor_name. CleverTap sends a personalised in-app message on the user’s next app open, along with a push notification with the batch start date.

This replaces a manual process where counsellors would inform the marketing team to send confirmation messages, a process that often had delays of hours or days.

Suppression: Avoiding Notifications During Active Support Cases

Equally important is using CRM data to suppress notifications. When a Contact in Zoho CRM has an open high-priority support ticket, the CRM workflow should push a profile update to CleverTap setting a custom property has_open_escalation: true. Campaign builders in CleverTap can then exclude users with this property from promotional and re-engagement campaigns until the ticket is resolved.

When the support case closes, the CRM workflow updates the profile to has_open_escalation: false, and the user re-enters eligible audiences automatically.

Data Sync Frequency and Handling Duplicate Profiles

Running profile sync on every CRM record save is reliable but can generate a high volume of API calls for large databases. Plan your sync strategy based on your CleverTap plan’s API rate limits and the actual frequency of meaningful profile changes.

For the initial historical sync when you first set up the integration, use a Zoho CRM scheduled function that queries all active Contacts in batches of 100 and posts each batch to CleverTap’s upload endpoint. Monitor the function’s execution log for failed batches and retry with exponential backoff.

Detecting and Resolving Duplicate Profiles

Duplicate CleverTap profiles occur when the same user is uploaded with different identity values at different times: once with phone, once with email, once as anonymous. Before pushing a profile, your Deluge function can call CleverTap’s profile lookup endpoint to check if a profile with that identity already exists.

// Check if CleverTap profile exists before upload
lookup_url = "https://api.clevertap.com/1/profiles.json?email=" + contact_email;
headers = Map();
headers.put("X-CleverTap-Account-Id", ct_account_id);
headers.put("X-CleverTap-Passcode", ct_passcode);

existing = invokeurl
[
    url: lookup_url
    type: GET
    headers: headers
];

if (existing.get("status") == "success" && existing.get("count") > 0) {
    // Profile exists: send update only
    // Use existing identity from the response
    existing_identity = existing.get("records").get(0).get("identity");
    user_obj.put("identity", existing_identity);
}

For merging already-duplicated profiles, CleverTap’s merge API requires an Enterprise plan feature. As a practical alternative, ensure all new uploads consistently use the same identity field (phone number) to prevent new duplicates from forming, and address existing duplicates through CleverTap’s dashboard merge tool.

Connecting CRM data to mobile marketing automation platforms like CleverTap requires the same identity discipline that governs Facebook Custom Audience matching: the quality of your outcomes depends entirely on how reliably you can match records across systems.

Building Lifecycle Campaigns with CRM-Sourced Segments

With CRM profile properties flowing into CleverTap, your segment builder gains access to a much richer set of attributes than behavioural data alone provides. You can now build segments that combine what users did in the app with what they are in the CRM.

Segment Examples for Indian Apps

High-intent inactive fintech users: CRM property crm_deal_stage = "Document Submitted" AND CleverTap event App Session not done in the last 7 days. These users have expressed strong intent (they submitted documents) but have gone cold. A targeted push with a specific CTA (“Your application is waiting”) outperforms a generic re-engagement broadcast.

D2C repeat purchase candidates: CRM property crm_account_type = "VIP" AND CleverTap event Product Viewed done in the last 3 days but Order Placed not done in the last 3 days. VIP customers browsing but not converting get a personalised in-app nudge with a limited-time offer or a free shipping prompt.

Edtech upsell segment: CRM property subscription_plan = "Basic" AND CleverTap event Course Completed done at least once. Users who finished a course on the basic plan and whose CRM record shows no sales activity in the last 14 days are strong upsell candidates. A CleverTap journey sends an in-app message with a batch upgrade offer, followed by a push notification 48 hours later if there is no conversion.

Journey Architecture for CRM-Triggered Campaigns

The most reliable journey architecture for CRM-triggered campaigns uses CleverTap’s API-triggered campaign feature rather than behavioural event triggers. Instead of waiting for CleverTap to detect an event, the Zoho CRM Deluge function directly calls CleverTap’s campaign trigger API, specifying the campaign ID and the user identity.

This approach has lower latency (the notification fires within seconds of the CRM action) and is more reliable for low-frequency, high-stakes events like loan approvals or order confirmations where timing matters. For AI-powered engagement flows that respond to intent signals, the event-based journey model works well because latency is less critical.

Practical Setup Checklist

Use this checklist when deploying the integration for an Indian mobile app:

• Confirm CleverTap Account ID and Passcode from Settings > Integration.
• Verify which field (phone or email) your mobile SDK uses as identity at login.
• Create a custom Zoho CRM field CleverTap Identity on the Contact module to store the confirmed identity value for debugging.
• Build the Deluge profile upload function and test with a single Contact record before attaching to the workflow.
• Set up the Deal stage change workflow and verify that CleverTap events appear in the Event Explorer within 60 seconds of a stage update.
• Configure phone number normalisation logic for Indian numbers, covering 10-digit numbers, numbers with +91, and numbers with leading 0.
• Run the initial historical sync in a test environment with 10 records before executing against your full Contact database.
• Set up error logging in the Deluge function: write failed API calls to a Zoho CRM custom module or a Zoho Cliq channel for visibility.
• Test profile merge behaviour by uploading the same identity twice with different profile data and confirming CleverTap shows the updated values rather than creating a duplicate.
• Validate that CleverTap campaign suppression logic correctly excludes users with has_open_escalation: true before going live.

For a full overview of all available options, explore our complete guide to Zoho integrations.