Zoho Creator Integrations — Connect with Your Business Tools 2026

Zoho Creator's strength is building custom apps for processes that don't fit standard software — a field service dispatch system, a dealer onboarding portal, a custom approval workflow, a quality audit form. But a Creator app that lives in isolation has limited value. The value multiplies when it's connected: syncing service jobs to Zoho CRM, posting approved expenses to Zoho Books, calling a logistics API to book a courier, or sending an automated alert to Slack.

This guide covers every integration method available in Zoho Creator — with code examples and real use cases — so you know which approach to use for each type of integration.

---

Integration Methods Overview

| Method | Use case | Technical level | |---|---|---| | Zoho CRM connector | Sync data to/from Zoho CRM | Low | | Zoho Books connector | Create invoices, contacts from Creator | Low | | Zoho Desk connector | Create/update tickets from Creator | Low | | Deluge invokeUrl() | Call any external REST API | Medium | | Inbound webhooks | Receive data from external systems | Medium | | Outbound webhooks | Push data to external systems on triggers | Low–Medium | | Zoho Flow | No-code connections to 800+ apps | Low | | REST API (exposing Creator data) | Let external apps query your Creator app | Medium |

---

Built-in Zoho Connectors

Zoho Creator has pre-built connectors for Zoho's own products. These handle authentication automatically — no API keys needed.

Zoho CRM Connector

The CRM connector lets Creator apps read and write Zoho CRM records using Deluge's zoho.crm functions.

Creating a CRM record from Creator:

leadMap = map();
leadMap.put("Last_Name", input.LeadLastName);
leadMap.put("First_Name", input.LeadFirstName);
leadMap.put("Company", input.Company);
leadMap.put("Phone", input.Phone);
leadMap.put("Lead_Source", "Creator App");
createLead = zoho.crm.createRecord("Leads", leadMap);

Call this in a Creator form's On Submit workflow — every form submission creates a Lead in Zoho CRM instantly.

Searching for existing CRM records:

searchCriteria = "((Email:equals:" + input.Email + "))";
results = zoho.crm.searchRecords("Contacts", searchCriteria);
if(results.size() > 0)
{
  contactId = results.get(0).get("id");
  // Contact exists — update instead of create
}

Updating a CRM record from Creator:

updateMap = map();
updateMap.put("Deal_Stage", "Proposal Sent");
updateMap.put("Amount", input.ProposalAmount);
updateDeal = zoho.crm.updateRecord("Deals", dealId, updateMap);

The CRM connector works in both directions — Creator can pull CRM data to display in forms (e.g., pre-populate customer details when a service engineer enters a job ID), and push updates back.

---

Zoho Books Connector

The Books connector handles invoice creation, contact management, and payment recording from Creator apps.

Creating an invoice in Zoho Books from a Creator approval workflow:

invoiceMap = map();
invoiceMap.put("customer_id", booksCustomerId);
invoiceMap.put("invoice_date", zoho.currentdate.toString("yyyy-MM-dd"));
invoiceMap.put("due_date", zoho.currentdate.addDay(30).toString("yyyy-MM-dd"));

lineItems = list();
item1 = map();
item1.put("item_id", "item_123456789");
item1.put("quantity", input.Quantity);
item1.put("rate", input.UnitPrice);
lineItems.add(item1);

invoiceMap.put("line_items", lineItems);
createInvoice = zoho.books.createRecord("invoices", "your_org_id", invoiceMap);
invoiceId = createInvoice.get("invoice").get("invoice_id");

Practical use case — custom approval app that posts to Books: A manufacturing company has a custom Creator app for sales order approvals. When a manager approves an order in Creator, a Deluge workflow calls the Books connector to create a proforma invoice in Zoho Books, pre-filled with the customer details and line items from the Creator record. The finance team sees the invoice in Books without any manual re-entry.

---

Zoho Desk Connector

Create support tickets from Creator forms (useful for field service apps where technicians report issues that need follow-up support):

ticketMap = map();
ticketMap.put("subject", "Field Issue: " + input.IssueType + " at " + input.SiteLocation);
ticketMap.put("description", input.IssueDescription);
ticketMap.put("contactId", deskContactId);
ticketMap.put("priority", "High");
createTicket = zoho.desk.createRecord("tickets", "your_portal_id", ticketMap);

---

Deluge invokeUrl() — Calling External REST APIs

When you need to integrate Creator with a system outside the Zoho ecosystem, invokeUrl() is the core Deluge function. It makes HTTP requests (GET, POST, PUT, DELETE) to any REST API.

Basic Structure

response = invokeUrl
[
  url: "https://api.externalservice.com/endpoint"
  type: POST
  parameters: {"key1": "value1", "key2": "value2"}.toString()
  headers: {"Authorization": "Bearer your_api_token", "Content-Type": "application/json"}
  connection: "your_connection_name"
];

The connection parameter is optional but recommended — Zoho Creator has a Connections feature (Settings → Connections) where you store API credentials securely. Reference the connection name in invokeUrl() instead of hardcoding API tokens in your Deluge code.

Creating a Connection

1. In Zoho Creator, go to Settings → Connections → + Add Connection
2. Select connection type: OAuth 2.0, API Key, Basic Auth, or Custom
3. Enter the provider's credentials and authorisation endpoint (for OAuth) or API key (for key-based APIs)
4. Give the connection a name (e.g., "twilio_connection", "shiprocket_connection")
5. Reference this name in invokeUrl() via connection: "connection_name"

---

Real Use Case: Field Service App Syncing to Zoho CRM

Scenario: A field service company uses a Creator app for technicians to log site visits. When a job is completed, the Creator app should:

1. Update the corresponding Deal in Zoho CRM to "Installation Complete"
2. Call the company's SMS API to notify the customer
3. Create an invoice in Zoho Books

Deluge workflow on job completion form submission:

// 1. Update CRM Deal
crmUpdateMap = map();
crmUpdateMap.put("Stage", "Installation Complete");
crmUpdateMap.put("Closing_Date", zoho.currentdate.toString("yyyy-MM-dd"));
zoho.crm.updateRecord("Deals", input.CRMDealID, crmUpdateMap);

// 2. Send SMS via external API (e.g., Exotel or MSG91)
smsPayload = map();
smsPayload.put("sender", "VOLTWAVE");
smsPayload.put("route", "4");
smsPayload.put("country", "91");
smsNumbers = list();
smsNumbers.add(input.CustomerPhone);
smsPayload.put("numbers", smsNumbers.toString());
smsPayload.put("message", "Dear " + input.CustomerName + ", your installation is complete. Job ID: " + input.JobID);

smsResponse = invokeUrl
[
  url: "https://api.msg91.com/api/sendhttp.php"
  type: POST
  parameters: smsPayload
  connection: "msg91_connection"
];

// 3. Create Zoho Books invoice
invoiceMap = map();
invoiceMap.put("customer_id", input.BooksCustomerID);
invoiceMap.put("invoice_date", zoho.currentdate.toString("yyyy-MM-dd"));
lineItems = list();
item = map();
item.put("name", "Installation Service - " + input.ProductModel);
item.put("quantity", 1);
item.put("rate", input.ServiceCharge);
lineItems.add(item);
invoiceMap.put("line_items", lineItems);
zoho.books.createRecord("invoices", "your_org_id", invoiceMap);

This three-step automation runs in under a second when the technician submits the completion form. No manual data entry, no delay.

---

Inbound Webhooks — Receiving Data in Creator

An inbound webhook lets external systems send data into your Creator app. Creator generates a unique webhook URL for each form — any HTTP POST to that URL creates a record in that form.

Setting up an inbound webhook:

1. In Creator, open the form you want to receive data into
2. Go to Integrations → Webhooks → Inbound Webhook
3. Creator generates a unique URL like: https://creator.zoho.in/api/v2/your_org/your_app/form/your_form/webhook
4. Configure the external system to POST data to this URL

The POST body should be application/x-www-form-urlencoded or application/json. Creator parses the incoming fields and maps them to form fields.

Use case: A Shopify store sends order data to a Creator app that manages warehouse operations. Shopify's webhook on "order created" POSTs to the Creator inbound webhook URL — a new order record appears in the Creator warehouse app instantly, ready for the picker.

Securing inbound webhooks: Creator inbound webhooks accept POST requests from any source by default. To secure them, enable the shared secret token — Creator includes a X-Creator-Secret header validation option, or use IP whitelisting for the sending system's IP range.

---

Outbound Webhooks — Pushing Data from Creator

When a Creator record is created or updated, you can push that data to an external URL automatically via an outbound webhook.

Setting up an outbound webhook:

1. Open the Creator form or report
2. Go to Workflow → Add Workflow → On a record action (Create/Edit)
3. Select action type: Call a Custom Function — write a Deluge invokeUrl() call, OR
4. Select action type: Integration → Webhook
5. Enter the destination URL, HTTP method (POST), and payload format

Outbound webhooks are appropriate when the destination system supports webhooks natively (Slack, Teams, Zapier catch webhooks, n8n, etc.).

Example — post a Creator approval to Slack:

slackPayload = map();
slackPayload.put("text", "New expense approved: ₹" + input.Amount + " by " + input.ApprovedBy + " | Category: " + input.Category);
invokeUrl
[
  url: "https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"
  type: POST
  parameters: slackPayload.toString()
  headers: {"Content-Type": "application/json"}
];

---

Zoho Flow — No-Code Connections

Zoho Flow (flow.zoho.in) connects Creator to 800+ apps without writing Deluge code. It's the right choice when:

• The target integration doesn't require complex data transformation
• The person building the integration isn't comfortable with Deluge
• You need to connect Creator to commonly used SaaS tools: Google Sheets, HubSpot, Mailchimp, Salesforce, Stripe, Razorpay, Trello, Jira, etc.

Example Zoho Flow: Creator form submission → Google Sheets row

1. Trigger: Zoho Creator — Record Created in [your form]
2. Action: Google Sheets — Append Row in [your sheet]
3. Map fields: Creator form fields → Google Sheets columns

This works without any Deluge code. The Flow runs in the background when a Creator record is created.

When Zoho Flow has limitations:

• Complex conditional logic (if Field A = X and Field B > Y, then...) is cumbersome in Flow's visual builder — better handled in Deluge
• High-frequency automations (hundreds of records per hour) can hit Flow execution limits on lower plans
• Transforming data (reformatting dates, splitting strings, doing arithmetic) is harder in Flow than in Deluge

For most typical integration use cases — syncing to CRM, updating spreadsheets, sending notifications — Flow is faster to build and easier to maintain.

---

Exposing Creator Data via REST API

Zoho Creator generates a REST API for every app automatically. External systems can query your Creator data without any custom development.

API endpoint format:

GET https://creator.zoho.in/api/v2/{owner_name}/{app_link_name}/report/{report_link_name}

Authentication: Use OAuth 2.0 with Zoho's accounts API to generate access tokens. Creator supports both user-level and service account (server-to-server) OAuth.

Filtering and pagination:

GET /api/v2/your_org/field-service-app/report/All_Jobs?criteria=(Status=="Open")&from=0&limit=200

This returns the first 200 open jobs from your Creator app as JSON. The external system can parse this and use it for reporting, BI tools (Tableau, Power BI, Google Data Studio), or other integrations.

Use case — Power BI dashboard from Creator data: A Creator app tracks dealer performance data. A Power BI report pulls data from the Creator API daily to build executive dashboards. The Creator API supports scheduled refresh via Power BI's web connector — no middleware needed.

---

Real Use Case 2: Custom Approval App Posting to Zoho Books

Scenario: A construction company has a custom Creator app for purchase order approval. When a PO is approved by the finance manager, it should create a Bill (vendor invoice) in Zoho Books.

Creator workflow on PO approval:

if(input.ApprovalStatus == "Approved")
{
  billMap = map();
  billMap.put("vendor_id", input.ZohoBooksVendorID);
  billMap.put("bill_number", input.PONumber);
  billMap.put("bill_date", input.PODate.toString("yyyy-MM-dd"));
  billMap.put("due_date", input.ExpectedDelivery.toString("yyyy-MM-dd"));

  lineItems = list();
  poLines = Creator.db.fetch("PO_Line_Items").filter(PONumber == input.PONumber);
  for each line in poLines
  {
    lineItem = map();
    lineItem.put("account_id", line.BooksAccountID);
    lineItem.put("description", line.Description);
    lineItem.put("quantity", line.Quantity);
    lineItem.put("rate", line.UnitRate);
    lineItems.add(lineItem);
  }
  billMap.put("line_items", lineItems);

  createBill = zoho.books.createRecord("bills", "your_org_id", billMap);
  billID = createBill.get("bill").get("bill_id");

  // Update the Creator PO record with the Books bill ID for reference
  Creator.db.edit("Purchase_Orders").where(PONumber == input.PONumber).set("BooksBillID", billID);
}

This creates a Bill in Zoho Books with all line items from the Creator PO, stores the Books bill ID back in Creator for cross-reference, and triggers the accounts payable workflow in Books (payment scheduling, vendor aging reports).

---

Practical Notes on invokeUrl() in Production

Error handling: Always check the response before assuming success.

if(response.get("status") == "success")
{
  // proceed
}
else
{
  // log the error to a Creator error log form
  errorLogMap = map();
  errorLogMap.put("Error_Source", "invokeUrl CRM update");
  errorLogMap.put("Error_Message", response.toString());
  errorLogMap.put("Record_ID", input.ID);
  Creator.db.insert("Error_Logs", errorLogMap);
}

Rate limits: Zoho CRM API has rate limits (varies by plan — typically 5,000–25,000 API calls per day). If your Creator app triggers CRM calls in bulk (e.g., importing 500 records at once), implement a delay or batch processing to avoid hitting limits.

Connections vs hardcoded credentials: Never hardcode API tokens in Deluge. Always use Zoho Creator Connections — stored credentials can be rotated without changing code.

---

VoltVave builds Zoho Creator apps with full system integrations — from field service platforms syncing to CRM to custom approval apps posting to Books. Contact us to discuss your use case.