Kaizen 185 - Subqueries in COQL API

Kaizen 185 - Subqueries in COQL API


Hello everyone!!

Welcome to another Kaizen week, where we discuss developer centric topics every Friday. This week, we have picked an interesting topic to discuss - Subqueries in COQL API.

Zoho CRM's CRM Object Query Language (COQL) is a powerful way to retrieve data from your CRM in a structured manner. With the release of COQL API version 7, we introduced a suite of enhancements, detailed in our previous Kaizen post. Today, we will cover one enhancement in detail—Subqueries.

Before the introduction of subqueries, filtering data dynamically across related modules required multiple API calls and additional code handling. Subqueries have fundamentally changed this, offering increased flexibility, reduced API consumption, and improved query performance. In today's Kaizen, we will explore what subqueries are, where and when to use them, their advantages, and a few practical use cases. We will also go through a few examples with different operators to help you understand COQL subqueries better.

What are Subqueries?

At its core, a subquery is a query nested within another query. This technique allows you to retrieve data from one module based on conditions derived from another related module. Think of it as a way to ask more sophisticated, multi-layered questions of your CRM data.
Imagine you're working on a CRM integration and need to find all Contacts associated with Accounts that have at least one Deal created in the last 30 days.

Before Subqueries:

Before subqueries, achieving this required multiple steps:
  1. Retrieve Account IDs from the Deals module where a Deal was created in the last 30 days - {"select_query": "SELECT Account_Name, Created_Time FROM Deals WHERE Created_Time >= '2025-01-01T00:00:00+05:30'"}
  2. Use these Account IDs in a second query to fetch associated Contacts - {"select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name in ('4876876000007481116', '4876876000007420031')"}
This requires writing extra code to store and use the Account IDs from the first query in the second query. This also means making multiple API calls, and handling responses separately. However, with Subqueries in COQL, this can now be achieved in a single query.

Using Subqueries:

With subqueries, you can achieve the same result in one single query!
{
  "select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name in (SELECT Account_Name FROM Deals WHERE Created_Time >= '2025-01-01T00:00:00+05:30')"
}
The Subquery (SELECT Account_Name FROM Deals WHERE Created_Time >= ...) retrieves Account IDs where a Deal was created in the last 30 days. The main query (SELECT Full_Name, Email FROM Contacts WHERE Account_Name IN (...)) fetches Contacts linked to those Accounts, all in one API call!
But there is a catch. Subqueries return only up to 100 records per query. If more than 100 matching records exist (e.g., over 100 Accounts with recent Deals in this case), the extra records are silently ignored. This can lead to incomplete results, so subqueries are best used when the filtered dataset is known to be small. Please head over to the Limitations section to learn about other limitations. 

Where to use Subqueries?

Subqueries in COQL are useful when there is a need to filter data dynamically based on conditions from other modules. Instead of fetching records separately and processing them, subqueries allow you to retrieve the required data in a single query.
Here are some common use cases where subqueries come in handy:

  • Segment accounts based on high-value Deal history: For instance, you can use subqueries to fetch accounts that have at least one high-value closed Deal. 
    { "select_query": "SELECT Account_Name FROM Accounts WHERE id in (SELECT Account_Name FROM Deals WHERE Amount > 100000 AND Stage = 'Closed Won')"}

  • Find Contacts whose Accounts have NEVER closed a deal: You can use subqueries in COQL to fetch Contacts that have no associated Deals. 
    {"select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name not in (SELECT Account_Name FROM Deals WHERE Stage != 'Closed Won')"}

  • Identify new Leads who haven’t been marketed to yet: For instance, if need to find all leads who were NOT part of a specific campaign, you can use Subqueries in COQL.
    {"select_query": "SELECT Full_Name, Email FROM Leads WHERE id not in (SELECT Leads FROM Campaigns WHERE Campaign_Name = 'T01')"}
    where Leads is a lookup up field in the Campaigns module.

  • Identify Deals Closed Outside a Specific Campaign: Similarly, to find all Deals that closed outside the “Q1 Marketing Blitz” campaign window, you can use the NOT BETWEEN operator with subqueries.
    { "select_query": "SELECT Deal_Name, Created_Time FROM Deals WHERE Closing_Date not between (SELECT Start_Date FROM Campaigns WHERE Campaign_Name = 'Q1 Marketing Blitz') and (SELECT End_Date FROM Campaigns WHERE Campaign_Name = 'Q1 Marketing Blitz')"}

Key Benefits of Using Subqueries

  • Reduces API calls and Credit consumption – Instead of fetching related data in multiple queries, subqueries fetch it in one go.
  • Less Data Processing – No need to store and process results from one query before making another.
  • Improved Query Efficiency – Filters and retrieves only relevant records dynamically.
  • Simplifies Integration Code – Removes extra loops and logic required to handle multiple queries.

Limitations of Subqueries in COQL

While subqueries improve performance and efficiency, they come with certain limitations:

  • Subqueries can only be used in the WHERE clause. You cannot use subqueries in SELECT or FROM.
  • There can be a maximum of 5 subqueries per query.
  • Only one column can be selected in a subquery. You cannot fetch multiple fields from the subquery.
  • Limited to 100 records per subquery. If more records are needed, or there could be more than 100 possible records in the subquery, consider using JOINs.

Credit Consumption Considerations

Please note that using subqueries does not introduce any change in credit consumption compared to regular COQL queries. Credit usage is determined by the number of records retrieved in the main query.
The following table outlines the credit consumption based on the number of records retrieved:

LIMIT (No: of records)
API credits consumed
1 - 200
1
201 - 1000
2
1001 - 2000
3

Subqueries vs. JOINs

A JOIN clause in COQL lets you retrieve fields from two (or more) related modules in a single query by linking them on a lookup field—no nested queries needed. It’s ideal when you need columns from both modules, ie., the parent module and the related modules, in the same response.

For example, consider a scenario where it's necessary to query all accounts that have associated Deal records created within the past month.
—without getting duplicate Account rows if an Account closed multiple Deals.

Subquery Approach:

{  "select_query": "SELECT Account_Name FROM Accounts WHERE id in (SELECT Account_Name FROM Deals WHERE Created_Time >= '2025-03-01T00:00:00+05:30')"}

The subquery first selects Account_Name from Deals where the Created_Time is within the past month. Then the main query fetches the Account_Name from Accounts, once per matching account.

JOINs Approach:

{ "select_query": "SELECT 'Account_Name.Account_Name', 'Account_Name.id' FROM Deals WHERE Created_Time >= '2025-03-01T00:00:00+05:30'"}

This JOIN COQL query queries the Deals module and pulls related fields from the Account_Name lookup (Account name and ID) for each Deal created in the last month. As a result, it returns duplicate rows for accounts that have multiple matching deals.

Sample Response:

Subquery
JOIN
 {
    "data": [
        {
            "Account_Name": "Chapmans",
            "id": "4876876000004946070"
        },
        {
            "Account_Name": "Customer Daily",
            "id": "4876876000005030168"
        },
        {
            "Account_Name": "Luma Infotech",
            "id": "4876876000007420031"
        },
        {
            "Account_Name": "Luma Biotech",
            "id": "4876876000007481116"
        }
    ],
    "info": {
        "count": 4,
        "more_records": false
    }
}




{
    "data": [
        {
            "Account_Name.id": "4876876000007481116",
            "Account_Name.Account_Name": "Luma Biotech",
            "id": "4876876000010128001"
        },
        {
            "Account_Name.id": "4876876000007481116",
            "Account_Name.Account_Name": "Luma Biotech",
            "id": "4876876000010128016"
        },
        {
            "Account_Name.id": "4876876000007420031",
            "Account_Name.Account_Name": "Luma Infotech",
            "id": "4876876000010128047"
        },
        {
            "Account_Name.id": "4876876000005030168",
            "Account_Name.Account_Name": "Customer Daily",
            "id": "4876876000010193006"
        },
        {
            "Account_Name.id": "4876876000004946070",
            "Account_Name.Account_Name": "Chapmans",
            "id": "4876876000010213010"
        }
    ],
    "info": {
        "count": 5,
        "more_records": false
    }
}

Why Subqueries Are Better in This Case:

  • No Duplicates: Subqueries ensure that each matching parent (Account) appears only once, even if multiple child records (Deals) match. This is perfect for deduplicated reporting or dropdown lists.
  • Cleaner Result: Easier to parse and use directly in UIs or aggregations where duplicates are not useful.
  • Lower Payload Size: Especially useful if you just want the Account info and don’t need Deal-level detail.
Both subqueries and JOINs allow you to retrieve related data, but when should you use one over the other?

Use Subqueries When:

  • You need to filter data based on related module conditions.
  • You do not need to fetch fields from multiple modules. ie., you want to query the inner lookup fields only in the WHERE clause, and not in any other clause.
  • You need deduplicated parent records.
  • The subquery has 100 or less records.

Use JOINs When:

  • You need to retrieve fields from multiple related modules in the same response. ie., you want to query the inner lookup fields in any clause other than the WHERE clause.
  • You are dealing with large datasets exceeding the subquery limit of 100 records.
  • You need detail per child record, even if it leads to duplicate parent values.

Operator support for Subqueries in COQL

When using subqueries in COQL, make sure to use the correct operators depending on whether the subquery returns multiple values or a single value.

Multi-Value Operators

These operators are to be used with the subqueries that return multiple values, which are then used in the main query. 
Operator
Description
Example use case and query
in
Checks if a value is present in a list of values returned by the subquery.
Fetch all Contacts whose Accounts have won high-value deals.

{"select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name in (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won' AND Amount > 100000)"}
not in
Excludes records where the value is present in the subquery result.
Fetch all Contacts whose Accounts have never closed a deal.

{ "select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name not in (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won')"}

Single-Value Operators

These operators require the subquery to return a single value. If the subquery returns multiple values, an error will occur. 
Operator
Description
Example use case 
=
Matches records where the field is equal to the subquery’s result.
Fetch Deals created on the same date as the latest deal.
!=
Retrieves records where the field is not equal to the subquery’s result.
Fetch Deals not created on the same date as the latest deal.
<, >, <=, >=
Compares a field with the single value returned by the subquery.
Fetch all Deals that closed before the latest high-value deal.
between
Ensures a field's value falls within a range.
Fetch all Deals closed between two specific deal closure dates.
not between
Excludes records within the range.
Fetch all Deals closed outside a specific date range.

Example 1: Using the IN operator to fetch Contacts linked to high-value Deals

{ "select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name in (SELECT Account_Name FROM Deals WHERE Amount > 100000 AND Stage = 'Closed Won')" }

Example 2: Using the NOT IN operator to fetch Contacts from Accounts that have never closed a Deal
{ "select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name not in (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won')"}

Example 3: Using the BETWEEN operator to identify Deals closed during a specific Campaign (Q1 Marketing Blitz)
{ "select_query": "SELECT Deal_Name, Created_Time FROM Deals WHERE Closing_Date between (SELECT Start_Date FROM Campaigns WHERE Campaign_Name = 'Q1 Marketing Blitz') and (SELECT End_Date FROM Campaigns WHERE Campaign_Name = 'Q1 Marketing Blitz')"}

Combine JOINs and Subqueries for Smarter Filtering

In many business scenarios, it is not enough to simply retrieve related fields via JOINs—you also need to dynamically filter data based on conditions from another module. This is where subqueries can be incredibly useful in conjunction with JOINs.

Let’s say you're analyzing deal performance and want to pull a list of Deals that are:
  • Associated with Active Campaigns
  • Linked to Accounts in high-revenue Industries (Annual Revenue > 10,000,000)
  • You need to fetch details from the related modules—like Account name, Campaign name, and Contact email—in the same query
Why this can't be solved easily: While COQL supports JOINs for pulling data from related modules and subqueries for dynamic filtering, you can’t do all of this in one approach alone.
  • JOINs allow you to retrieve fields from related modules (like Contact_Name.Email )—but they do not let you dynamically filter using fields from those modules.
  • Subqueries, on the other hand, allow you to filter based on fields from related modules (like filtering Deals based on the Annual Revenue of the associated Account)—but you can’t fetch fields from multiple related modules using just a subquery.
So, if you need to both filter based on fields in a related module (like Accounts.Annual_Revenue) and retrieve fields from related modules (like Contact_Name.Email, Campaign_Source.Campaign_Name), you need both tools.

Solution: Combine JOINs and Subqueries in the Same Query
{"select_query": "SELECT Deal_Name, Amount, Account_Name, Campaign_Source, Contact_Name.Email FROM Deals WHERE (Campaign_Source.Status = 'Active') AND Account_Name.Industry in (SELECT Industry FROM Accounts WHERE Annual_Revenue > 10000000 GROUP BY Industry)"}

This query:
  • Uses JOINs to fetch:
    • Contact_Name.Email – from Contacts
  • Uses a subquery to apply dynamic filtering on Deals based on the Industry of Accounts with Annual Revenue > 10000000. COQL subqueries return a maximum of 100 records. If multiple accounts satisfying the criteria share the same industry, using GROUP BY Industry ensures only unique industry values are returned. This helps stay within the 100-record limit and avoids redundant filtering.
In the results, you get a deduplicated, filter-accurate list of Deals tied to Active Campaigns and high-value industries—with rich contextual fields in one API call.

You can even use JOINs inside subqueries. For instance, to fetch all deals from Optical Networking accounts managed by Jane (jane.doe@zohotest.com), and include key details about the deal, contact, account, and campaign:
{ "select_query": "SELECT Deal_Name, Amount, Account_Name, Contact_Name.Email, Campaign_Source FROM Deals WHERE Account_Name in (SELECT id FROM Accounts WHERE Industry = 'Optical Networking' AND Owner.email = 'jane.doe@zohotest.com')"}

By combining JOINs and subqueries, you can handle more complex, real-world business requirements in a single query. JOINs help you enrich your data with fields from related modules, while subqueries let you apply smart, condition-based filters across modules. 

Advanced Filtering: Nested Subqueries

For more advanced use cases, you can nest subqueries within subqueries to create complex filtering conditions.
Let's say Imagine you need to identify all Contacts associated with Accounts that meet two specific criteria:
  • The Account is in the "Retail" industry.
  • The Account has at least one associated Deal that is in the "Closed Won" stage and has a value greater than $50,000.
This scenario is common in sales and marketing, where you want to target high-potential customers within a specific industry. Here's how you can achieve this using a nested subquery in COQL:
{
  "select_query": "SELECT Full_Name, Email FROM Contacts WHERE Account_Name in (SELECT id FROM Accounts WHERE Industry = 'Communications' AND id in (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won' AND Amount > 50000))"
}
Innermost Subquery: (SELECT Account_Name FROM Deals WHERE Stage = 'Closed Won' AND Amount > 50000)
This subquery identifies all Account_Name values from the Deals module where the Stage is "Closed Won" and the Amount is greater than $50,000. Although the field name is Account_Name, it's a lookup to the Accounts module, so it returns the Account ID. This effectively isolates Accounts that have closed high-value deals.

Middle Subquery: (SELECT id FROM Accounts WHERE Industry = 'Retail' AND id IN (...))
This filters Accounts by the "Retail" industry and ensures that only those whose ID appears in the innermost subquery are selected.

Main Query: SELECT Full_Name, Email FROM Contacts WHERE Account_Name IN (...)
Finally, the main query retrieves the Full_Name and Email of all Contacts whose Account_Name matches the id values returned by the middle subquery.

Info
Note: COQL supports a maximum subquery nesting depth of 5, and you can include up to 5 subqueries total within a single query. The nesting limit refers to subqueries embedded within the WHERE clause of another subquery. 
Subqueries in COQL are a game-changer for developers looking to build efficient, context-aware queries across modules—allowing dynamic filtering that was previously only possible with multiple API calls. While JOINs help you fetch rich, multi-module data in a single response, subqueries let you filter records based on conditions from related modules. And when you combine the two, you unlock a powerful mechanism to tackle real-world CRM business cases with precision and clarity.

For advanced use cases, don’t hesitate to nest subqueries—COQL allows up to five levels deep—giving you the flexibility to build truly nuanced filters. Mastering the balance between JOINs and subqueries is key to writing smarter, cleaner, and more performant queries.

We hope you found this guide useful in understanding and implementing COQL subqueries. If you have any questions or require further clarification, please don't hesitate to leave a comment below or reach out to us directly at support@zohocrm.com. 

Keep experimenting, and as always, happy querying!






      • Sticky Posts

      • Kaizen #197: Frequently Asked Questions on GraphQL APIs

        🎊 Nearing 200th Kaizen Post – We want to hear from you! Do you have any questions, suggestions, or topics you would like us to cover in future posts? Your insights and suggestions help us shape future content and make this series better for everyone.

      • Kaizen #198: Using Client Script for Custom Validation in Blueprint

        Nearing 200th Kaizen Post – 1 More to the Big Two-Oh-Oh! Do you have any questions, suggestions, or topics you would like us to cover in future posts? Your insights and suggestions help us shape future content and make this series better for everyone.

      • Celebrating 200 posts of Kaizen! Share your ideas for the milestone post

        Hello Developers, We launched the Kaizen series in 2019 to share helpful content to support your Zoho CRM development journey. Staying true to its spirit—Kaizen Series: Continuous Improvement for Developer Experience—we've shared everything from FAQs

      • Kaizen #193: Creating different fields in Zoho CRM through API

        🎊 Nearing 200th Kaizen Post – We want to hear from you! Do you have any questions, suggestions, or topics you would like us to cover in future posts? Your insights and suggestions help us shape future content and make this series better for everyone.

      • Client Script | Update - Introducing Commands in Client Script!

        Have you ever wished you could trigger Client Script from contexts other than just the supported pages and events? Have you ever wanted to leverage the advantage of Client Script at your finger tip? Discover the power of Client Script - Commands! Commands

        • Recent Topics

        • UK payroll entries

          Hey guys, Nett payroll payments are imported direct into the bank, using an external payroll system (will be glad for Zoho to have a UK payroll app) At present I have monthly recurring bills for HMRC which are auto entered & paid when due. This seems

        • Closing Accounting Periods - Invoice/Posting dates

          Hi, I have seen in another thread but I'm unsure on how the 'transaction locking' works with regards to new and old transactions. When producing monthly accounts if I close December 24 accounts on 8th Jan 25 will transaction locking prevent me from posting

        • Invoice status on write-off is "Paid" - how do I change this to "Written off"

          HI guys, I want to write off a couple of outstanding invoices, but when I do this, the status of the invoices shows as "Paid". Clearly this is not the case and I need to be able to see that they are written off in the customer's history. Is there a way

        • Reverse Charge Services (Non-EU) Showing Correctly in 84/85 and 67, But Missing in Box 46 - Germany

          Hi, I'm located in Germany and I’ve set up my expenses for non-EU services (e.g., OpenAI, DeepSeek) under the reverse charge mechanism (§ 13b UStG) in Zoho Books, and I noticed some discrepancies in the VAT Summary Report. What’s Correct: Reverse Charge

        • Zoho Live Chat/Support

          What is going on with Zoho support lately? I've tried to use the live chat feature 4 different times and it refuses to connect to any (despite waiting over 30 minutes one of the tries). I finally gave up and emailed my question nearly a week ago and still

        • Can we have a module to records Certificate No and TDS rates for Lower TDS Certificates by the vendors ?

          Can we have a module to records Certificate No and TDS rates for Lower TDS Certificates by the vendors ?

        • Tip #38- Track Organizational Changes: A Guide to Using Action Log Viewer- 'Insider Insights'

          Hello Zoho Assist Community! Ever needed to trace who did what and when within your remote support operations? Let’s say your support team is growing, and you want to monitor key activities like settings updates, user invites, module changes, or permission

        • Tip of the Week #67– Avoid confusion – Mark duplicate threads.

          When customers send the same message to multiple email addresses, such as support@ and sales@, your team may end up seeing the same message in different inboxes. This creates confusion, risks double replies, and clutters your workspace. Use the Mark as

        • Tax in Quote

          Each row item in a quote has a tax value.  At the total numbers at the bottom, there is also a Tax entry. If you select tax in both of the (line item, and the total), the tax doubles. My assumption is that the Tax total should be totalling the tax from

        • Final Reminder: Discontinuation of Older ASAP Widgets and Mobile SDK Support

          We launched the new ASAP Help Widget last year, introducing a unified and enhanced experience. Since then, older configurations have been placed in read-only mode, with all major updates and improvements built exclusively on the new version. As part of

        • Zoho Subscriptions -- Zoho Commerce integration

          Is there integration between Zoho Subscriptions and Zoho Commerce? I would like to create subscription plans in Zoho Subscritpions and list them for on my Zoho Commerce store.

        • Website show Blank white screen

          Customer called me to tell me my website is currently down upon review it shows a white screen however I can access everything via editor. JITCADCAM.com

        • How manufacturing analytics can transform your enterprise with Zoho Projects Plus

          Did you know that every single car is made up of 30,000 to 40,000 individual parts? All of these are manufactured meticulously in various facilities before being assembled into one. The global manufacturing industry spans a wide range from delivering

        • Projects custom colors replaced by default orange

          Since yesterday, projects uploaded to Zoho, to which I had assigned a custom color, have lost the customization and reverted to the default color (orange). Has anyone else had the same problem? If so, how did you resolve it?

        • Customize your SalesIQ live chat with Custom CSS and blend it with your website design

          Hi everyone. Hope you all are having a great day! SalesIQ offers various inbuilt customization choices for your chat widget and window like changes in colour, theme, font etc. Although these choices are many, sometimes they may not match with the design

        • From Email Address When Replaying to Missed Chats

          One of the most common things we do is follow up on every missed chat.  Missed chats are like money in the bank, people just waiting for your response and to start a relationship with our companies. However, SalesIQ only lets you respond from 1 email address from your entire account?! We have happily paid for 4 subscriptions, but our users cannot reply from their own email address?  How are we supposed to build customer relationships? The fix to this issue is so simple, just load in the logged in

        • how to treat a same person as customer and vendor in zoho

          hi team, in my company, few persons acting as creditors as well as debtors (which means sometimes we pay them... some times we paid by them). in that case i would like to maintain a same ledger for that person.in zoho books it is treating creditor and

        • Narrative 6 - The impact of rebranding

          Behind the scenes of a successful ticketing system - BTS Series Narrative 6 - The impact of rebranding Every organization has invested in branding to set itself apart, and that should be reflected in the help desk. Zoho Desk enables organizations to apply

        • custom color palette for picklist in Sheet

          Migrating over from Google Sheets and missing the ability to customize the individual item colors of my picklist/dropdown menus. Is this something that is possible? A search showed me creating a custom color palette in Analytics is possible but I am not

        • What's New - July 2025 | Zoho Backstage

          Start smart, end strong. From knowing who’s coming to celebrating who showed up, July’s updates help you run events that feel organized from the first invite to the final thank you. Planning an event used to be like writing a choose-your-own-adventure

        • Image Upload Field API get encrypted ID and sequence number

          Hello is there a way to extract the encrypted id and sequence number from image upload fields through the Zoho CRM API? I created a custom script with javascript within Zoho CRM, but I want to extract the encrypted id and sequence number for all my images

        • Attention: Changes to 10DLC TCR pricing and new authentication requirements

          Hi everyone, Starting August 1, 2025, The Campaign Registry (TCR) is introducing new pricing changes and a mandatory brand verification process called Authentication+ 2.0, which will affect how you register and manage your 10DLC messaging services. These

        • Better Time Tracking

          We need better time tracking customization for IT MSPs. We also need reporting that is built in, rather than having to try and fumble with creating custom reports. We also need to be able to mark whether a ticket has been billed or not, I don't think

        • Scheduled Tickets Need Updated

          There is a very clunky manual way to create reoccurring scheduled tickets. This should be created to be easy for the administrator to create. We create several (10 to 12) reoccurring tickets per account for biweekly and monthly auditing purposes.. The

        • Team Feeds Improvements

          Team Feeds needs to show a feed of every action within the department. Currently it seems that the feed will only show a ticket that I've personally commented on or interacted with/followed. A feed should be that, a feed. As a manager I would like to

        • Better Security, Better User Experience | Help Center Update | June'25

          As part of our commitment to enhancing user experience and security, we are happy to announce updates to our authentication mechanism. This update introduces several key enhancements designed to improve the password recovery process and streamline the

        • Upload Logo to Account Page

          It would be nice to set a logo for an Account

        • View Agent Collision on Ticket List Page

          It would be nice from the ticket listing page (views) to see what agents are working on what tickets rather than having to click into each ticket throughout the day to see what agents are working on what tickets. This functionality would also be desired

        • Restrict user from viewing the detail standard view

          Is there any way to restrict a user(it can be user-field-based) from viewing the detail standard view? Basically, I have created a canvas detailed view so that on some conditions I can hide some data from the users but the standard view client script

        • Upload Picture to Contact

          It would be nice to upload a profile picture to a contact.

        • Ticket Status Colors

          Can i change the colors of Ticket Status in the admin panel? Or even change the background of the entire cell of a Critical ticket? This way its easy for my agents to see a urgent ticket when it comes in. Right now everything is black text. Here Right

        • Allowing Pictures for Client Contacts

          Do you have any plans to allow us to add pictures of our client contacts? There is a silhouette of a person there now, but no way that I can see where I can actually add a picture of the individual.

        • Paid Support Plans with Automated Billing

          We (like many others, I'm sure) are designing or have paid support plans. Our design involves a given number of support hours in each plan. Here are my questions: 1) Are there any plans to add time-based plans in the Zoho Desk Support Plans feature? The

        • Agent name Alias

          I am seeing that Full name of my staffs are written on every ticket response which is not good for some reasons. It is possible to user like this: Manny P. (First Name with Last Name's First Letter) or  Manny (First Name) This is want we want to show

        • Unable to add attachments to tickets through Desk API

          I able to use the Desk API to generate tickets. However when I try to use the tickets/{ticketId}/attachments endpoint, I always get an Unauthorized error. My app has Desk.Tickets.ALL included in its scope so this should not be an issue

        • What's wrong with this COQL?

          What's wrong with this COQL? Code returns "invalid operator found". SELECT id, Name, Stage, Account, Created_Time, Tag FROM Production_Orders WHERE (Account = '4356038000072566002' AND Stage NOT LIKE '%customer%') ORDER BY Created_Time DESC LIMIT 200

        • [Feature Request] Add support for internationalized top-level domains mail hosting

          This is an important request to add support for internationalized domains mail hosting to https://www.zoho.com/mail/ In this case, that is only limited to domain name/mail address however currently it's already possible for us send mails etc using below

        • Add Enable/Disable to Field Rules and other Rules

          Hi, Sometimes I have rules setup for fields, and until I want to enable them for use, I can set the fields to Hidden but rules still show them, today you have to delete rules and then recreate them again, would be nice to have a toggle for Enabled/Disabled

        • Syncing stuck for days

          Hello when I made an account a few days ago and synced all my notes to it, it is still syncing. My app is only 400mb so I do not know why it is taking so long. Please help

        • Workflow runs on every edit despite not ticking the field repeat this workflow whenever a parent is edited.....

          Hi, It is my understanding that this workflow should only trigger once. Why is this triggering on every edit of the field? Based on another support query - directly from Zoho, If i tick the box 'repeat this workflow whenever a parent is edited' it should

        • Next Page