x-provenance:
generated: '2026-08-13'
method: searched
source: https://apidocs.hootsuite.com/docs/api/inbox/openapi/openapi.yaml
note: >-
Verbatim first-party OpenAPI 3.1 for the Hootsuite Inbox 2.0 API (formerly Sparkcentral),
linked as service-desc for anchor https://platform.hootsuite.com/inbox/v1/ in Hootsuite's
RFC 9727 API catalog at https://www.hootsuite.com/.well-known/api-catalog.
ownership: >-
servers[] https://platform.hootsuite.com, contact dev.support@hootsuite.com, license
"Hootsuite Developer Terms and API License Agreement" - Hootsuite's own contract.
openapi: 3.1.0
info:
title: Inbox 2.0 API Reference
description: Inbox 2.0 API Reference
version: v1
x-logo:
url: static/hootsuite-logo.png
contact:
email: dev.support@hootsuite.com
license:
name: Hootsuite Developer Terms and API License Agreement
url: https://hootsuite.com/legal/dev-api-terms
servers:
- url: https://platform.hootsuite.com
description: Inbox 2.0 production server
x-tagGroups:
- name: General
tags:
- rest-api-authentication
- name: CRM API
tags:
- crm_introduction
- crm_webhooks
- crm_rest_api
- name: Virtual Agent API
tags:
- vai_introduction
- vai_webhooks
- vai_rest_api
- name: Real-time metrics API
tags:
- real_time_metrics_introduction
- real_time_metrics_rest_api
- name: User Presence API
tags:
- user_presence_introduction
- user_presence_rest_api
- name: Queue API
tags:
- queue_introduction
- queue_rest_api
- name: Proactive messaging API
tags:
- proactive_messaging_introduction
- proactive_messaging_rest_api
- name: Messenger SDK
tags:
- messenger_introduction
- messenger_web_sdk
tags:
- name: rest-api-authentication
x-displayName: REST API authentication
description: |
Follow the steps below to make an authenticated API request.
# 1. Request client credentials
### Step 1: Create your OAuth 2.0 app
Follow [these steps](https://developer.hootsuite.com/docs/getting-started-with-the-rest-api) to set up your app and retrieve your client credentials (`client_id` and `client_secret`):
### Step 2: Retrieve the appId of your newly created app
1. Go to your [Hootsuite Developer Apps](https://hootsuite.com/developers/my-apps) dashboard.
2. Select `edit` for your newly created app.
3. You can find the appId in the `appId` parameter of the browser URL. Ex: `https://hootsuite.com/developers/my-apps/app-directory/app/edit?appId=XXXXXX`
### Step 3: Retrieve the organization ID of your Hootsuite organization
1. Sign in into your [Hootsuite account](https://hootsuite.com).
2. Select `My profile > Manage accounts and teams`.
3. Select `Teams` for your organization.
5. You can find the organization ID in the id query parameter in your browser's address bar.
```
https://hootsuite.com/dashboard#/organizations/teams/?id=<your_organization_id>
```
### Step 4: Request to link your organization to your app
1. Add a member to your org that is not a paying member
2. Make sure they have at least admin permission level
3. Send an email to the Development Support Team to link your organization to your app:
- To: `dev.support@hootsuite.com`
- Include:
- the `appId` you retrieved in *Step 2*
- the `organization ID` you retrieved in *Step 3*
- the `member ID` of the non-paying admin member
4. Wait for the Development Support Team to link your app to your organization.
# 2. Generate an access token
When the developer app is correctly set up, you can use your `client_id` and `client_secret` to retrieve an `access_token` to make authorized API requests.
When the `access_token` expires, use the [/oauth2/token](#operation/oauthToken) to generate a new token.
This endpoint requires that you pass in your client credentials (`client_id` and `client_secret`) using the HTTP Basic authentication scheme as described in the [OAuth 2.0 specification](https://datatracker.ietf.org/doc/html/rfc6749#section-2.3.1).
Including your client credentials in the request-body is not supported.
When the `access_token` expires, the API returns a 401 unauthorized. The client can automate this by generating a new access
token and replaying the failed request with the fresh access token, as described in the following section.
# 3. Include the access token as a bearer token Authorization header
Add the bearer token in the Authorization header
```text
Authorization: Bearer <your_access_token>
```
Example request with token
```shell
$ curl -X GET https://platform.hootsuite.com/inbox/v1/reporting/metrics/agent-availability \
-H 'Authorization: Bearer oZy8FDUHEiZ0mh0j4rUwOT9t5yHouTzBDsn-x_GROB0.rz-pMQzh-1F6VIGwnJZMBwH3SRwDfEHE4CRi-AClpcg'
```
- name: crm_introduction
x-displayName: Introduction
description: |
Inbox 2.0 CRM integration allows you to pull customer contact data from CRMs or other internal business applications into Inbox 2.0. To integrate your CRM with Inbox 2.0, you need to provide an HTTPS endpoint for lookups. You can also provide an optional HTTPS endpoint for handling write back requests and an HTTP endpoint for Inbox 2.0 to send notifications from our application to your CRM.
- name: crm_webhooks
x-displayName: Webhooks
description: |
### Webhook authentication
When receiving data from Inbox 2.0, we provide two authentication options. Both mechanisms are in place so that you can make sure the request originates from Inbox 2.0.
#### Shared secret
If you choose the shared secret authentication method, a secret will be generated for you. This secret allows you to calculate the signature to verify that the call originated from Inbox 2.0. With this mechanism, every single request from Inbox 2.0 contains the `X-Hootsuite-Signature` header. Here's an example of a request:
```shell
curl -X POST https://my-webhook-url \
-H 'content-type : application/json' \
-H 'accept: application/json' \
-H 'X-Hootsuite-Signature: e6f93239a06e46ae9654fc9ad2fb4e1cc4eb213830a0d94e711570c047e43c57' \
-d '{
"version": 2,
"contactProfile": {
"id": "a7a20053-9c54-11eb-a89f-47717a44c639"
},
"contactAttributes": [
{"attribute": "email", "value": "fj@example.com"}
]
}'
```
The signature is generated using the `HMAC-SHA256` algorithm with the shared secret and the request body.
Use your secret to calculate the signature and compare with the given signature.
Both the secret key you received and the signature are encoded as hexadecimal strings.
Make sure to convert the shared secret from its hexadecimal representation to its binary format before using it.
Most languages come with libraries out of the box to verify this signature.
For example, here's how it looks in JavaScript:
```javascript
const crypto = require("crypto");
const secret = "..."; // do not share!
const expectedSignature = request.headers["X-Hootsuite-Signature"];
const actualSignature = crypto
.createHmac("sha256", Buffer.from(secret, "hex"))
.update(request.body, "utf-8")
.digest("hex");
if (actualSignature !== expectedSignature) {
throw new createError.Unauthorized("X-Hootsuite-Signature wrong");
}
console.log(JSON.parse(request.body).email);
```
#### OAuth
If your endpoints support OAuth2, you can configure your client credentials, a Token URL, and, optionally, a Scope in Inbox 2.0.
We use the OAuth2 Client Credentials flow to authenticate against your CRM. The Token URL is the endpoint where we can authenticate with these credentials and retrieve an access token. To do the actual lookup, write back, or notification requests, we use the token in the Authorization Header to authenticate.
- name: crm_rest_api
x-displayName: REST API
description: |
If you want to update contact attributes asynchronously, you'll need to call the Contact API.
When calling the Contact API, the client needs to be authenticated.
The [REST API authentication](#tag/rest-api-authentication) section contains more details on how to authenticate your client.
- name: vai_introduction
x-displayName: Introduction
description: |
Inbox 2.0 virtual agents allow enterprises to add bots to the platform as if they were real agents. They can respond
to incoming messages, resolve conversations, apply topics, and set contact attributes. Instead of limiting the bot
platforms that can be integrated, we provide a generic API that you can use to integrate with any platform.
To integrate your favorite bot platform with Inbox 2.0, you will need to provide an HTTPS endpoint. Inbox 2.0
calls this endpoint every time a conversation is assigned to your virtual agent and whenever the contact sends a new
message. If you're using a synchronous bot platform, you can immediately answer this request with the response. If
you're using an asynchronous bot platform, you can also send a POST request to Inbox 2.0 to send a reply to a
conversation.
# Two types of virtual agents
### Inception
An inception virtual agent automatically picks up private conversations that start in the channels it has access to. If
an inception virtual agent needs a human agent, it will place the conversation in the New queue so that any agent can
respond. The inception virtual agent can also resolve a conversation if no human assistance is required.
Because an inception virtual agent automatically picks up conversations in the channel it has access to, you cannot
create multiple inception virtual agents that have access to the same channel.
### Delegation
A delegation virtual agent will not automatically pick up conversations. Instead, a human agent can give a conversation
to a delegation virtual agent at any point in the conversation. The delegation virtual agent will take over at this
point. The handoff rule determines what should happen if a delegation virtual agent needs a human agent. If "New queue"
is selected, the conversation moves to the New queue to be picked up by any agent. If "previous agent" is selected, the
delegation virtual agent assigns the conversation back to the previous human agent.
Multiple delegation virtual agents can have access to the same channel. A human agent must specifically select the
virtual agent to take over the conversation.
# Add a virtual agent
To add a virtual agent:
1. Go to `Admin settings`, expand `Virtual agents`, select `Custom virtual agents`, and then
select `Add custom virtual agent`.
2. Enter a name for the virtual agent. This name will appear in Inbox 2.0 as "{Name} VA".
3. Specify whether you want your virtual agent to be activated as an `Inception` agent or a `Delegation` agent.
4. The Webhook URL must be provided to properly send conversation information to your virtual agent (see the Webhooks
section for more information).
5. Fill out the remaining fields as you like, including any handoff rules you want to add.
6. Select `Save`.
7. Scroll down to the `Channel access` section, and use the toggles to select a channel or channels where this virtual
agent can be accessed.
### Timeout virtual agent
You can configure two types of contact rules for virtual agents:
- Timeout virtual agent - Determines when a handoff (to the New or Resolved queue) will occur if the auto responder stops responding for any reason. The maximum you can set is 1 hour.
- Timeout contact - Determines when a handoff will occur if the contact stops responding. The maximum you can set is 23 hours.
#### Error handling
If the virtual agent connection times out, an error occurs, or if the contact times out, you can do the following:
- Mark the conversation as New or Resolved
- Automatically apply a topic
- If the conversation is marked as Resolved, automatically send a standard reply to the customer
### Edit or delete a virtual agent
To edit a virtual agent, on the `Custom virtual agents` page, select the `Edit` icon. To delete a virtual agent, select
the `Trash` icon.
### View the secret for a virtual agent
On the `Custom virtual agents` page, select the `Edit` icon next to the virtual agent. You can view or copy the shared
secret generated for this virtual agent on the `Edit custom virtual agent` page. See the Securing webhooks section for
more information.
- name: vai_webhooks
x-displayName: Webhooks
description: |
### Webhook authentication
When setting up a virtual agent, you received a secret key that you can use to verify whether an incoming webhook
request really comes from Inbox 2.0 without alterations. In the request headers of each webhook call is the
`X-Hootsuite-Signature`. This contains an `HMAC-SHA256` signature based on the body of the request.
Both the secret key you received and the signature are encoded as hexadecimal strings.
Most languages come with libraries out of the box to verify this signature.
Here is some sample code to verify it in Node.js:
```javascript
const secret = "..."; // do not share!
const expectedSignature = request.headers["X-Hootsuite-Signature"];
const actualSignature = crypto
.createHmac("sha256", Buffer.from(secret, "hex"))
.update(request.body, "utf-8")
.digest("hex");
if (actualSignature !== expectedSignature) {
throw new createError.Unauthorized("X-Hootsuite-Signature wrong");
}
```
Note: Make sure you calculate the signature off the body as is, before you deserialize it from JSON.
During the calculation of the signature, all white space is considered significant.
As part of the request body, you will find a timestamp. This is the time a request was sent. To prevent replay attacks,
we recommend verifying that this timestamp is no older than 5 minutes:
```javascript
if (moment(JSON.parse(request.body).timestamp).isBefore(moment().subtract(5, "minutes"))) {
throw new createError.Unauthorized("Request too old");
}
```
### Events
When a conversation is assigned to the virtual agent you registered in the previous section, Inbox 2.0 sends you an event via the URL you configured.
Three important events are sent:
- `CONVERSATION_STARTED`
- `CONVERSATION_DELEGATED`
- `INBOUND_MESSAGE_RECEIVED`
### Common fields
All events have certain common fields:
- type: A string that defines what kind of event occurred (currently `CONVERSATION_STARTED`, `CONVERSATION_DELEGATED`, or `INBOUND_MESSAGE_RECEIVED`).
New events can be added in the future. Avoid responding with an error to unknown
values; instead, ignore them. Depending on this type, the structure of data will be different.
- version: A number designating the version of the type of request. Currently, the version is always 1. Versions will be
used in the future for introducing non-backward-compatible changes.
- idempotencyKey: A string that uniquely identifies each event. When a timeout occurs when sending you the event, (or we
receive an error response), we will retry the event. This key can help you to ensure that a request is processed only
once.
- timestamp: The timestamp when we sent the request. This is used to counter possible replay attacks.
- data: An object that contains structured data for the specific type. For example, an `INBOUND_MESSAGE_RECEIVED` type
event has fields such as `conversationId` and `message`. Fields may be added in the future.
### Requirements
To provide a good customer experience, some non-functional requirements are imposed on the webhook. When a webhook is
sent, you have 10 seconds to respond with a 200 OK. If a timeout occurs, we will retry 3 times using an exponential
backoff (up to 2 seconds). If the failures persisted during the retries, the assigned conversation will be handed over
to a human agent by placing it in the New queue.
When the contact sends a message through Inbox 2.0, by default we expect the virtual agent to reply to that message
within 5 minutes (using either the response to the webhook call or the REST API). You can configure the timeout on the
settings page for your virtual agent (Timeout virtual agent). If the virtual agent does not answer the contact, by
default the conversation is placed in the New queue for a human agent to pick up. This can also be configured
in `Settings`. If you prefer, you can automatically resolve the conversation and send a message to the contact (such
as "Please try again in a little while"). The virtual agent could also decide to immediately return control by
sending `RESOLVED` or `HANDOVER` in the `complete` field.
Similarly, after a `CONVERSATION_DELEGATED` event, your virtual agent has 5 minutes to pose a question to the contact by
default. If the virtual agent fails to do this, the conversation is handed back to the previous owner of the
conversation or placed in the New queue, depending on the handoff rule.
### Response
Your response to the webhook should be a status `200 OK`. In the body, you can return the response you want to send to the contact:
```json
{
"sendMessage": {
"text": "Hi! How can I help you?",
"attachment": "funny_cat.gif"
},
"applyTopics": [
"Hotel Reservation"
],
"applyTags": [
"Happy"
],
"setContactAttributes": {
"account_number": "19758293529351"
},
"complete": "HANDOVER"
}
```
- sendMessage: (Optional) The message you want to send to the contact. You can send only text, only an attachment, or
both at the same time. If you want to send an attachment, you must upload it first, so we recommend using the
asynchronous flow.
- applyTopics: (Optional) The list of topics you want to apply to the conversation (the intent or action that your
Virtual Agent matched). Topics that do not exist in Inbox 2.0 will be ignored.
- applyTags: The list of tags you want to apply to the message from the contact. Tags that do not exist in Inbox 2.0
will be ignored. It's only possible to use `applyTags` in response to an `INBOUND_MESSAGE_RECEIVED`. It's also
possible to tag a specific message by specifying the `messageId`. In that case you can respond
using
```json
{
"applyTags": [{
"messageId": "cc75552a-1a78-11e9-855e-6d1e71016abf",
"tag": "Happy"
}]
}
```
- setContactAttributes: The attributes you want to set on a contact. The object is a map between the attribute
definition's alias and value to set.
- complete: (Optional) This can be either `HANDOVER` if you want to give the conversation to another agent,
or `RESOLVED` if you want to resolve the conversation. When you pass HANDOVER, the handoff rule you configured in
settings determine what will happen next. If the handoff rule is "No one," the conversation is placed in the New
queue without an owner. Any human agent can pick up the conversation. If the rule has been set to "Previous agent,"the
conversation will be assigned back to the previous human agent. If there was no previous agent, the conversation is
placed in the New queue without an owner.
If you are integrating with an asynchronous bot platform, you can simply return an empty JSON body {} and send this
message using a POST request. We also recommend using the REST API when you want to send an attachment. You can respond
with {}, upload an attachment using a PUT request, and then send the attachment using a POST request.
- name: vai_rest_api
x-displayName: REST API
description: |
If you want to send the replies asynchronously or manipulate the conversation in your fulfillment code, you'll need to
call the Virtual Agent REST API.
The [REST API authentication](#tag/rest-api-authentication) section contains more details on how to authenticate your client.
- name: real_time_metrics_introduction
x-displayName: Introduction
description: |
The Real-time Metrics API gives you direct access to real-time metrics in the Inbox 2.0 platform via a convenient and
secure REST API. The API provides Inbox 2.0 customers a means to integrate with internal contact center dashboards in
conjunction with other traditional and/or digital communication channels such as phone, email, live chat, etc.
### Use cases
If you are building software, you can use the API to engage your customers by displaying current wait time to customers in a mobile application or website.
If you're a business, you can use the API to streamline internal business processes by:
- Displaying current backlog and key metrics on digital channels alongside other contact center mediums on real-time
dashboards maintained internally.
- Keeping internal stakeholders informed by reporting on hourly trends in volume and backlog statistics across digital
channels, to efficiently route agents to another channel if volume spikes.
- name: user_presence_introduction
x-displayName: Introduction
description: |
The User Presence API gives you direct access to an overview of online agents in the Inbox 2.0 platform via a
convenient and secure REST API.
The API provides Inbox 2.0 customers a means to integrate with internal contact center dashboards in
conjunction with other traditional and/or digital communication channels such as phone, email, live chat, etc.
- name: user_presence_rest_api
x-displayName: REST API
description: |
When calling the User Presence API, the client needs to be authenticated.
The [REST API authentication](#tag/rest-api-authentication) section contains more details on how to authenticate your client.
- name: queue_introduction
x-displayName: Introduction
description: |
The Queue API gives you direct access to an overview of conversations with the agent that locked the conversation
in the Inbox 2.0 platform via a convenient and secure REST API.
The API provides Inbox 2.0 customers a means to integrate with internal contact center dashboards in
conjunction with other traditional and/or digital communication channels such as phone, email, live chat, etc.
- name: queue_rest_api
x-displayName: REST API
description: |
When calling the Queue API, the client needs to be authenticated.
The [REST API authentication](#tag/rest-api-authentication) section contains more details on how to authenticate your client.
- name: real_time_metrics_rest_api
x-displayName: REST API
description: |
When calling the Real-time Metrics API, the client needs to be authenticated.
The [REST API authentication](#tag/rest-api-authentication) section contains more details on how to authenticate your client.
- name: proactive_messaging_introduction
x-displayName: Introduction
description: |
### What is proactive messaging?
Proactive messaging allows enterprises to reach out preemptively to customers, ensuring higher satisfaction and loyalty.
Typical use cases include appointment reminders, delivery confirmations, shipping updates, order tracking, etc.
With our convenient and secure RESTful API, enterprises can send proactive messages to their customers.
Hootsdesk's Proactive Messaging API allows you to:
- Send messages in real-time to your customers for supported media, including message templates on WhatsApp.
- Follow up on the status of sent messages.
- Retrieve detailed information about reasons for failures.
### Supported media
You can use Inbox 2.0 to send proactive messages on:
- WhatsApp
### Rate limit
The Proactive Messaging API is rate-limited to 60 messages per minute per organization. Enterprises exceeding these limits receive an error and must re-send any failed messages.
### Metadata
When sending a proactive message, you can pass along custom information that is stored in Inbox 2.0. This data can then be exported. Please contact `dev.support@hootsuite.com` to add metadata to the Messages export. For example, when you send an appointment confirmation to your customer, you can pass along a unique identifier. You can then download the Messages export from Inbox 2.0, and determine how many unique customers are responding to your outbound notification.
Example code:
```json
{
"contact": "+32123456789",
"text": "This is a message with metadata",
"medium": "WHATSAPP",
"channel": "Inbox 2.0 WA Channel",
"metadata": {
"customerID": "ABC123",
"Source": "IVR"
}
}
```
- name: proactive_messaging_rest_api
x-displayName: REST API
description: |
When calling the Proactive Messaging API, the client needs to be authenticated.
The [REST API authentication](#tag/rest-api-authentication) section contains more details on how to authenticate your client.
### Examples
1. Send a proactive text message
The following example shows a proactive outbound message that can be sent as a text message. Inbox 2.0 supports text messaging on WhatsApp
Enterprises are responsible for ensuring that the customers have opted-in for proactive communications.
Request
```shell
curl -X POST https://platform.hootsuite.com/inbox/v1/proactive-messaging/ \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
-d '{ "medium": "WHATSAPP", "channel": "myChannel", "contact": "+32495123456", "text": "Hello world!" }'
```
Response `200`
```json
{
"correlationId": "3a7c6c1d-9f9b-11e8-b23b-6f13d5844b66"
}
```
2. Send a proactive message template (WhatsApp)
WhatsApp allows for proactive outbound communication when these are sent as message templates that have been authorized by WhatsApp. These templates have a name, corresponding text, and substitution parameters within the text to make them personalized.
Inbox 2.0 has simplified how enterprises can send out these message templates through the use of shorthand codes for inline syntax:
```text
&((namespace=[[NAMESPACE]] template=[[TEMPLATE NAME]] fallback=[[FALLBACK TEXT]] language=[[LANGUAGE]] body_text=[[VARIABLE1]] body_text=[[VARIABLE2]]))&
```
| Parameter name | Parameter description | Required |
|----------------|----------------------------------------------------------------------------------------------------------------------------|-----------|
| namespace | Unique code provided by WhatsApp while defining message templates. | true |
| template | Name of the template provided on WhatsApp Manager. | true |
| fallback | We recommend setting the same value as the Template name here. | true |
| language | The language in which the messages should be sent. The language needs to be defined in the WhatsApp Manager. | true |
| body_text | The variable text. 0, 1, or multiple variables in a message. Per variable, there needs to be a body_text parameter. | true |
The language codes can be found on: <https://developers.facebook.com/docs/whatsapp/message-templates/creation>
Enterprises construct the messages in shorthand and send it in the text field as shown in the following code.
Request
```shell
curl -X POST https://platform.hootsuite.com/inbox/v1/proactive-messaging/ \
-H 'Authorization: Bearer <token>' \
-H 'Content-Type: application/json' \
-d '{ "medium": "WHATSAPP", "channel": "myChannel", "contact": "+32495123456", "text": "&((namespace=[[3c860f8b_1ae3_1105_b9ea_647e69aa2d49]] template=[[welcome_customer]] fallback=[[welcome_customer]] language=[[en]] body_text=[[Gregory]] body_text=[[How can I help you?]]))&" }'
```
Response `200`
```json
{
"correlationId": "3a7c6c1d-9f9b-11e8-b23b-6f13d5844b66"
}
```
3. Get status overview
Request
```shell
curl -X GET https://platform.hootsuite.com/inbox/v1/proactive-messaging/3a7c6c1d-9f9b-11e8-b23b-6f13d5844b66 \
-H 'Authorization: Bearer '
```
Response `200`
```json
{
"correlationId": "3a7c6c1d-9f9b-11e8-b23b-6f13d5844b66",
"total": 1,
"statuses": {
"SENT": 1
}
}
```
4. Get status details
Request
```shell
curl -X GET https://platform.hootsuite.com/inbox/v1/proactive-messaging/f988bd0f-9f9d-11e8-b23b-7d351b0c7ce9/FAILED \
-H 'Authorization: Bearer '
```
Response 200
```json
[
{
"status": "FAILED",
"contact": "+32495123456",
"reason": "No channel found for medium TWIT"
}
]
```
- name: messenger_introduction
x-displayName: Introduction
description: |
The Inbox Web Messenger SDK allows you to implement a customizable, fully featured messenger on your website. Any customer who visits your website or uses your app can contact your support team directly, eliminating the need for your users to use Facebook, WhatsApp, or any other messaging platform.
### Create your channel
Please email customer support (`dev.support@hootsuite.com`) to add a new messenger channel.
- name: messenger_web_sdk
x-displayName: Web Messenger SDK
description: |
## Implement Messenger on your website
### Get started
The following steps are required to get Messenger to appear on your website.
#### Step 1: Add the following code toward the end of the `<head>` section on your page.
> **Attention:** Make sure to copy all the code below
```html
<script>
!function(e,t,n,o){var r,s,c,a=[],i=[];e[n]={init:function(){r=arguments;var e={then:function(t){return i.push({type:"t",next:t}),e},catch:function(t){return i.push({type:"c",next:t}),e}};return e},on:function(){a.push(arguments)},render:function(){s=arguments},destroy:function(){c=arguments}},e.__onWebMessengerHostReady__=function(t){if(delete e.__onWebMessengerHostReady__,e[n]=t,r)for(var o=t.init.apply(t,r),p=0;p<i.length;p++){var u=i[p];o="t"===u.type?o.then(u.next):o.catch(u.next)}for(s&&t.render.apply(t,s),c&&t.destroy.apply(t,c),p=0;p<a.length;p++)t.on.apply(t,a[p])};try{var p=t.getElementsByTagName("script")[0],u=t.createElement("script");u.async=!0,u.src="https://assets.hootsuite.com/sdk/messenger/web/"+o+"/webmessenger."+o+".min.js",p.parentNode.insertBefore(u,p)}catch(e){console.error(e)}}(window,document,"WebMessenger","2.6.9");
</script>
```
#### Step 2: Paste the following initialization code toward the end of the `<body>` section.
This initializes a basic Web Messenger without any special customizations. Customizations are described in the next sec
# --- truncated at 32 KB (148 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/hootsuite/refs/heads/main/openapi/hootsuite-inbox-api-openapi.yml