# Type

**Required**: no\
**Default**: `automatic` (based on `Content-Type` header)\
**Values**: `automatic`, `json`, `urlencoded`, `text` (or `string`), `binary` , and `xml`.

This directive specifies how to parse the data received from the server.

When `automatic` is used for the response type, Make tries to parse the response based on its `Content-Type` header.

Currently, Make recognizes only `text/plain`, `application/json`, `application/x-www-form-urlencoded` and `application/xml`(or `text/xml`).

When specifying other types, Make ignores the `Content-Type` header and tries to parse the response in the format that you have specified.

{% tabs %}
{% tab title="Example" %}

```json
{
    "response": {
        "type": "json"
    }
}
```

{% hint style="info" %}
This will parse all responses as JSON.

You can specify the type as a `string`, in which case every response, no matter the status code, will be processed based on your selected type.
{% endhint %}
{% endtab %}
{% endtabs %}

## Custom response types based on status code

You can specify the type as a special object where keys are status codes, wildcard, or status code ranges. This may be necessary because some services return different responses with different status codes: JSON on success and TEXT on error, for example.

### **Type object specification**

* The `*` (wildcard) represents all responses and should always be present.
* The `[number]-[number]` represents a status code range.
* The `[number]` represents a status code.\\

When specifying ranges and multiple ranges include the same status code, the smallest range is selected. The `*` has the largest range (1-999) and a number has the smallest range, for example, `455` is `455-455` range.

Ranges are counted inclusive from both sides, so if you specify a range `401-402`, both the `401` and `402` status codes will be processed by this range.

{% tabs %}
{% tab title="Example" %}

```json
{
    "response": {
        "type": {
            "*": "json", // parse all responses as JSON
            "400-408": "text", // parse all 400-408 responses as text, overrides "*",
            "406": "xml" // parse the 406 response as XML, overrides above definitions
        }
    }
}
```

{% hint style="info" %}
If a response returns with status `406`, it will be parsed as XML.\
If a response returns with status `401`, it will be parsed as text.\
If a response returns with status `200`, it will be parsed as JSON.
{% endhint %}
{% endtab %}
{% endtabs %}

## **XML type**

It is not possible to convert XML to JSON objects one-to-one. However, in Make, there are methods to accessing nodes and attributes to parsed XML.

#### Everything is an array

Each parsed node is an array, even the root node. Even if in XML a node is single, it will still be represented in Make as an array.

{% tabs %}
{% tab title="Example" %}

```xml
<data>
    <text>Hello, world</text>
</data>
```

Is parsed in Make as:

```json
{
    "data": {
        "text": ["Hello, world"]
    }
}
```

To access the value of `<text>` node in the output, for example:

```json
{
    "response": {
        "output": "body.data[].text[]"
    }
}
```

{% hint style="info" %}
Note the `[]` notation. This is a shortcut to getting the first element of an array in IML.
{% endhint %}
{% endtab %}
{% endtabs %}

#### Access the value of a node with attributes

If there are attributes present on the node you want to get the value of, you need to use `_value` .

{% tabs %}
{% tab title="Example" %}

```xml
<data>
    <text foo="bar">Hello, world</text>
</data>
```

Here, the previous example will not work, because the `<text>` node has attributes.

Use this to access the value of the `<text>` node:

```json
{
    "response": {
        "output": "body.data[].text[]._value"
    }
}
```

{% endtab %}
{% endtabs %}

#### Access node attributes

In a similar manner, you can access node attributes with `_attributes`:

{% tabs %}
{% tab title="Example " %}

```xml
<data>
    <text foo="bar">Hello, world</text>
</data>
```

`_attributes` is a collection where you can access each attribute’s value by its name:

```json
{
    "response": {
        "output": "body.data[].text[]._attributes.foo"
    }
}
```

{% endtab %}
{% endtabs %}

#### Access nested nodes

When accessing nested XML nodes, access them via the array notation. When accessing nested elements, it doesn’t matter if the parent has attributes or not:

{% tabs %}
{% tab title="Example" %}

```xml
<data>
    <items length="2">
        <item>
            <name>Foo</name>
        </item>
        <item>
            <name>Bar</name>
        </item>
    </items>
</data>
```

To process these two items in the `iterate` directive:

```json
{
    "response": {
        "iterate": "body.data[].items[].item",
        "output": {
            "name": "{{item.name[]}}"
        }
    }
}
```

{% hint style="info" %}
It is the `item` array that contains `<item>` nodes, and not the `items` array.
{% endhint %}
{% endtab %}
{% endtabs %}

## Rounded long ID numbers

In some cases, services might send JSON or XML with long IDs:

{% tabs %}
{% tab title="Example" %}

```json
{
"id": 5189203162509781230504938,
"name": "blabla",
...
}
```

{% endtab %}
{% endtabs %}

Since Make uses JavaScript, numbers exceeding the [MAX\_SAFE\_INTEGER value](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER) may be rounded.

In this case, use `type: text` to handle the response. Then, use the `replace` (with RegEx) and `parseJSON` functions to convert these long numbers to strings.

{% tabs %}
{% tab title="Communication" %}

```json
"response": {
"type": "text",
"output": "{{fixLongNumbers(body)}}"
}
```

{% endtab %}

{% tab title="Custom function" %}

```javascript
function fixLongNumbers(body) {
try {
const fixedBody = body.replaceAll(/(?<!"|\d)(?<value>\d{16,})/g, '"$<value>"');
const output = JSON.parse(fixedBody);
return output;
} catch {
return body;
}
}
```

{% endtab %}
{% endtabs %}

This is not a problem when the third party sends an ID as a `string`.

{% tabs %}
{% tab title="First Tab" %}

```javascript
{
"id": "5189203162509781230504938",
"name": "blabla",
...
}
```

{% endtab %}
{% endtabs %}


---

# 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://developers.make.com/custom-apps-documentation/component-blocks/api/handling-responses/type.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.