Once your webhook sends a request to an external API, it often receives a response. This is where the Response List in the webhook block becomes incredibly useful. It lets you capture and use the data that comes back from the API, right inside your Guided Conversation flow.
Let’s dive into what the Response section in a webhook block does, why it matters, and how you can use it effectively.
What is a Webhook Response?
When your webhook sends a request to a third-party API (like your Zoho Desk, CRM, billing tool, or database), that API usually sends back a reply. This reply is called a response and contains the outcome of your request.
Example
For example, if your GC asks for a user’s profile from an external CRM, the API might send back something like this:
{
"user": {
"name": "Jane Doe",
"email": "jane.doe@example.com",
"subscription_status": "Active"
}
}
This response is important, and the Webhook Block’s Response section helps you capture and use this information within your conversation flow.
Two main parts of a Webhook Response
There are two parts of the response that you can work with inside the Webhook block:
Status Code
This is a number returned by the server that tells you if your request worked or not. It’s like a health check for your API call.
Common examples:
- 200 is Success! The request went through.
- 404 is Not found. Maybe the data doesn’t exist.
- 500 is Server error. Something went wrong on their side.
In Zoho Desk GC, you can store this status code in a variable and use it in conditional flows.
For example:
- If the status code is 200, show a success message and display user info.
- If status code is 404, show a “No records found” message.
- If the status code is 500, ask the user to try again later.
Response Values
This is the real data you asked for, like names, dates, statuses, or order details. The API can send data in many formats:
Single Value:
Example: "userName": "John"
List of Values:
Example: "orders": ["#123", "#124", "#125"]
Object (Structured Data):
Example:
"user": {
"name": "John",
"email": "john@example.com"
}
Array of Objects (Multiple Records):
Example:
"tickets": [
{ "id": "101", "subject": "Login Issue" },
{ "id": "102", "subject": "Billing Error" }
]
You can map any of these values to variables in your GC flow.
Once mapped, you can:
- Display them to users
- Use them in conditional checks
- Summarize them into one response using the Formatter block
Why the Response section is useful
Here’s why:
- Show live data like subscription status, order history, or open tickets
- Handle different API results differently using status codes
- Display data directly from your system without manual updates
- Keep your API as-is and manage formatting inside the GC flow
Response mapping is completely in the backend; users won’t see this configuration. It’s just there to help your bot know what to do with the data it receives.
Let’s say your bot is checking a user’s subscription status.
Step 1: You set up a webhook to fetch details from your billing API
Step 2: The API returns:
{
"user": {
"name": "Talaash",
"subscription": "Inactive"
}
}
Step 3: In the Response section:
- Map the status code to a variable: response_code
- Map user.name to user_name
- Map user.subscription to subscription_status
Step 4: Use conditions in the GC:
- If subscription_status is “Inactive”, prompt the user to renew
- If “Active”, show appreciation and subscription expiry date
- Just like that, your bot becomes more helpful, relevant, and context-aware.
If you’re using a Formatter block in this flow, the mapping should be done based on the Formatter’s output.
Learn about Formatter
Using JSON Pointers to map nested API responses
If your API response contains nested data, you can use a **JSON Pointer** to extract the exact value you need. This follows the [RFC 6901](https://www.rfc-editor.org/rfc/rfc6901.html) standard and is supported in the webhook block.
What’s a JSON Pointer?
It’s a string syntax used to locate a value inside a JSON response. It starts with `/` and uses `/` to separate levels in the hierarchy.
Example JSON Response
```json
{
"user": {
"name": "John Doe",
"subscription": {
"status": "Active"
}
}
Pointer paths:
- /user/name → John Doe
- /user/subscription/status → Active
When mapping your response values:
- In Response Variable, use a JSON pointer like /user/subscription/status.
- Set the Variable Name as something like subscription_status.
In Guided Conversations (GC), do not use {{...}} syntax in the pointer. Just use the plain JSON pointer path (e.g., /user/name).
Tips
Sometimes, API responses aren’t user-friendly. You might get dates like 2025-06-01T09:00:00Z or codes like subs_001_A. That’s where the Formatter block comes in handy. Once you capture the data using the Response section, pass it to the Formatter to clean it up and make it readable.
Example:
- Turn this "2025-06-01T09:00:00Z"
- Into this “1 June 2025, 9:00 AM”