Construa sobre o WhatsApp
sem adivinhar a API.

Implement a TypeScript function called chat_archiveChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/archiveChat with Authorization Bearer <YOUR_TOKEN>. Moves the conversation out of the main list and into Archived, or brings it back. Nothing is deleted: the conversation and all its messages remain. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "messageTimestamp": 0
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.archiveChat integration in a Node.js service. Moves the conversation out of the main list and into Archived, or brings it back. Nothing is deleted: the conversation and all its messages remain."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/archiveChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": false,
        "messageData": {
          "key": {},
          "messageTimestamp": 0
        }
      }
    }
  ]
}

In the current project, implement the chat_archiveChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/archiveChat. Moves the conversation out of the main list and into Archived, or brings it back. Nothing is deleted: the conversation and all its messages remain. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "messageTimestamp": 0
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/archiveChat. Auth: Bearer <YOUR_TOKEN>. Moves the conversation out of the main list and into Archived, or brings it back. Nothing is deleted: the conversation and all its messages remain. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "messageTimestamp": 0
  }
}

Implement a TypeScript function called chat_blockChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/blockChat with Authorization Bearer <YOUR_TOKEN>. Blocks the contact: they can no longer message the connected number and no longer see "online" and the profile photo. The same call undoes the block, but the messages they tried to send while blocked are not delivered afterward. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": false
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.blockChat integration in a Node.js service. Blocks the contact: they can no longer message the connected number and no longer see \"online\" and the profile photo. The same call undoes the block, but the messages they tried to send while blocked are not delivered afterward."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/blockChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": false
      }
    }
  ]
}

In the current project, implement the chat_blockChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/blockChat. Blocks the contact: they can no longer message the connected number and no longer see "online" and the profile photo. The same call undoes the block, but the messages they tried to send while blocked are not delivered afterward. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": false
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/blockChat. Auth: Bearer <YOUR_TOKEN>. Blocks the contact: they can no longer message the connected number and no longer see "online" and the profile photo. The same call undoes the block, but the messages they tried to send while blocked are not delivered afterward. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": false
}

Implement a TypeScript function called chat_clearChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/clearChat with Authorization Bearer <YOUR_TOKEN>. Deletes every message inside the conversation but keeps the conversation in the list. Deleted messages do not come back. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0,
    "starredMessage": true,
    "mediaFromDevice": true
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.clearChat integration in a Node.js service. Deletes every message inside the conversation but keeps the conversation in the list. Deleted messages do not come back."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/clearChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "key": {},
          "messageTimestamp": 0,
          "starredMessage": true,
          "mediaFromDevice": true
        }
      }
    }
  ]
}

In the current project, implement the chat_clearChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/clearChat. Deletes every message inside the conversation but keeps the conversation in the list. Deleted messages do not come back. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0,
    "starredMessage": true,
    "mediaFromDevice": true
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/clearChat. Auth: Bearer <YOUR_TOKEN>. Deletes every message inside the conversation but keeps the conversation in the list. Deleted messages do not come back. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0,
    "starredMessage": true,
    "mediaFromDevice": true
  }
}

Implement a TypeScript function called chat_deleteChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteChat with Authorization Bearer <YOUR_TOKEN>. Deletes the whole conversation, with all its history, from the instance. No undo: the messages cannot be recovered through this API afterward. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.deleteChat integration in a Node.js service. Deletes the whole conversation, with all its history, from the instance. No undo: the messages cannot be recovered through this API afterward."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "key": {},
          "messageTimestamp": 0
        }
      }
    }
  ]
}

In the current project, implement the chat_deleteChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteChat. Deletes the whole conversation, with all its history, from the instance. No undo: the messages cannot be recovered through this API afterward. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteChat. Auth: Bearer <YOUR_TOKEN>. Deletes the whole conversation, with all its history, from the instance. No undo: the messages cannot be recovered through this API afterward. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0
  }
}

Implement a TypeScript function called chat_deleteMessage that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessage with Authorization Bearer <YOUR_TOKEN>. Deletes a message from the conversation. The action is irreversible: the message does not come back, and WhatsApp leaves a notice in its place that a message was deleted. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.deleteMessage integration in a Node.js service. Deletes a message from the conversation. The action is irreversible: the message does not come back, and WhatsApp leaves a notice in its place that a message was deleted."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessage",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "key": {},
          "messageTimestamp": 0
        }
      }
    }
  ]
}

In the current project, implement the chat_deleteMessage client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessage. Deletes a message from the conversation. The action is irreversible: the message does not come back, and WhatsApp leaves a notice in its place that a message was deleted. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessage. Auth: Bearer <YOUR_TOKEN>. Deletes a message from the conversation. The action is irreversible: the message does not come back, and WhatsApp leaves a notice in its place that a message was deleted. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "key": {},
    "messageTimestamp": 0
  }
}

Implement a TypeScript function called chat_deleteMessageFromMe that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessageFromMe with Authorization Bearer <YOUR_TOKEN>. Deletes a message that came from the connected number itself. It is final: once deleted, the message cannot be recovered through this API. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "messageData": {
    "id": "<VALOR>",
    "timestamp": 0
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.deleteMessageFromMe integration in a Node.js service. Deletes a message that came from the connected number itself. It is final: once deleted, the message cannot be recovered through this API."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessageFromMe",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "messageData": {
          "id": "<VALOR>",
          "timestamp": 0
        }
      }
    }
  ]
}

In the current project, implement the chat_deleteMessageFromMe client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessageFromMe. Deletes a message that came from the connected number itself. It is final: once deleted, the message cannot be recovered through this API. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "messageData": {
    "id": "<VALOR>",
    "timestamp": 0
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/deleteMessageFromMe. Auth: Bearer <YOUR_TOKEN>. Deletes a message that came from the connected number itself. It is final: once deleted, the message cannot be recovered through this API. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "messageData": {
    "id": "<VALOR>",
    "timestamp": 0
  }
}

Implement a TypeScript function called chat_muteChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteChat with Authorization Bearer <YOUR_TOKEN>. Stops getting notifications from a conversation for the given time. Messages keep arriving normally, they just do not notify. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "time": 0
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.muteChat integration in a Node.js service. Stops getting notifications from a conversation for the given time. Messages keep arriving normally, they just do not notify."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "time": 0
      }
    }
  ]
}

In the current project, implement the chat_muteChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteChat. Stops getting notifications from a conversation for the given time. Messages keep arriving normally, they just do not notify. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "time": 0
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteChat. Auth: Bearer <YOUR_TOKEN>. Stops getting notifications from a conversation for the given time. Messages keep arriving normally, they just do not notify. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "time": 0
}

Implement a TypeScript function called chat_muteStatus that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteStatus with Authorization Bearer <YOUR_TOKEN>. Stops receiving a contact's status updates, without blocking or removing anyone. The same call undoes it. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": false
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.muteStatus integration in a Node.js service. Stops receiving a contact's status updates, without blocking or removing anyone. The same call undoes it."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteStatus",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": false
      }
    }
  ]
}

In the current project, implement the chat_muteStatus client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteStatus. Stops receiving a contact's status updates, without blocking or removing anyone. The same call undoes it. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": false
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/muteStatus. Auth: Bearer <YOUR_TOKEN>. Stops receiving a contact's status updates, without blocking or removing anyone. The same call undoes it. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": false
}

Implement a TypeScript function called chat_pinChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinChat with Authorization Bearer <YOUR_TOKEN>. Pins the conversation to the top of the list, or releases it. WhatsApp limits how many conversations can be pinned at the same time. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": false
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.pinChat integration in a Node.js service. Pins the conversation to the top of the list, or releases it. WhatsApp limits how many conversations can be pinned at the same time."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": false
      }
    }
  ]
}

In the current project, implement the chat_pinChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinChat. Pins the conversation to the top of the list, or releases it. WhatsApp limits how many conversations can be pinned at the same time. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": false
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinChat. Auth: Bearer <YOUR_TOKEN>. Pins the conversation to the top of the list, or releases it. WhatsApp limits how many conversations can be pinned at the same time. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": false
}

Implement a TypeScript function called chat_pinMessageInChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinMessageInChat with Authorization Bearer <YOUR_TOKEN>. Highlights a specific message at the top of the conversation, visible to all participants, or removes that highlight. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "duration": 0
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.pinMessageInChat integration in a Node.js service. Highlights a specific message at the top of the conversation, visible to all participants, or removes that highlight."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinMessageInChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": false,
        "messageData": {
          "key": {},
          "duration": 0
        }
      }
    }
  ]
}

In the current project, implement the chat_pinMessageInChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinMessageInChat. Highlights a specific message at the top of the conversation, visible to all participants, or removes that highlight. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "duration": 0
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/pinMessageInChat. Auth: Bearer <YOUR_TOKEN>. Highlights a specific message at the top of the conversation, visible to all participants, or removes that highlight. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "duration": 0
  }
}

Implement a TypeScript function called chat_presenceUpdateChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/presenceUpdateChat with Authorization Bearer <YOUR_TOKEN>. Makes the "typing…" or "recording audio…" notice appear in the other person's conversation. Automated services use this so the reply does not arrive too instantly. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": "<VALOR>"
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.presenceUpdateChat integration in a Node.js service. Makes the \"typing…\" or \"recording audio…\" notice appear in the other person's conversation. Automated services use this so the reply does not arrive too instantly."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/presenceUpdateChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": "<VALOR>"
      }
    }
  ]
}

In the current project, implement the chat_presenceUpdateChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/presenceUpdateChat. Makes the "typing…" or "recording audio…" notice appear in the other person's conversation. Automated services use this so the reply does not arrive too instantly. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": "<VALOR>"
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/presenceUpdateChat. Auth: Bearer <YOUR_TOKEN>. Makes the "typing…" or "recording audio…" notice appear in the other person's conversation. Automated services use this so the reply does not arrive too instantly. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": "<VALOR>"
}

Implement a TypeScript function called chat_readChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readChat with Authorization Bearer <YOUR_TOKEN>. Resets a conversation's unread counter - or does the opposite, marking it unread so you remember to reply later. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "messageTimestamp": 0
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.readChat integration in a Node.js service. Resets a conversation's unread counter - or does the opposite, marking it unread so you remember to reply later."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "to": "5511999998888",
        "option": false,
        "messageData": {
          "key": {},
          "messageTimestamp": 0
        }
      }
    }
  ]
}

In the current project, implement the chat_readChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readChat. Resets a conversation's unread counter - or does the opposite, marking it unread so you remember to reply later. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "messageTimestamp": 0
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readChat. Auth: Bearer <YOUR_TOKEN>. Resets a conversation's unread counter - or does the opposite, marking it unread so you remember to reply later. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "to": "5511999998888",
  "option": false,
  "messageData": {
    "key": {},
    "messageTimestamp": 0
  }
}

Implement a TypeScript function called chat_readMessage that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readMessage with Authorization Bearer <YOUR_TOKEN>. Marks a message as read. If read receipts are on, the other person starts seeing the blue ticks. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "key": {}
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.readMessage integration in a Node.js service. Marks a message as read. If read receipts are on, the other person starts seeing the blue ticks."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readMessage",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "key": {}
        }
      }
    }
  ]
}

In the current project, implement the chat_readMessage client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readMessage. Marks a message as read. If read receipts are on, the other person starts seeing the blue ticks. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "key": {}
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/readMessage. Auth: Bearer <YOUR_TOKEN>. Marks a message as read. If read receipts are on, the other person starts seeing the blue ticks. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "key": {}
  }
}

Implement a TypeScript function called chat_starMessageChat that calls POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/starMessageChat with Authorization Bearer <YOUR_TOKEN>. Marks a message with the star, so you can find it later in the starred messages list. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "option": true,
    "key": {}
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the chat.starMessageChat integration in a Node.js service. Marks a message with the star, so you can find it later in the starred messages list."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/starMessageChat",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "option": true,
          "key": {}
        }
      }
    }
  ]
}

In the current project, implement the chat_starMessageChat client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/starMessageChat. Marks a message with the star, so you can find it later in the starred messages list. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "option": true,
    "key": {}
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/chat/<INSTANCE_KEY>/starMessageChat. Auth: Bearer <YOUR_TOKEN>. Marks a message with the star, so you can find it later in the starred messages list. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "option": true,
    "key": {}
  }
}

Implement a TypeScript function called config_allConfigs that calls POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/allConfigs with Authorization Bearer <YOUR_TOKEN>. Applies the full set of instance settings in a single call: token, block list, accepted webhooks, and message notifications. Since it is a closed package, send everything that should apply, not just what changed. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "token": "token123456",
    "blockList": [
      "+status@broadcast"
    ],
    "acceptWebhook": [
      ""
    ],
    "acceptSecondaryWebhook": [
      ""
    ],
    "messagesAck": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the config.allConfigs integration in a Node.js service. Applies the full set of instance settings in a single call: token, block list, accepted webhooks, and message notifications. Since it is a closed package, send everything that should apply, not just what changed."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/allConfigs",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "token": "token123456",
          "blockList": [
            "+status@broadcast"
          ],
          "acceptWebhook": [
            ""
          ],
          "acceptSecondaryWebhook": [
            ""
          ],
          "messagesAck": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the config_allConfigs client in TypeScript for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/allConfigs. Applies the full set of instance settings in a single call: token, block list, accepted webhooks, and message notifications. Since it is a closed package, send everything that should apply, not just what changed. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "token": "token123456",
    "blockList": [
      "+status@broadcast"
    ],
    "acceptWebhook": [
      ""
    ],
    "acceptSecondaryWebhook": [
      ""
    ],
    "messagesAck": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/allConfigs. Auth: Bearer <YOUR_TOKEN>. Applies the full set of instance settings in a single call: token, block list, accepted webhooks, and message notifications. Since it is a closed package, send everything that should apply, not just what changed. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "token": "token123456",
    "blockList": [
      "+status@broadcast"
    ],
    "acceptWebhook": [
      ""
    ],
    "acceptSecondaryWebhook": [
      ""
    ],
    "messagesAck": [
      ""
    ]
  }
}

Implement a TypeScript function called config_configAcceptWebhooks that calls POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configAcceptWebhooks with Authorization Bearer <YOUR_TOKEN>. Controls the delivery of instance events to the configured webhook. Send the desired setting in the body; the "View instance settings" response shows how it ended up. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "acceptWebhook": [
      ""
    ],
    "acceptSecondaryWebhook": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the config.configAcceptWebhooks integration in a Node.js service. Controls the delivery of instance events to the configured webhook. Send the desired setting in the body; the \"View instance settings\" response shows how it ended up."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configAcceptWebhooks",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "acceptWebhook": [
            ""
          ],
          "acceptSecondaryWebhook": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the config_configAcceptWebhooks client in TypeScript for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configAcceptWebhooks. Controls the delivery of instance events to the configured webhook. Send the desired setting in the body; the "View instance settings" response shows how it ended up. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "acceptWebhook": [
      ""
    ],
    "acceptSecondaryWebhook": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configAcceptWebhooks. Auth: Bearer <YOUR_TOKEN>. Controls the delivery of instance events to the configured webhook. Send the desired setting in the body; the "View instance settings" response shows how it ended up. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "acceptWebhook": [
      ""
    ],
    "acceptSecondaryWebhook": [
      ""
    ]
  }
}

Implement a TypeScript function called config_configBlockList that calls POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configBlockList with Authorization Bearer <YOUR_TOKEN>. Sets which senders the instance should ignore. This is what prevents your automation from processing the status updates that arrive through WhatsApp, for example. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "blockList": [
      "+status@broadcast"
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the config.configBlockList integration in a Node.js service. Sets which senders the instance should ignore. This is what prevents your automation from processing the status updates that arrive through WhatsApp, for example."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configBlockList",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "blockList": [
            "+status@broadcast"
          ]
        }
      }
    }
  ]
}

In the current project, implement the config_configBlockList client in TypeScript for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configBlockList. Sets which senders the instance should ignore. This is what prevents your automation from processing the status updates that arrive through WhatsApp, for example. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "blockList": [
      "+status@broadcast"
    ]
  }
}

Create a TypeScript function for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configBlockList. Auth: Bearer <YOUR_TOKEN>. Sets which senders the instance should ignore. This is what prevents your automation from processing the status updates that arrive through WhatsApp, for example. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "blockList": [
      "+status@broadcast"
    ]
  }
}

Implement a TypeScript function called config_configMessagesAck that calls POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configMessagesAck with Authorization Bearer <YOUR_TOKEN>. Sets which message confirmations - sent, delivered, read - the instance notifies to your webhook. Turning all of them on greatly increases the number of calls your system receives. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "messagesAck": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the config.configMessagesAck integration in a Node.js service. Sets which message confirmations - sent, delivered, read - the instance notifies to your webhook. Turning all of them on greatly increases the number of calls your system receives."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configMessagesAck",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "messagesAck": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the config_configMessagesAck client in TypeScript for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configMessagesAck. Sets which message confirmations - sent, delivered, read - the instance notifies to your webhook. Turning all of them on greatly increases the number of calls your system receives. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "messagesAck": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configMessagesAck. Auth: Bearer <YOUR_TOKEN>. Sets which message confirmations - sent, delivered, read - the instance notifies to your webhook. Turning all of them on greatly increases the number of calls your system receives. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "messagesAck": [
      ""
    ]
  }
}

Implement a TypeScript function called config_configToken that calls POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configToken with Authorization Bearer <YOUR_TOKEN>. Stores the token used to authenticate calls to this instance. Since it is what authorizes every request, any integration still using the old value gets rejected - update your systems along with it. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "token": "token123456"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the config.configToken integration in a Node.js service. Stores the token used to authenticate calls to this instance. Since it is what authorizes every request, any integration still using the old value gets rejected - update your systems along with it."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configToken",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "token": "token123456"
        }
      }
    }
  ]
}

In the current project, implement the config_configToken client in TypeScript for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configToken. Stores the token used to authenticate calls to this instance. Since it is what authorizes every request, any integration still using the old value gets rejected - update your systems along with it. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "token": "token123456"
  }
}

Create a TypeScript function for POST https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>/configToken. Auth: Bearer <YOUR_TOKEN>. Stores the token used to authenticate calls to this instance. Since it is what authorizes every request, any integration still using the old value gets rejected - update your systems along with it. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "token": "token123456"
  }
}

Implement a TypeScript function called config_instance_key that calls GET https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Brings all the current instance settings in one response: token, block list, accepted webhooks, and message notifications. Good to check what is on before changing anything. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the config.instance_key integration in a Node.js service. Brings all the current instance settings in one response: token, block list, accepted webhooks, and message notifications. Good to check what is on before changing anything."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the config_instance_key client in TypeScript for GET https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>. Brings all the current instance settings in one response: token, block list, accepted webhooks, and message notifications. Good to check what is on before changing anything. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apinocode01.megaapi.com.br/rest/config/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Brings all the current instance settings in one response: token, block list, accepted webhooks, and message notifications. Good to check what is on before changing anything. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_addParticipants that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/addParticipants with Authorization Bearer <YOUR_TOKEN>. Adds one or more numbers to the group. Whoever set their privacy to avoid being added by strangers gets only an invite instead of joining directly. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.addParticipants integration in a Node.js service. Adds one or more numbers to the group. Whoever set their privacy to avoid being added by strangers gets only an invite instead of joining directly."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/addParticipants",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "group_data": {
          "jid": "<VALOR>",
          "participants": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the group_addParticipants client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/addParticipants. Adds one or more numbers to the group. Whoever set their privacy to avoid being added by strangers gets only an invite instead of joining directly. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/addParticipants. Auth: Bearer <YOUR_TOKEN>. Adds one or more numbers to the group. Whoever set their privacy to avoid being added by strangers gets only an invite instead of joining directly. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Implement a TypeScript function called group_adminGroups that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroups with Authorization Bearer <YOUR_TOKEN>. Returns only the groups where the connected number is an administrator - the only ones where it can add or remove participants and change settings. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.adminGroups integration in a Node.js service. Returns only the groups where the connected number is an administrator - the only ones where it can add or remove participants and change settings."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroups",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_adminGroups client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroups. Returns only the groups where the connected number is an administrator - the only ones where it can add or remove participants and change settings. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroups. Auth: Bearer <YOUR_TOKEN>. Returns only the groups where the connected number is an administrator - the only ones where it can add or remove participants and change settings. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_adminGroupsWithParticipants that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroupsWithParticipants with Authorization Bearer <YOUR_TOKEN>. The same list of groups where you are admin, already with every member of each group. The response gets much bigger, so only use it when you really need the participants. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.adminGroupsWithParticipants integration in a Node.js service. The same list of groups where you are admin, already with every member of each group. The response gets much bigger, so only use it when you really need the participants."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroupsWithParticipants",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_adminGroupsWithParticipants client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroupsWithParticipants. The same list of groups where you are admin, already with every member of each group. The response gets much bigger, so only use it when you really need the participants. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/adminGroupsWithParticipants. Auth: Bearer <YOUR_TOKEN>. The same list of groups where you are admin, already with every member of each group. The response gets much bigger, so only use it when you really need the participants. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_create that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/create with Authorization Bearer <YOUR_TOKEN>. Creates a new group with the given name and participants. The connected number joins as the group's administrator. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "group_data": {
    "group_name": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.create integration in a Node.js service. Creates a new group with the given name and participants. The connected number joins as the group's administrator."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/create",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "group_data": {
          "group_name": "<VALOR>",
          "participants": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the group_create client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/create. Creates a new group with the given name and participants. The connected number joins as the group's administrator. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "group_data": {
    "group_name": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/create. Auth: Bearer <YOUR_TOKEN>. Creates a new group with the given name and participants. The connected number joins as the group's administrator. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "group_data": {
    "group_name": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Implement a TypeScript function called group_demoteParticipants that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/demoteParticipants with Authorization Bearer <YOUR_TOKEN>. Takes away the admin power from a participant, who stays in the group as a regular member. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.demoteParticipants integration in a Node.js service. Takes away the admin power from a participant, who stays in the group as a regular member."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/demoteParticipants",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "group_data": {
          "jid": "<VALOR>",
          "participants": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the group_demoteParticipants client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/demoteParticipants. Takes away the admin power from a participant, who stays in the group as a regular member. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/demoteParticipants. Auth: Bearer <YOUR_TOKEN>. Takes away the admin power from a participant, who stays in the group as a regular member. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Implement a TypeScript function called group_group that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/group?jid=<VALOR> with Authorization Bearer <YOUR_TOKEN>. Brings the full information of a group: name, description, who created it, participants, and settings. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.group integration in a Node.js service. Brings the full information of a group: name, description, who created it, participants, and settings."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/group?jid=<VALOR>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_group client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/group?jid=<VALOR>. Brings the full information of a group: name, description, who created it, participants, and settings. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/group?jid=<VALOR>. Auth: Bearer <YOUR_TOKEN>. Brings the full information of a group: name, description, who created it, participants, and settings. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_groupAcceptInviteCode that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupAcceptInviteCode?code=<VALOR> with Authorization Bearer <YOUR_TOKEN>. Makes the connected number join a group using an invite link's code. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.groupAcceptInviteCode integration in a Node.js service. Makes the connected number join a group using an invite link's code."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupAcceptInviteCode?code=<VALOR>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_groupAcceptInviteCode client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupAcceptInviteCode?code=<VALOR>. Makes the connected number join a group using an invite link's code. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupAcceptInviteCode?code=<VALOR>. Auth: Bearer <YOUR_TOKEN>. Makes the connected number join a group using an invite link's code. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_groupInviteCode that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupInviteCode?jid=<VALOR> with Authorization Bearer <YOUR_TOKEN>. Returns the invite link code of the group, the one shared so people can join. Anyone with that link can get in, so treat it as sensitive information. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.groupInviteCode integration in a Node.js service. Returns the invite link code of the group, the one shared so people can join. Anyone with that link can get in, so treat it as sensitive information."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupInviteCode?jid=<VALOR>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_groupInviteCode client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupInviteCode?jid=<VALOR>. Returns the invite link code of the group, the one shared so people can join. Anyone with that link can get in, so treat it as sensitive information. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupInviteCode?jid=<VALOR>. Auth: Bearer <YOUR_TOKEN>. Returns the invite link code of the group, the one shared so people can join. Anyone with that link can get in, so treat it as sensitive information. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_groupRequestParticipantsList that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsList?to=5511999998888 with Authorization Bearer <YOUR_TOKEN>. Shows who asked to join the group and is waiting for approval. Only makes sense on a group set to require admin approval. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.groupRequestParticipantsList integration in a Node.js service. Shows who asked to join the group and is waiting for approval. Only makes sense on a group set to require admin approval."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsList?to=5511999998888",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_groupRequestParticipantsList client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsList?to=5511999998888. Shows who asked to join the group and is waiting for approval. Only makes sense on a group set to require admin approval. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsList?to=5511999998888. Auth: Bearer <YOUR_TOKEN>. Shows who asked to join the group and is waiting for approval. Only makes sense on a group set to require admin approval. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_groupRequestParticipantsUpdate that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsUpdate with Authorization Bearer <YOUR_TOKEN>. Answers the join requests in the queue, approving or rejecting. Someone rejected is not let in and has to ask again. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "participants": [
      ""
    ],
    "action": "approve"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.groupRequestParticipantsUpdate integration in a Node.js service. Answers the join requests in the queue, approving or rejecting. Someone rejected is not let in and has to ask again."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsUpdate",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "participants": [
            ""
          ],
          "action": "approve"
        }
      }
    }
  ]
}

In the current project, implement the group_groupRequestParticipantsUpdate client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsUpdate. Answers the join requests in the queue, approving or rejecting. Someone rejected is not let in and has to ask again. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "participants": [
      ""
    ],
    "action": "approve"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRequestParticipantsUpdate. Auth: Bearer <YOUR_TOKEN>. Answers the join requests in the queue, approving or rejecting. Someone rejected is not let in and has to ask again. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "participants": [
      ""
    ],
    "action": "approve"
  }
}

Implement a TypeScript function called group_groupRevokeInviteCode that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRevokeInviteCode?jid=<VALOR> with Authorization Bearer <YOUR_TOKEN>. Invalidates the current invite link and generates another in its place. The old link stops working right away, forever: whoever had it saved can no longer get in. There is no going back nor recovering the previous code. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.groupRevokeInviteCode integration in a Node.js service. Invalidates the current invite link and generates another in its place. The old link stops working right away, forever: whoever had it saved can no longer get in. There is no going back nor recovering the previous code."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRevokeInviteCode?jid=<VALOR>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_groupRevokeInviteCode client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRevokeInviteCode?jid=<VALOR>. Invalidates the current invite link and generates another in its place. The old link stops working right away, forever: whoever had it saved can no longer get in. There is no going back nor recovering the previous code. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/groupRevokeInviteCode?jid=<VALOR>. Auth: Bearer <YOUR_TOKEN>. Invalidates the current invite link and generates another in its place. The old link stops working right away, forever: whoever had it saved can no longer get in. There is no going back nor recovering the previous code. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_instance_key that calls GET https://apibusiness1.megaapi.com.br/rest/group/list/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Lists every group and community the connected number is part of. This is where the group ID required by other endpoints comes from. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.instance_key integration in a Node.js service. Lists every group and community the connected number is part of. This is where the group ID required by other endpoints comes from."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/list/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_instance_key client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/list/<INSTANCE_KEY>. Lists every group and community the connected number is part of. This is where the group ID required by other endpoints comes from. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/list/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Lists every group and community the connected number is part of. This is where the group ID required by other endpoints comes from. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_inviteInfo that calls GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/inviteInfo?code=<VALOR> with Authorization Bearer <YOUR_TOKEN>. From an invite link's code, shows which group it belongs to before you join. Handy to check the group without committing. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.inviteInfo integration in a Node.js service. From an invite link's code, shows which group it belongs to before you join. Handy to check the group without committing."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/inviteInfo?code=<VALOR>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_inviteInfo client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/inviteInfo?code=<VALOR>. From an invite link's code, shows which group it belongs to before you join. Handy to check the group without committing. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/inviteInfo?code=<VALOR>. Auth: Bearer <YOUR_TOKEN>. From an invite link's code, shows which group it belongs to before you join. Handy to check the group without committing. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_leaveGroup that calls DELETE https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/leaveGroup?jid=<VALOR> with Authorization Bearer <YOUR_TOKEN>. Makes the connected number leave the group. No undo here: to come back, someone has to add it again or you need a valid invite link. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.leaveGroup integration in a Node.js service. Makes the connected number leave the group. No undo here: to come back, someone has to add it again or you need a valid invite link."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "DELETE",
      "url": "DELETE https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/leaveGroup?jid=<VALOR>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_leaveGroup client in TypeScript for DELETE https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/leaveGroup?jid=<VALOR>. Makes the connected number leave the group. No undo here: to come back, someone has to add it again or you need a valid invite link. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for DELETE https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/leaveGroup?jid=<VALOR>. Auth: Bearer <YOUR_TOKEN>. Makes the connected number leave the group. No undo here: to come back, someone has to add it again or you need a valid invite link. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_promoteParticipants that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/promoteParticipants with Authorization Bearer <YOUR_TOKEN>. Gives admin power to a participant: they can now add and remove people and change the group settings. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.promoteParticipants integration in a Node.js service. Gives admin power to a participant: they can now add and remove people and change the group settings."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/promoteParticipants",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "group_data": {
          "jid": "<VALOR>",
          "participants": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the group_promoteParticipants client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/promoteParticipants. Gives admin power to a participant: they can now add and remove people and change the group settings. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/promoteParticipants. Auth: Bearer <YOUR_TOKEN>. Gives admin power to a participant: they can now add and remove people and change the group settings. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Implement a TypeScript function called group_removeParticipants that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/removeParticipants with Authorization Bearer <YOUR_TOKEN>. Removes one or more participants from the group. The person leaves right away and only comes back if added again or joining via invite - the removal itself cannot be undone. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.removeParticipants integration in a Node.js service. Removes one or more participants from the group. The person leaves right away and only comes back if added again or joining via invite - the removal itself cannot be undone."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/removeParticipants",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "group_data": {
          "jid": "<VALOR>",
          "participants": [
            ""
          ]
        }
      }
    }
  ]
}

In the current project, implement the group_removeParticipants client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/removeParticipants. Removes one or more participants from the group. The person leaves right away and only comes back if added again or joining via invite - the removal itself cannot be undone. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/removeParticipants. Auth: Bearer <YOUR_TOKEN>. Removes one or more participants from the group. The person leaves right away and only comes back if added again or joining via invite - the removal itself cannot be undone. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "group_data": {
    "jid": "<VALOR>",
    "participants": [
      ""
    ]
  }
}

Implement a TypeScript function called group_sendLinkInviteGroup that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/sendLinkInviteGroup with Authorization Bearer <YOUR_TOKEN>. Sends the group invite link straight to a contact, as a WhatsApp message. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "textWithLink": "<VALOR>"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.sendLinkInviteGroup integration in a Node.js service. Sends the group invite link straight to a contact, as a WhatsApp message."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/sendLinkInviteGroup",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "textWithLink": "<VALOR>"
        }
      }
    }
  ]
}

In the current project, implement the group_sendLinkInviteGroup client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/sendLinkInviteGroup. Sends the group invite link straight to a contact, as a WhatsApp message. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "textWithLink": "<VALOR>"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/sendLinkInviteGroup. Auth: Bearer <YOUR_TOKEN>. Sends the group invite link straight to a contact, as a WhatsApp message. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "textWithLink": "<VALOR>"
  }
}

Implement a TypeScript function called group_setWhoCanChangeSettings that calls PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanChangeSettings?jid=<VALOR>&allowOnlyAdmins=false with Authorization Bearer <YOUR_TOKEN>. Chooses whether any participant can change the group's name, photo, and description, or whether that stays restricted to the admins. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.setWhoCanChangeSettings integration in a Node.js service. Chooses whether any participant can change the group's name, photo, and description, or whether that stays restricted to the admins."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "PUT",
      "url": "PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanChangeSettings?jid=<VALOR>&allowOnlyAdmins=false",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_setWhoCanChangeSettings client in TypeScript for PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanChangeSettings?jid=<VALOR>&allowOnlyAdmins=false. Chooses whether any participant can change the group's name, photo, and description, or whether that stays restricted to the admins. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanChangeSettings?jid=<VALOR>&allowOnlyAdmins=false. Auth: Bearer <YOUR_TOKEN>. Chooses whether any participant can change the group's name, photo, and description, or whether that stays restricted to the admins. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_setWhoCanSendMessage that calls PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanSendMessage?jid=<VALOR>&allowOnlyAdmins=false with Authorization Bearer <YOUR_TOKEN>. Makes the group open for everyone to talk or closes it to admins only. When closed, the other participants can only read. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.setWhoCanSendMessage integration in a Node.js service. Makes the group open for everyone to talk or closes it to admins only. When closed, the other participants can only read."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "PUT",
      "url": "PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanSendMessage?jid=<VALOR>&allowOnlyAdmins=false",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_setWhoCanSendMessage client in TypeScript for PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanSendMessage?jid=<VALOR>&allowOnlyAdmins=false. Makes the group open for everyone to talk or closes it to admins only. When closed, the other participants can only read. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for PUT https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/setWhoCanSendMessage?jid=<VALOR>&allowOnlyAdmins=false. Auth: Bearer <YOUR_TOKEN>. Makes the group open for everyone to talk or closes it to admins only. When closed, the other participants can only read. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_updateGroupDescription that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupDescription with Authorization Bearer <YOUR_TOKEN>. Changes the group's description text, the one shown in group info. The previous description is replaced. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "jid": "<VALOR>",
    "description": "<VALOR>"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.updateGroupDescription integration in a Node.js service. Changes the group's description text, the one shown in group info. The previous description is replaced."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupDescription",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "jid": "<VALOR>",
          "description": "<VALOR>"
        }
      }
    }
  ]
}

In the current project, implement the group_updateGroupDescription client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupDescription. Changes the group's description text, the one shown in group info. The previous description is replaced. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "jid": "<VALOR>",
    "description": "<VALOR>"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupDescription. Auth: Bearer <YOUR_TOKEN>. Changes the group's description text, the one shown in group info. The previous description is replaced. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "jid": "<VALOR>",
    "description": "<VALOR>"
  }
}

Implement a TypeScript function called group_updateGroupPicture that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPicture?to=5511999998888 with Authorization Bearer <YOUR_TOKEN>. Swaps the group image by sending the photo file. The previous image is replaced and not kept. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.updateGroupPicture integration in a Node.js service. Swaps the group image by sending the photo file. The previous image is replaced and not kept."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPicture?to=5511999998888",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the group_updateGroupPicture client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPicture?to=5511999998888. Swaps the group image by sending the photo file. The previous image is replaced and not kept. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPicture?to=5511999998888. Auth: Bearer <YOUR_TOKEN>. Swaps the group image by sending the photo file. The previous image is replaced and not kept. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called group_updateGroupPictureBase64 that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureBase64 with Authorization Bearer <YOUR_TOKEN>. Swaps the group image by sending the photo itself converted to text (Base64), without hosting anything anywhere. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "base64": "<VALOR>"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.updateGroupPictureBase64 integration in a Node.js service. Swaps the group image by sending the photo itself converted to text (Base64), without hosting anything anywhere."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureBase64",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "base64": "<VALOR>"
        }
      }
    }
  ]
}

In the current project, implement the group_updateGroupPictureBase64 client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureBase64. Swaps the group image by sending the photo itself converted to text (Base64), without hosting anything anywhere. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "base64": "<VALOR>"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureBase64. Auth: Bearer <YOUR_TOKEN>. Swaps the group image by sending the photo itself converted to text (Base64), without hosting anything anywhere. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "base64": "<VALOR>"
  }
}

Implement a TypeScript function called group_updateGroupPictureUrl that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureUrl with Authorization Bearer <YOUR_TOKEN>. Swaps the group image using the address of a photo published on the internet. The link must open directly on the image, with no password or login page. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "to": "5511999998888",
    "url": "https://seu-dominio.com/webhook"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.updateGroupPictureUrl integration in a Node.js service. Swaps the group image using the address of a photo published on the internet. The link must open directly on the image, with no password or login page."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureUrl",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "to": "5511999998888",
          "url": "https://seu-dominio.com/webhook"
        }
      }
    }
  ]
}

In the current project, implement the group_updateGroupPictureUrl client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureUrl. Swaps the group image using the address of a photo published on the internet. The link must open directly on the image, with no password or login page. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "to": "5511999998888",
    "url": "https://seu-dominio.com/webhook"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupPictureUrl. Auth: Bearer <YOUR_TOKEN>. Swaps the group image using the address of a photo published on the internet. The link must open directly on the image, with no password or login page. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "to": "5511999998888",
    "url": "https://seu-dominio.com/webhook"
  }
}

Implement a TypeScript function called group_updateGroupSubject that calls POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupSubject with Authorization Bearer <YOUR_TOKEN>. Changes the group name. Usually only admins can, and the change shows for all participants. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageData": {
    "jid": "<VALOR>",
    "subject": "<VALOR>"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the group.updateGroupSubject integration in a Node.js service. Changes the group name. Usually only admins can, and the change shows for all participants."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupSubject",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageData": {
          "jid": "<VALOR>",
          "subject": "<VALOR>"
        }
      }
    }
  ]
}

In the current project, implement the group_updateGroupSubject client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupSubject. Changes the group name. Usually only admins can, and the change shows for all participants. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageData": {
    "jid": "<VALOR>",
    "subject": "<VALOR>"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/group/<INSTANCE_KEY>/updateGroupSubject. Auth: Bearer <YOUR_TOKEN>. Changes the group name. Usually only admins can, and the change shows for all participants. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageData": {
    "jid": "<VALOR>",
    "subject": "<VALOR>"
  }
}

Implement a TypeScript function called instance_get_instance_key that calls GET https://apibusiness1.megaapi.com.br/rest/instance/timeLock/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Fetches the sending limits configured for the instance: the wait time before you can start a conversation with a new contact and the cap on messages per conversation. Helps explain why a batch of sends started being blocked. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the instance.get.instance_key integration in a Node.js service. Fetches the sending limits configured for the instance: the wait time before you can start a conversation with a new contact and the cap on messages per conversation. Helps explain why a batch of sends started being blocked."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/instance/timeLock/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the instance_get_instance_key client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/instance/timeLock/<INSTANCE_KEY>. Fetches the sending limits configured for the instance: the wait time before you can start a conversation with a new contact and the cap on messages per conversation. Helps explain why a batch of sends started being blocked. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/instance/timeLock/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Fetches the sending limits configured for the instance: the wait time before you can start a conversation with a new contact and the cap on messages per conversation. Helps explain why a batch of sends started being blocked. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called instance_instance_key that calls GET https://apibusiness1.megaapi.com.br/rest/instance/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Shows whether the instance is connected to WhatsApp and which phone number is paired with it. Check before sending any message: if the instance is disconnected, all other calls fail. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the instance.instance_key integration in a Node.js service. Shows whether the instance is connected to WhatsApp and which phone number is paired with it. Check before sending any message: if the instance is disconnected, all other calls fail."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/instance/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the instance_instance_key client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/instance/<INSTANCE_KEY>. Shows whether the instance is connected to WhatsApp and which phone number is paired with it. Check before sending any message: if the instance is disconnected, all other calls fail. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/instance/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Shows whether the instance is connected to WhatsApp and which phone number is paired with it. Check before sending any message: if the instance is disconnected, all other calls fail. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called instance_instance_key-10 that calls POST https://apibusiness1.megaapi.com.br/rest/instance/labels/editLabel/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Changes the name or color of an existing label, and this is also where you delete one. Deletion is final: the label disappears from every conversation it was on and cannot be undone. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "data": {
    "labelId": "<VALOR>",
    "name": "<VALOR>",
    "color": 1,
    "deleted": false
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the instance.instance_key-10 integration in a Node.js service. Changes the name or color of an existing label, and this is also where you delete one. Deletion is final: the label disappears from every conversation it was on and cannot be undone."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/instance/labels/editLabel/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "data": {
          "labelId": "<VALOR>",
          "name": "<VALOR>",
          "color": 1,
          "deleted": false
        }
      }
    }
  ]
}

In the current project, implement the instance_instance_key-10 client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/instance/labels/editLabel/<INSTANCE_KEY>. Changes the name or color of an existing label, and this is also where you delete one. Deletion is final: the label disappears from every conversation it was on and cannot be undone. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "data": {
    "labelId": "<VALOR>",
    "name": "<VALOR>",
    "color": 1,
    "deleted": false
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/instance/labels/editLabel/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Changes the name or color of an existing label, and this is also where you delete one. Deletion is final: the label disappears from every conversation it was on and cannot be undone. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "data": {
    "labelId": "<VALOR>",
    "name": "<VALOR>",
    "color": 1,
    "deleted": false
  }
}

Implement a TypeScript function called instance_instance_key-11 that calls GET https://apibusiness1.megaapi.com.br/rest/instance/labels/getChatLabels/<INSTANCE_KEY>[email protected] with Authorization Bearer <YOUR_TOKEN>. Shows which labels are applied to a specific conversation. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: no JSON body

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the instance.instance_key-11 integration in a Node.js service. Shows which labels are applied to a specific conversation."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "GET",
      "url": "GET https://apibusiness1.megaapi.com.br/rest/instance/labels/getChatLabels/<INSTANCE_KEY>[email protected]",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": null
    }
  ]
}

In the current project, implement the instance_instance_key-11 client in TypeScript for GET https://apibusiness1.megaapi.com.br/rest/instance/labels/getChatLabels/<INSTANCE_KEY>[email protected]. Shows which labels are applied to a specific conversation. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: no JSON body

Create a TypeScript function for GET https://apibusiness1.megaapi.com.br/rest/instance/labels/getChatLabels/<INSTANCE_KEY>[email protected]. Auth: Bearer <YOUR_TOKEN>. Shows which labels are applied to a specific conversation. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: no JSON body

Implement a TypeScript function called instance_instance_key-12 that calls POST https://apibusiness1.megaapi.com.br/rest/instance/labels/setChatLabels/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Attaches or removes labels on a conversation. You specify the conversation, which labels, and what to do with them. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "data": {
    "chatId": "[email protected]",
    "messageId": "<VALOR>",
    "labelId": [
      ""
    ],
    "action": "add"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the instance.instance_key-12 integration in a Node.js service. Attaches or removes labels on a conversation. You specify the conversation, which labels, and what to do with them."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/instance/labels/setChatLabels/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "data": {
          "chatId": "[email protected]",
          "messageId": "<VALOR>",
          "labelId": [
            ""
          ],
          "action": "add"
        }
      }
    }
  ]
}

In the current project, implement the instance_instance_key-12 client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/instance/labels/setChatLabels/<INSTANCE_KEY>. Attaches or removes labels on a conversation. You specify the conversation, which labels, and what to do with them. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "data": {
    "chatId": "[email protected]",
    "messageId": "<VALOR>",
    "labelId": [
      ""
    ],
    "action": "add"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/instance/labels/setChatLabels/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Attaches or removes labels on a conversation. You specify the conversation, which labels, and what to do with them. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "data": {
    "chatId": "[email protected]",
    "messageId": "<VALOR>",
    "labelId": [
      ""
    ],
    "action": "add"
  }
}

Implement a TypeScript function called instance_instance_key-13 that calls POST https://apibusiness1.megaapi.com.br/rest/instance/downloadMediaMessage/<INSTANCE_KEY> with Authorization Bearer <YOUR_TOKEN>. Retrieves the file - image, audio, video, or document - from a message that went through the instance. It only works with the media's technical data in hand, which arrives along with the message notification on your webhook. Use the documented parameters and handle non-2xx HTTP responses without exposing the token. Example body: {
  "messageKeys": {
    "mediaKey": "<VALOR>",
    "directPath": "<VALOR>",
    "url": "https://seu-dominio.com/webhook",
    "mimetype": "<VALOR>",
    "messageType": "<VALOR>"
  }
}

{
  "model": "grok-4",
  "input": [
    {
      "role": "user",
      "content": "Implement the instance.instance_key-13 integration in a Node.js service. Retrieves the file - image, audio, video, or document - from a message that went through the instance. It only works with the media's technical data in hand, which arrives along with the message notification on your webhook."
    }
  ],
  "tools": [
    {
      "type": "http",
      "method": "POST",
      "url": "POST https://apibusiness1.megaapi.com.br/rest/instance/downloadMediaMessage/<INSTANCE_KEY>",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      },
      "json_body": {
        "messageKeys": {
          "mediaKey": "<VALOR>",
          "directPath": "<VALOR>",
          "url": "https://seu-dominio.com/webhook",
          "mimetype": "<VALOR>",
          "messageType": "<VALOR>"
        }
      }
    }
  ]
}

In the current project, implement the instance_instance_key-13 client in TypeScript for POST https://apibusiness1.megaapi.com.br/rest/instance/downloadMediaMessage/<INSTANCE_KEY>. Retrieves the file - image, audio, video, or document - from a message that went through the instance. It only works with the media's technical data in hand, which arrives along with the message notification on your webhook. Keep the call isolated, typed, and testable; read instance_key and the remaining parameters from configuration, never hardcode credentials. Payload: {
  "messageKeys": {
    "mediaKey": "<VALOR>",
    "directPath": "<VALOR>",
    "url": "https://seu-dominio.com/webhook",
    "mimetype": "<VALOR>",
    "messageType": "<VALOR>"
  }
}

Create a TypeScript function for POST https://apibusiness1.megaapi.com.br/rest/instance/downloadMediaMessage/<INSTANCE_KEY>. Auth: Bearer <YOUR_TOKEN>. Retrieves the file - image, audio, video, or document - from a message that went through the instance. It only works with the media's technical data in hand, which arrives along with the message notification on your webhook. Validate the HTTP status, serialize the payload below, and return typed JSON. Payload: {
  "messageKeys": {
    "mediaKey": "<VALOR>",
    "directPath": "<VALOR>",
    "url": "https://seu-dominio.com/webhook",
    "mimetype": "<VALOR>",
    "messageType": "<VALOR>"
  }
}