Zoho SalesIQ and ChatGPT Integration: Build an AI-Powered Chatbot

Zoho SalesIQ gives you visitor tracking, live chat, and a bot framework out of the box. ChatGPT, through the OpenAI API, gives you natural language understanding that can handle nuanced customer questions without rigid decision trees. The Zoho SalesIQ ChatGPT integration combines both: a Zobot that calls the OpenAI Chat Completions API, grounds responses in your knowledge base, and hands off to a human agent when it cannot help. This guide walks through the full implementation, from creating the Zobot to writing the Deluge script, managing conversation context, and keeping API costs under control.

By the end, you will have a working chatbot on your website that answers product questions using your own documentation, handles multi-turn conversations, and routes complex queries to your support team. No third-party middleware required, just SalesIQ, Deluge, and the OpenAI API.

Why Connect Zoho SalesIQ with ChatGPT

The default SalesIQ Answer Bot works well for FAQ-style questions where a visitor’s query matches a knowledge base article. It struggles with open-ended questions, follow-up context, and anything that requires synthesizing information from multiple articles. ChatGPT fills that gap.

Here is what the integration gives you compared to the standard bot:

For businesses already using Zoho SalesIQ for live chat and visitor tracking, adding ChatGPT to an existing Zobot is a relatively small engineering effort with a measurable impact on first-response resolution rates.

Prerequisites and Account Setup

Before writing any code, confirm you have the following in place:

• Zoho SalesIQ Enterprise or Professional plan (Zobot with custom script handler requires at least Professional)
• An OpenAI API account with billing enabled and an API key generated from platform.openai.com
• The SalesIQ-OpenAI integration activated under Settings > Integrations > OpenAI in your SalesIQ dashboard
• At least one department configured in SalesIQ with live agents, for fallback routing

The OpenAI integration in SalesIQ enables the native open_ai action in Deluge, but for full control over prompts and context, you will use invokeurl to call the API directly. Both approaches work; direct API calls give you more flexibility for knowledge base grounding.

Creating the Zobot with a Custom Script Handler

Navigate to SalesIQ > Bots > Zobot and create a new bot. Choose “Custom Script” as the handler type. This gives you a Deluge script editor where you write the logic that runs every time a visitor sends a message.

Basic Zobot Structure

The Zobot script runs on every visitor message. The basic flow is:

1. Receive the visitor’s message via response.get("message")
2. Build a prompt with your knowledge base context and conversation history
3. Call the OpenAI API using invokeurl
4. Parse the response and send it back to the visitor
5. If the response indicates low confidence or the visitor asks for a human, trigger agent handoff

Here is the skeleton script:

// Zobot Custom Script — ChatGPT Integration
visitor_message = response.get("message");

if(visitor_message != null && visitor_message != "")
{
    // Build the API request
    system_prompt = "You are a helpful customer support assistant for [Your Company]. Answer questions based only on the following knowledge base. If you do not know the answer, say ESCALATE.";

    kb_context = "Product: ... | Pricing: ... | Return policy: ...";

    messages = List();
    messages.add({"role": "system", "content": system_prompt + "

Knowledge Base:
" + kb_context});
    messages.add({"role": "user", "content": visitor_message});

    payload = Map();
    payload.put("model", "gpt-4o-mini");
    payload.put("messages", messages);
    payload.put("max_tokens", 500);
    payload.put("temperature", 0.3);

    api_response = invokeurl
    [
        url: "https://api.openai.com/v1/chat/completions"
        type: POST
        parameters: payload.toString()
        headers: {"Authorization": "Bearer YOUR_OPENAI_API_KEY", "Content-Type": "application/json"}
    ];

    reply = api_response.get("choices").get(0).get("message").get("content");

    if(reply.contains("ESCALATE"))
    {
        // Hand off to human agent
        response.set("action", "forward");
        response.set("department", "Support");
        response.reply("Let me connect you with a support agent who can help further.");
    }
    else
    {
        response.reply(reply);
    }
}

This is the foundation. The sections below add conversation context, knowledge base grounding, and rate limiting on top of it.

Knowledge Base Grounding: Keeping Responses Accurate

The biggest risk with a ChatGPT-powered chatbot is hallucination, the model generating plausible but incorrect answers. Knowledge base grounding solves this by constraining the model’s responses to your actual documentation.

Building the Context Window

Your system prompt should include the specific information the chatbot needs to reference. There are two approaches:

Static context: paste your FAQ, product specs, pricing, and policies directly into the system prompt. This works for businesses with fewer than 50 FAQ entries. You update the Deluge script whenever the information changes.

Dynamic context: store your knowledge base in Zoho Creator or a Zoho CRM custom module and fetch relevant records at runtime using a Deluge zoho.crm.getRecords call before building the prompt. This scales better and keeps the bot current without script changes.

System Prompt Engineering

The system prompt controls the chatbot’s behavior. A well-structured prompt for a support chatbot includes:

• Role definition: who the bot is and what company it represents
• Knowledge base content: the actual information it can use to answer questions
• Constraints: instructions to only answer from provided context, never fabricate information
• Escalation trigger: a specific keyword (like “ESCALATE”) the model outputs when it cannot answer confidently
• Tone guidelines: professional, concise, no jargon, match your brand voice

Keep the system prompt under 3,000 tokens to leave room for conversation history and the model’s response within the context window.

Conversation Context Management

A chatbot that forgets the previous message is frustrating. To maintain multi-turn context, you need to store and replay conversation history with each API call.

SalesIQ provides response.get("chatHistory") in the Zobot script, which returns the recent messages. You can also use Zoho SalesIQ’s session storage to persist data across messages within the same chat session:

// Store and retrieve conversation context
chat_history = response.get("chatHistory");
stored_context = zoho.salesiq.session.get("conv_context");

messages = List();
messages.add({"role": "system", "content": system_prompt + "

" + kb_context});

// Add previous exchanges from history
if(stored_context != null)
{
    prev_messages = stored_context.toJSONList();
    for each msg in prev_messages
    {
        messages.add(msg);
    }
}

// Add current message
messages.add({"role": "user", "content": visitor_message});

// After getting the reply, store updated context
new_context = List();
if(stored_context != null)
{
    new_context.addAll(stored_context.toJSONList());
}
new_context.add({"role": "user", "content": visitor_message});
new_context.add({"role": "assistant", "content": reply});

// Keep only last 10 messages to manage token costs
if(new_context.size() > 10)
{
    new_context = new_context.subList(new_context.size() - 10, new_context.size());
}

zoho.salesiq.session.set("conv_context", new_context.toString());

Limiting the history to 10 messages (5 exchanges) balances context quality with API cost management. Each additional message adds to the token count and therefore the cost per request.

Fallback to Human Agent

No chatbot should be a dead end. When the AI cannot help, the visitor needs a path to a human. SalesIQ’s Zobot provides built-in handoff actions that make this straightforward.

Trigger Conditions for Escalation

Configure your bot to escalate in these scenarios:

• The model responds with your escalation keyword (e.g., “ESCALATE” in the system prompt instructions)
• The visitor explicitly asks for a human agent (detect phrases like “talk to a person”, “human agent”, “speak to someone”)
• The conversation exceeds a set number of exchanges without resolution (e.g., 8 messages)
• The API call fails due to timeout or rate limiting

// Escalation logic
escalation_phrases = {"talk to a person", "human agent", "speak to someone", "real person", "live agent"};
needs_human = false;

for each phrase in escalation_phrases
{
    if(visitor_message.toLowerCase().contains(phrase))
    {
        needs_human = true;
        break;
    }
}

if(needs_human || reply.contains("ESCALATE") || msg_count > 8)
{
    response.set("action", "forward");
    response.set("department", "Support");
    response.reply("I am connecting you with a support agent now. They will have the full context of our conversation.");
}

The agent who picks up the chat sees the entire conversation history in SalesIQ, including both the visitor messages and the bot’s responses. This eliminates the need for the visitor to repeat themselves. For teams using Zoho Desk alongside SalesIQ, the chat can automatically create a ticket with the full transcript attached.

Rate Limits, Cost Control, and Error Handling

OpenAI API calls cost money and have rate limits. A production chatbot needs safeguards against runaway costs and graceful handling of API errors.

Cost Estimation

For most customer support chatbots, GPT-4o-mini delivers strong results at a fraction of GPT-4o’s cost. A site handling 1,000 chat sessions per month with GPT-4o-mini would spend roughly $2 to $5 on API calls.

Error Handling in Deluge

Wrap your API call in a try-catch block and implement retry logic for transient errors:

try
{
    api_response = invokeurl
    [
        url: "https://api.openai.com/v1/chat/completions"
        type: POST
        parameters: payload.toString()
        headers: {"Authorization": "Bearer " + api_key, "Content-Type": "application/json"}
        connection_timeout: 10000
    ];

    if(api_response.get("error") != null)
    {
        error_type = api_response.get("error").get("type");
        if(error_type == "rate_limit_exceeded")
        {
            response.reply("Our systems are experiencing high demand. Please try again in a moment, or I can connect you with an agent.");
        }
        else
        {
            response.set("action", "forward");
            response.set("department", "Support");
            response.reply("Let me connect you with a support agent.");
        }
    }
}
catch(e)
{
    response.set("action", "forward");
    response.set("department", "Support");
    response.reply("I encountered a temporary issue. Connecting you with a support agent now.");
}

Set a monthly spending cap in your OpenAI account settings as an additional safeguard. You can also use Zoho Flow to monitor API usage by tracking the token counts returned in each API response and triggering alerts when costs approach your budget.

Testing and Deployment

Before pointing real visitors to the ChatGPT-powered Zobot, validate it thoroughly:

1. Use SalesIQ’s built-in bot testing tool to simulate conversations. Test at least 20 different question types from your FAQ coverage area.
2. Test edge cases: empty messages, very long messages (over 500 words), messages in languages other than your primary language, and profanity or abuse.
3. Verify the escalation flow by triggering each escalation condition and confirming the chat reaches a live agent with full history.
4. Measure response latency. The OpenAI API typically responds in 1 to 3 seconds for GPT-4o-mini. If latency exceeds 5 seconds, consider adding a typing indicator message before the API call.
5. Run a soft launch by deploying the bot to a single page or a percentage of traffic before rolling it out site-wide.

After deployment, track these metrics in the SalesIQ analytics dashboard: bot resolution rate (conversations resolved without agent), average response time, escalation rate, and visitor satisfaction scores. Zoho Zia’s analytics features can surface trends in the types of questions the bot handles well versus those that consistently escalate.

The combination of Zoho SalesIQ’s visitor tracking and bot framework with ChatGPT’s natural language capabilities creates a support channel that works around the clock without the rigidity of traditional decision-tree bots. Start with GPT-4o-mini for cost efficiency, ground every response in your knowledge base, and keep the human handoff path clear. The technical setup takes a day; the ongoing refinement of your knowledge base and prompts is where the real value compounds over time.