> This page is for version Generative (default).
> For other versions, use one of these documentation indexes:
> - Generative (default): https://developers.ada.cx/generative/llms.txt
> - Scripted: https://developers.ada.cx/scripted/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developers.ada.cx/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developers.ada.cx/_mcp/server.

# SDK API Reference

Ada's Web Chat consists of a global adaEmbed object that you must [add to your site](/generative/chat/web/getting-started#script-tag) to use any Web SDK functionality, along with corresponding [settings](#settings) and [actions](#actions).

## Settings

Set the Web Chat's configurable options by defining an adaSettings object on your `window` scope.

**`HTML`**

```html HTML
<script>
  window.adaSettings = {
    ...
  }
</script>
...
<!-- Define the web chat script afterwards -->
```

Alternatively, you can pass settings to the adaEmbed.start method. (See [Delay bot loading](/generative/chat/web/getting-started#delay-bot-loading).)

> **Note**
>
> The Web SDK requires that `window.adaSettings` be defined before the script loads. You must therefore either define `window.adaSettings` before the script, or make use of [async](/generative/chat/web/getting-started#use-async-to-improve-page-load-times) on your web chat script.

The following are all of the available settings for Web chat.

### adaReadyCallback

`adaReadyCallback?(params: { isRolledOut: boolean }): void;`

Specifies a callback function to be called when Web Chat has finished setting up. This is especially useful when Web Chat is loaded asynchronously.

**`HTML`**

```html HTML
<script type="text/javascript">
  window.adaSettings = {
    adaReadyCallback: ({ isRolledOut }) => {
      console.log("Ada Embed is done setting up. Chat support is now available.");
    }
  }
</script>
```

### chatterTokenCallback

`chatterTokenCallback?(chatter: string): void;`

Specifies a callback for when the `chatter` token has been set in Chat.  This is called when chat is first opened by a chatter.

### cluster

`cluster?: string;`

Specifies the Kubernetes cluster to be used. Unless directed by an Ada team member, you should not change this value.

### conversationEndCallback

`conversationEndCallback?(callback: (event?: { [key]: string | object }) => void): void;`

Use `conversationEndCallback` to specify a callback function to be called when a chatter ends the conversation. The callback will receive an event object containing conversation metadata.

**`HTML`**

```html HTML
<script type="text/javascript">
window.adaSettings = {
  conversationEndCallback: (event) => {
    // perform action after conversation has been ended by the chatter
  }
};
</script>
```

### crossWindowPersistence

`crossWindowPersistence?: boolean;`

When set to `true`, allows the chat drawer open/close state to persist across windows and page refreshes using the `Window.sessionStorage` API. When the browser is closed the state is forgotten. Note that the `crossWindowPersistence` setting only works if an Ada Glass live chat is active (that is, while a chatter is connected to an agent).

> **Note**
>
> We recommend enabling this feature if your bot uses Ada Glass.

### domain

`domain?: string;`

Use this setting to change the subdomain. Unless directed by an Ada team member, you will not need to change this value.

### greeting

`greeting?: string;`

Use to customize the greeting messages that new chatters see. This is useful for setting page-specific greetings across your app. The greeting should correspond to the ID of the Answer you would like to use, which you can find in the URL of the corresponding Answer in the dashboard.

**Example**

![](/_fern-files/_img/a7fea47cff8a7e0931f1f7b88be30130fc81ec7c6be9d662433b766b8e037e0b.webp)

### handle

`handle:? string;`

Can be used to specify the bot handle if one is not specified in the script `data-handle` attribute.

### hideMask

`hideMask?: boolean;`

When set to `true`, prevents the default mask from appearing on top of your site's content when opened on desktop.

> **Note**
>
> We recommend setting the value of hideMask to `false`. This allows users to navigate the page while the Ada chat window is open.

### language

`language?: string;`

Set the language for your bot. This setting takes in a language code to programatically set the default bot language. For example, you could change the language to French as in the following example:

**`HTML`**

```html HTML
<script>
      window.adaSettings = {
        language: "fr",
      }
    </script>
```

You must first turn languages on in your dashboard:

* If you're using a **generative AI Agent**, go to **Customization** > **Languages**. See [Support multiple languages in the same AI Agent](https://docs.ada.cx/docs/generative/set-up-your-ai-agent-s-knowledge-and-behavior/support-multiple-languages-in-the-same-ai-agent/).
* If you're using a **scripted bot**, go to **Settings** > **Bot Setup** > **Multilingual**. See [Support multiple languages in the same bot](https://docs.ada.cx/support-multiple-languages).

> **Note**
>
> Language codes must use the [ISO 639-1 language format](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes).

> **Check**
>
> Alternatively, you can use the [setLanguage](#setlanguage) action, which allows you to change the language without clearing the chat history.

### lazy

`lazy?: boolean;`

When set to true `true`, this will prevent the bot from loading until the `adaEmbed.start(...)` method is called. (Alternatively, see [Delay bot loading](/generative/chat/web/getting-started#delay-bot-loading).)

### metaFields

`metaFields?: FlatObject;`

Use metaFields to pass information about a `chatter` to Ada. This can be useful for tracking information about your customers, as well as personalizing their experience. For example, you may wish to track the `phone_number` and `name` for conversation attribution. (See [Variables](https://docs.ada.cx/variables) for more information)

Once set, you can access this information:

* in the email attachment from Handoff Form submissions
* via the **Meta variables** modal in the **Conversations** page of your Ada dashboard

To change these values after bot setup, use the [setMetaFields](#setmetafields) action.

**`HTML`**

```html HTML
<script type="text/javascript">
  window.adaSettings = {
    metaFields: {
      phone_number: "(123) 456-7890",
      name: "Ada Lovelace"
    }
  }
</script>
```

> **Note**
>
> Meta field keys should not include whitespace, emojis, special characters, or periods.

### onAdaEmbedLoaded

Called when the embed script has been loaded, and before it is initialized. This is useful for [subscribing to events](#subscribeevent). Subscribing here ensures that subscriptions are in place before events are triggered.

**`HTML`**

```html HTML
<script type="text/javascript">
window.adaSettings = {
  onAdaEmbedLoaded: () => {
    window.adaEmbed.subscribeEvent("ada:campaigns:shown", (data) => {
      console.log("Message received from campaign with key:", data.campaignKey);
    });
  }
};
</script>
```

### parentElement

`parentElement?: string | HTMLElement;`

Specifies where to mount the `<iframe>` if the default side drawer is not desired. Accepts the `HTMLElement` or element `id` of the desired parent element.

**`HTML`**

```html HTML
<head>
  <!-- ... -->
  <script type="text/javascript">
    window.adaSettings = {
      parentElement: document.getElementById("custom-iframe")
    }
  </script>
</head>
<body>
  <!-- ... -->
  <div id="custom-iframe"></div>
</body>
```

> **Warning**
>
> Chat will render immediately inside the `parentElement` provided. This means that the conversation will also get initialized. We do not recommend initializing Embed2 with the  `parentElement` setting automatically on every page, since it could lead to low engagement rates.

### privateMode

`privateMode?: boolean;`

Puts web chat into private mode when set to `true`. In private mode, web chat forgets conversation history on refresh. This is effectively the same as setting [customer persistence](https://docs.ada.cx/docs/generative/set-up-your-ai-agent-s-knowledge-and-behavior/manage-your-ai-agent-s-behavior/manage-when-your-ai-agent-forgets-customers/) or [chatter persistence](https://docs.ada.cx/chatter-persistence) to **Forget After Reload**.

### rolloutOverride

`rolloutOverride?: number;`

Use this setting to override the rollout value set in the dashboard. This can be useful if you need page-specific rollout values. Accepts any number between `0` and `1`.

### sensitiveMetaFields

`sensitiveMetaFields?: FlatObject;`

Like [metaFields](#metafields), you can use `sensitiveMetaFields` to pass information about a chatter to Ada. With sensitiveMetaFields, however, values are:

* encrypted immediately upon entering the Ada system
* temporarily stored in a cache on the Ada side, that is cleared after 24 hours
* not stored in the database
* redacted on the dashboard

If the sensitive data is sent as part of a bot response, it is not redacted the first time it appears (to allow the chatter to verify it, for example), but the data is redacted when fetching the logs of a recent conversation.

**`HTML`**

```html HTML
<script type="text/javascript">
  window.adaSettings = {
    sensitiveMetaFields: {
      jwt_token: "xxxxx.yyyyy.zzzzz",
    }
  }
</script>
```

To change these values after bot setup, use the [setSensitiveMetaFields](#setsensitivemetafields) action.

> **Note**
>
> Meta field keys should not include whitespace, emojis, special characters, or periods.

### testMode

`testMode?: boolean;`

Marks the chatter as a test user.

### toggleCallback

`toggleCallback?(isDrawerOpen: boolean): void;`

Use this setting to trigger side effects when the web chat drawer is opened or closed.

### zdChatterAuthCallback

`zdChatterAuthCallback?(callback: (token: string) => void): void;`

Use `zdChatterAuthCallback` for Zendesk chatter authentication. This setting allows you to request a JWT token from your API, then pass it to Ada. This creates shared trust between Ada and Zendesk, and in turn allows for verifiable chatter identity within the context of a chat session.

```js
window.adaSettings = {
  zdChatterAuthCallback: (callback) => {
    // Here you should make a request to get the fresh JWT token
    const token = "token goes here";
    callback(token)
  }
};
```

> **Info**
>
> Ada waits up to 30 seconds for the callback to be triggered before loading chat. If the callback isn't triggered within that time, Ada abandons the request. If you need to bypass authentication, ensure you call the callback with no arguments.

> **Note**
>
> `zdChatterAuthCallback` is available only for [Zendesk Chat](https://docs.ada.cx/docs/generative/integrate-ada-with-other-tools/use-ada-with-zendesk/configure-zendesk-chat). It is not available for [Zendesk Messaging](https://docs.ada.cx/docs/generative/integrate-ada-with-other-tools/use-ada-with-zendesk/configure-and-use-zendesk-messaging/).

**`JavaScript`**

```javascript JavaScript
window.adaSettings = {
    handle: "<YOUR-BOT-HANDLE>",
    cluster: "<YOUR-CLUSTER>",
    zdChatterAuthCallback: (callback) => {
        if (userLoggedIn) {
            const token = "token goes here";
            callback(token)
        }

        callback()
    }
};
```

## Actions

You can call all of the following Embed2 Actions from the global adaEmbed object.

### closeCampaign

`closeCampaign(): Promise<void>;`

Closes the currently displayed campaign (does nothing if no campaign is currently displayed).

> **Note**
>
> This action requires the Ada Pro package.

### deleteHistory

`deleteHistory(): Promise<void>;`

Deletes the `chatter` object used to fetch conversation logs for a user from storage. When a user opens a new chat window, a new `chatter` object is generated.

### evaluateCampaignConditions

`evaluateCampaignConditions(options: CampaignParams): Promise<void>;`

This is similar to [triggerCampaign](#triggercampaign), however, instead of triggering a specific Campaign, `evaluateCampaignConditions` evaluates the trigger conditions of the Campaigns in priority order, and triggers the first Campaign whose conditions are matched. This can be useful, for example, if Embed2 cannot determine that the route has changed, and the campaign trigger rules need to be evaluated again.

An optional argument `options` can be passed that matches the `CampaignParams` interface. These  options settings may be helpful when testing your Campaign:

* `ignoreFrequency?: boolean`: if `ignoreFrequency` is `true`, trigger conditions for Campaigns that have already been triggered within the configured frequency are also evaluated and may be triggered.
* `ignoreStatus?: boolean`: if `ignoreStatus` is `true`, trigger conditions for inactive and draft Campaigns are also evaluated and may be triggered.

> **Note**
>
> This action requires the Ada Pro package.

### getInfo

`getInfo(): Promise<WindowInfo>;`

Returns a `WindowInfo` object containing information about the bot. See [WindowInfo](#windowinfo) for more details.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.getInfo().then(function(windowInfo){
    console.log("is the drawer open?");
    console.log(windowInfo.isDrawerOpen ? "Yes": "No");
});
```

### reset

`reset(resetParams?: ResetParams): Promise<void>;`

Creates a new `chatter` and refreshes the Chat window. `reset` can take an optional object allowing you to change the `language`, `metaFields`, `sensitiveMetaFields`, and `greeting` for the new `chatter`.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.reset({
  greeting: "5e9481e296ac6c4467092be5"
});
```

### setLanguage

`setLanguage(language: string): void;`

Changes the language in chat programatically. Use this action, rather than the language setting, to change the chat language without clearing the chat history. Language codes must use a lowercase, two-letter code, in [ISO 639-1 language format](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes). For example, en, fr, ca, ar, and so on.

```js
window.adaEmbed.setLanguage("en");
```

Before using `setLanguage`:

* You must turn languages on in your Ada dashboard.
  * If you're using a **generative AI Agent**, go to **Customization** > **Languages**. See [Support multiple languages in the same AI Agent](https://docs.ada.cx/docs/generative/set-up-your-ai-agent-s-knowledge-and-behavior/support-multiple-languages-in-the-same-ai-agent/) for more information.
  * If you're using a **scripted bot**, go to **Settings** > **Bot setup** > **Multilingual**. See [Support multiple languages in the same bot](https://docs.ada.cx/support-multiple-languages) for more information.

* The chat window must be opened at least once.

### setMetaFields

`setMetaFields(fields: FlatObject): Promise<void>;`

Used to update `metaFields` after chat has been opened. In most situations, the `metaFields` settings object should be enough for user attribution. However, in cases where Ada chat remains open while page changes occur (like in Single Page Applications), this method may be useful.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.setMetaFields({
  phone_number: "(123) 456-7890",
  name: "Ada Lovelace"
});
```

> **Note**
>
> Meta field keys should not include whitespace, emojis, special characters, or periods.

### setSensitiveMetaFields

`setSensitiveMetaFields(fields: FlatObject): Promise<void>;`

Use this action to update `sensitiveMetaFields` after chat has been opened. Here, the values are not stored in the database and are deleted after 24 hours.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.setSensitiveMetaFields({
  jwt_token: "xxxxx.yyyyy.zzzzz",
});
```

> **Note**
>
> Meta field keys should not include whitespace, emojis, special characters, or periods.

### start

`start(adaSettings: StartOptions): Promise<void>;`

Used to initialize Embed2 on your page. This action is triggered by default internally, so you will typically not need to call it directly unless you are using Embed2 in `lazy` mode, or have called `stop` and want to restart Embed2.

`StartOptions` matches anything listed in the [Settings](#settings) section (for example, `adaReadyCallback`).

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.start({
  handle: "my-bot",
  language: "fr",
  mobileOverlay: true
});
```

### stop

`stop(): Promise<void>;`

Removes Embed2 from your page.

### subscribeEvent

`subscribeEvent(eventKey: string, callback: (data: object, context: object) => void): Promise<number>`

Certain things in Ada trigger events. Each event consists of an event key and a data payload. Using `subscribeEvent`, you can define callbacks that are called when a specific event is triggered.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.subscribeEvent("ada:campaigns:shown", (data) => {
  console.log("Message received from campaign with key:", data.campaignKey);
});
```

Callbacks are triggered whenever an event starts with the `eventKey` provided to `subscribeEvent`. This means you can subscribe to all events of a certain category. For example, the callback in a subscription to `ada:campaigns` will be called on `ada:campaigns:shown`, `ada:campaigns:opened`, and any other events beginning with `ada:campaigns`.

Two arguments are provided to each callback when it is called: `data` and `context`:

* `data` is specific to each event.
* `context` is an object with a single property, the `eventKey` of the event that triggered the callback.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.subscribeEvent("ada:campaigns", (data, context) => {
  const { eventKey } = context;

  if (eventKey === "ada:campaigns:shown") {
    console.log("Message received from campaign with key:", data.campaignKey);
  }

  if (eventKey === "ada:campaigns:opened") {
    console.log("Chat opened after being shown campaign with key:", data.campaignKey);
  }

  if (eventKey === "ada:campaigns:engaged") {
    console.log("Chatter engaged with campaign with key:", data.campaignKey);
  }
});
```

`subscribeEvent` returns a number `subscriptionId` that you can use to unsubscribe later (see [unsubscribeEvent](#unsubscribeevent)).

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.subscribeEvent("ada:end_conversation", (data, context) => {
    console.log("The conversation has been ended by the user.");
    console.log("Chatter ID: ", data.chatter_id);
    console.log("Chat Data: ", data.event_data);
    console.log("Chat Transcript: ", data.event_data.chatter_transcript);
    });
```

It is strongly recommended that you place initial subscriptions to events in the `onAdaEmbedLoaded` function. This ensures that:

* the embed script has been loaded, so it is available to accept subscriptions.
* subscriptions happen before any events are triggered, so that no events are missed.

**`JavaScript`**

```javascript JavaScript
window.adaEmbed.subscribeEvent("ada:chat_frame_timeout", (data, context) => {
  // Perform logic needed here when chat fails to load.
});
```

The following are the events that you can currently subscribe to:

| Event key                  | Data                                                                                                                                                                                                                                     | Description                                                                                                                                                          |
| :------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ada:agent:joined`         | `{"conversation_id": "66a150a67abaa4b0d515909b"}`  The conversation ID                                                                                                                                                                   | Triggered whenever an agent joins the conversation.                                                                                                                  |
| `ada:agent:left`           | `{"conversation_id": "66a150a67abaa4b0d515909b"}`  The conversation ID                                                                                                                                                                   | Triggered whenever an agent leaves the conversation.                                                                                                                 |
| `ada:campaigns:shown`      | `campaignKey`  The key of the campaign that triggered the received message.                                                                                                                                                              | Triggered when the chat application receives a message originating from a campaign.                                                                                  |
| `ada:campaigns:opened`     | `campaignKey`  The key of the last campaign shown before chat was opened.                                                                                                                                                                | Triggered when chat is opened after a proactive campaign has been shown.                                                                                             |
| `ada:campaigns:engaged`    | `campaignKey`  The key of the last campaign shown before the conversation was engaged.                                                                                                                                                   | Triggered when the chatter engages a conversation (that is, sends a message) after being shown a campaign in the same session.                                       |
| `ada:conversation:message` | `{  <br />    "author": "bot" \| "agent",  <br />    "conversation_id": "66a150a67abaa4b0d515909b" // the Ada conversation ID  <br />    "message_id": "66a150a67ab7a4b0d5259077" // the Ada message ID  <br />}`                        | Triggered whenever the chatter receives a new message.                                                                                                               |
| `ada:end_conversation`     | `chatter_id`  Contains the `chat id` for the chatter.   `event_data`  Contains necessary chat information (chat start time, chat end time, chat messages).   `chatter_transcript`  Contains the transcript between the user and the bot. | Triggered when the chatter ends the chat by closing the chat window or selecting **End Chat**.                                                                       |
| `ada:csat_submitted`       | `{  "conversation_id": "66a150a67abaa4b0d515909b", "csat_score": 5 }`                                                                                                                                                                    | Triggered when the full screen CSAT is submitted. `csat_score` is a numerical value.                                                                                 |
| `ada:chat_frame_timeout`   | `null`                                                                                                                                                                                                                                   | Triggers when the chat iframe has loaded, but the chat application does not confirm it is ready within 5 seconds. Used to create a fallback when chat fails to load. |
| `ada:minimize_chat`        | `conversation_id`  The conversation ID   `is_engaged`  Whether a chatter has sent a message to the bot at least once in a new conversation                                                                                               | Triggered when the chatter minimizes the chat window.                                                                                                                |
| `ada:close_chat`           | `conversation_id`  The conversation ID   `is_engaged`  Whether a chatter has sent a message to the bot at least once in a new conversation                                                                                               | Triggered when the chatter closes the chat window.                                                                                                                   |

The events that begin with `ada:agent` are compatible with the following handoffs:

* Zendesk Messaging
* Zendesk Live Chat
* Salesforce
* Nuance
* Aysnchronous handoffs (via Ada’s Solutions team)

### toggle

`toggle(): Promise<void>;`

Used `toggle` to programatically open or close the chat window. You cannot use this method with the `parentElement` option.

### triggerAnswer

`triggerAnswer(answerId: string): void;`

Triggers an answer in chat. Include the Answer ID, which you can find in the URL of the corresponding Answer in the dashboard.

**Example**

![](/_fern-files/_img/a7fea47cff8a7e0931f1f7b88be30130fc81ec7c6be9d662433b766b8e037e0b.webp)

```
window.adaEmbed.triggerAnswer("627d28a9bd9ca9e5337b9763");
```

> **Note**
>
> The chat window must be opened at least once before this method can be used.

### triggerCampaign

`triggerCampaign(campaignKey: string, options: CampaignParams): Promise<void>;`

Use in conjunction with `campaignKey` to trigger proactive campaigns.  It supports two optional arguments:

* `ignoreFrequency?: boolean`: when set to true, allows campaign triggering even if it's already been triggered within the frequency configured in the dashboard campaign settings.
* `ignoreStatus?: boolean`: when set to true, allows campaign triggering even if it's inactive or in a draft state.

In most cases, you should set these to false, so that the original settings configured for the campaign take precedence. There may be specific cases in which you might enable ignoreFrequency. For example, a campaign that is shared across multiple pages, that you want to show once on a single page (such as the main page of a help center), but show once per session on all subpages.

See [Embed Campaign Use Cases](https://docs.ada.cx/docs/scripted/build-and-maintain-your-bot/create-conversations/start-customizable-interactions-using-advanced-proactive-campaigns) for some examples of how to use this action.

> **Note**
>
> This action requires the Ada Pro package.

> **Note**
>
> This action is only applicable if you're using a **scripted bot**. For a **generative AI Agent**, see [triggerProactive](#triggerproactive) instead.

### triggerProactive

`triggerProactive({ messageKey: string, params?: Record<string, string> }): void;`

Triggers a proactive conversation using a specified key. This will display predefined static or template messages, where template messages can include dynamic parameters.

Parameters

| Name         | Type                     | Required                   | Description                                                                                         |
| ------------ | ------------------------ | -------------------------- | --------------------------------------------------------------------------------------------------- |
| `messageKey` | `string`                 | Yes                        | The key identifying the proactive conversation. Must match a predefined static or template message. |
| `params`     | `Record<string, string>` | No (static) Yes (template) | Key-value pairs for replacing placeholders in template messages. Ignored for static messages.       |

**Examples**

1. Triggering a static Proactive Conversation

   Ex: *"Hello, how can I help you today?"*

```js
window.adaEmbed.triggerProactive({
  messageKey: "static_message_key"
});
```

2. Triggering a template Proactive Conversation

   Ex: *"Hello \{\{name}}, how can I help you today?"*

```js
window.adaEmbed.triggerProactive({
  messageKey: "template_message_key",
  params: { name: "Ada" }
});

// -> "Hello Ada, how can I help you today?"
```

> **Note**
>
> This action is only applicable if you're using a **generative AI Agent**. For a **scripted bot**, see [triggerCampaign](#triggercampaign) instead.

### trackEvent

`trackEvent(eventKey: string, value?: number, meta?: FlatObject)`

Use this to track an Event. The arguments of this function are:

* `eventKey: string`:  the key of the Event to track (required).
* `value?: number`: an optional value to assign to the Event.
* `meta?: FlatObject`: an optional object containing metadata corresponding to the Event. For example, it may be useful to track information such as currency, product group, customer segment, and so on.

```js
window.adaEmbed.trackEvent("Example_Event", 2, {
  productId: "a1b2c3",
  customerSegment: "premium"
});
```

> **Note**
>
> This action requires the Ada Pro package.

### unsubscribeEvent

`unsubscribeEvent(subscriptionId: number): void;`

Use this function to remove subscriptions created with the `subscribeEvent` function. It takes a single parameter, `subscriptionId`, which is the id of the subscription to be removed.

```js
const subscriptionId = await window.adaEmbed.subscribeEvent("ada:campaigns:shown", (data) => {
  console.log("Message received from campaign with key:", data.campaignKey);
});

window.adaEmbed.unsubscribeEvent(subscriptionId);
```

## Type signatures

Embed2 actions commonly use the following type signatures.

### CampaignParams

**`JavaScript`**

```javascript JavaScript
{
  ignoreFrequency?: boolean
  ignoreStatus?: boolean
}
```

### FlatObject

**`JavaScript`**

```javascript JavaScript
{
  [key: string]\: string | number | boolean | null
}
```

### ResetParams

**`JavaScript`**

```javascript JavaScript
{
  greeting?: string;
  language?: string;
  metaFields?: FlatObject;
  sensitiveMetaFields?: FlatObject;
}
```

### WindowInfo

**`JavaScript`**

```javascript JavaScript
{
  hasActiveChatter: boolean;
  hasClosedChat: boolean;
  isChatOpen: boolean;
  isDrawerOpen: boolean;
}
```