# Response Handler

IoT communication is bidirectional in nature, it includes both device-to-cloud and cloud-to-device communication. So far we have seen how to generate messages and send them to your IoT platform. Let's discuss how to handle the messages or commands coming from the server side.

The responses are handled by the receiver function in the device model. To handle such responses, go to the stage you want the logic to be in and then switch to the Receiver tab.

The handling of these messages are specific to the protocol in use, however, the common functions remain the same. 

```javascript
function receiver(response)
{ 
    console.log("Received a message on the subscribed topic ", response)
    state.received++;                
    state.recv_queue.push(response);            
}

```

It is important to understand that while a simulation is running, the handler may be invoked asynchronously. This is because the command from the server side could be initiated at any time. To be on the safer side and avoid any race condition, the subscription handler should be small and defer all actions to be executed in the next iteration call. In the above example, we have simply produced a log and pushed the received message to the receive queue. 

{% hint style="info" %}
Note that the subscription handler does not need to return any value. 
{% endhint %}

{% hint style="info" %}
The subscription handler could be invoked multiple times asynchronously while your simulation is running. That's why the results of the subscription should be stored in a queue rather than being processed, as a second run could overwrite the previous run's results. 
{% endhint %}

While the basic function of the response handler is the same, the data that it contains varies with the protocol. To understand how to handle the data that is received for each protocol, follow the examples given below.

**Response Handler for MQTT**

In MQTT, a client could subscribe to any particular topic. The subscription topic can be specified in the template by enabling the subscription button in the protocol tab. When a publication is received on the chosen topic, the subscription handler is invoked with 

```javascript
function(response)
{
   //response.topic   - The MQTT topic on which subscription has been received
   //response.message - A buffer object which is sent for the subscription 
}
```

**Response Handler for HTTP**

In HTTP, the custom handler is invoked with the result of the operation performed. For example, if you did a POST operation, you could handle the response sent by the server. 

```javascript
function(response)
{
   //response.header - The header info for the operation that was performed
   //response.status- The status for the operation that was performed
   //response.body   - A buffer object which is sent by the server
}
```

**Response Handler for NONE**

In NONE, if loopback is set to on. The payload that was supposed to be sent is received back.

```javascript
function(response)
{
   //response - The payload that was sent by the sender function
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.iotify.io/concepts/understanding-a-test/response-handler.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.