# Custom actions API
Source: https://docs.molin.ai/apis/custom-actions

Define HTTP endpoints your AI can call mid-chat to issue coupons, look up orders, book callbacks, and take other real actions for your customers.

The custom actions API allows you to define custom actions that can be triggered by users when they chat with your AI.

## Examples

Examples of custom actions include:

* Sending an email to the user with a discount code when they request one.
* Sending a message to a Slack channel when the user requests a callback.
* Providing product recommendations from your own database or inventory system.
* Collecting feedback from users and storing it in your own database.
* Collecting leads and storing them in your CRM system.

## How it works

1. You need to define a custom action in the [molin.ai](https://molin.ai) dashboard. You can define the name, description, and parameters that the action requires (e.g. email address, phone number, etc).
2. Your team needs to implement an API endpoint. This endpoint should accept the parameters defined in the dashboard and perform the action (e.g. generate a coupon and email it to the user).
3. You should enable the action from the dashboard and test it in the chat preview.

## How to create a custom action

1. Go to the [Actions page](https://molin.ai/app/actions) and click on the **New custom action** button.
2. Fill in a **name** and **description**. The **name** should describe succinctly what the action does. The **description** should provide more details about the action. Both the **name** and the **description** will be given to our AI so that it knows *when* to call the action. *See the example screenshot below*
3. Define the parameters that the action requires. For example, if the action is to email the user a coupon, you might need the user's email address. You must define correctly the type of each parameter (e.g. string, number, or boolean).
4. Choose the HTTP method (**POST** or **GET**) and define the endpoint URL where the action will be triggered. This URL should be accessible from the internet and should accept the parameters defined in the previous step. The endpoint should return plain text or JSON.

<Note>
  The entire response body from your endpoint will be given to the AI so it can respond to the user. Although the AI will only use the body to formulate its own answer, assume that the body *can* be
  shown to the user.
</Note>

![Example custom action](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/41c41340-b779-44a0-b671-fe7079160400/fit=scale-down,q=75,dpr=1)

![Example chat](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/393fd33a-c3a6-4a8e-3d15-02bdce802d00/fit=scale-down,q=75,dpr=1)

## How to create your endpoint

You can use any stack to create an HTTP web server that conforms to the following requirements.

<Note>Only HTTPS endpoints are supported.</Note>

### Requirements

#### Request

The request uses the HTTP method you chose when defining the action, **POST** by default. You can read the `x-molin-` headers to get additional information about the widget and conversation.

For a **POST** action, the parameters defined in the dashboard are sent as a JSON body:

```
POST https://your-endpoint.com/your-action
Content-Type: application/json
x-molin-custom-actions-version: 2024-11-01
x-molin-widget-id: widget-id
x-molin-conversation-id: conversation-id

{
  "your_defined_param": "some value from user input"
}
```

For a **GET** action, parameters are sent as query params instead, and no body is sent:

```
GET https://your-endpoint.com/your-action?your_defined_param=some+value+from+user+input
x-molin-custom-actions-version: 2024-11-01
x-molin-widget-id: widget-id
x-molin-conversation-id: conversation-id
```

##### URL path placeholders

If your endpoint expects a value as part of the URL path rather than a query param or body field, wrap a parameter name in curly braces in the endpoint URL, e.g. `https://your-endpoint.com/products/{productId}/availability`. Any parameter matching a `{paramName}` placeholder fills that path segment instead of being sent as a query param or body field; the remaining parameters are still sent normally for the chosen HTTP method. This works for both GET and POST actions.

<Note>
  Every placeholder in the endpoint URL must have a matching parameter defined in the dashboard, otherwise the action fails instead of calling your endpoint with an unresolved placeholder still in the
  URL.
</Note>

#### Response

The response should be plain text or JSON. The entire body will be given to the AI so it can respond to the user.

```
Content-Type: text/plain or application/json

any plain text or JSON
```

<Note>The response will be trimmed down to 8000 characters before being given to the AI. Make sure you don't exceed this length limit.</Note>

### Example

```
POST https://molin.your-shop.com/actions/generate-coupon-code
Content-Type: application/json
x-molin-custom-actions-version: 2024-11-01
x-molin-widget-id: widget123
x-molin-conversation-id: fce602af-39f2-4717-b2e0-698357b4f109

{
  "email": "john@testington.com"
}
```

```
Content-Type: text/plain

Success. Generated coupon code: LUCKY53215
```

## Response format recommendations

While the AI can understand JSON and XML, we recommend that you format your response as human readable plain text or markdown.

<Note>The response will be trimmed down to 8000 characters before being given to the AI. Make sure you remove any unnecessary information to stay under the 8000 character limit.</Note>

For example, if your custom action returns the order history for your customer, we recommend the following format:

```
Order ID: SHOP123
Creation date: 2025-01-01
Items:
- 1 x Blue jumper
- 2 x Red socks
Total cost: 100 USD

Order ID: SHOP456
…
```

## Special UI card responses

Your custom action endpoint can return structured data that will be rendered as interactive UI cards in the chat. This provides a richer user experience for certain types of data like products and orders.

### Product Card

```json theme={null}
{
  "url": "https://shop.com/product/123",
  "name": "Product Name",
  "description": "Product description",
  "price": "$100"
}
```

### Order Card

```json theme={null}
{
  "order_id_label": "Order ID",
  "order_id_value": "RTX-789012",
  "timeline": {
    "step": [
      {
        "label": "Order Placed",
        "status": "completed"
      },
      {
        "label": "Processing",
        "status": "completed"
      },
      {
        "label": "Shipped",
        "status": "in_progress"
      }
    ]
  },
  "items": {
    "item": [
      {
        "name": "Premium Cotton T-Shirt",
        "quantity": "2",
        "price": "$29.99",
        "image": "https://placehold.co/400x300/orange/white/png"
      },
      {
        "name": "Leather Wallet",
        "quantity": "1",
        "price": "$45.00"
      }
    ]
  },
  "total_label": "Total",
  "total_amount": "$104.98",
  "customer_name": "John Doe",
  "shipping_label": "Shipping",
  "shipping_method": "FedEx Express",
  "payment_label": "Payment",
  "payment_method_label": "Method",
  "payment_method_value": "Credit Card",
  "payment_status_label": "Status",
  "payment_status_value": "Paid",
  "order_tracking_label": "Track Order",
  "order_tracking_url": "https://fedex.com/track/RTX-789012"
}
```

#### Order Card with XML

You can also return order data in XML format:

```xml theme={null}
<order>
  <order_id_label>Order ID</order_id_label>
  <order_id_value>RTX-789012</order_id_value>
  <timeline>
    <step>
      <label>Order Placed</label>
      <status>completed</status>
    </step>
    <step>
      <label>Shipped</label>
      <status>in_progress</status>
    </step>
  </timeline>
  <items>
    <item>
      <name>Premium Cotton T-Shirt</name>
      <quantity>2</quantity>
      <price>$29.99</price>
      <image>https://placehold.co/400x300/orange/white/png</image>
    </item>
  </items>
  <total_label>Total</total_label>
  <total_amount>$104.98</total_amount>
  <customer_name>John Doe</customer_name>
  <order_tracking_url>https://fedex.com/track/RTX-789012</order_tracking_url>
</order>
```

<Note>Timeline can have 1–5 steps. Status values must be one of: `completed`, `in_progress`, `pending`, or `failed`. Use `failed` for a step that encountered an error.</Note>

## Using a test endpoint for development

If you wish to test quickly, you can use [Beeceptor](https://beeceptor.com/), a free service that allows you to create a temporary endpoint that you can use to test your custom action.

You can use the following URL as your endpoint in your custom action:

```
https://custom-action-generate-coupon-code.free.beeceptor.com
```

You can view requests sent to it [here](https://app.beeceptor.com/console/custom-action-generate-coupon-code).

## Static IPs

All calls on behalf of custom actions sent to your server are made through the following IPs:

```
35.207.69.21
209.38.162.129
```

<Note>Make sure you allowlist all of them if your server has IP restrictions.</Note>


# Personalization API
Source: https://docs.molin.ai/apis/experimental/personalization-api

Personalize conversation for your user by passing personal data to Molin automatically. Also, instruct the AI dynamically with custom AI instructions.

## Intro

You can pass 2 types of data to your AI on your website:

1. User data (e.g. your customer's email, name, ID) in a simple JSON format

2. Custom instructions for the AI to follow (in addition to the instructions configured via our dashboard on the [Personality page](https://molin.ai/app/shop-ai/personality))

Both of these will appear in the dashboard (on the Inbox page) for your agents to see. Both of these will be passed to your AI to help it generate relevant responses to your user.

## Demo

We prepared a demo environment that shows you an example implementation: [Demo: Personalization API | StackBlitz](https://stackblitz.com/edit/molin-ai-inject-user-data-2025-01?file=index.html).

## How to pass data

You will pass data through the Molin AI widget. The widget is either installed automatically (if your platform uses our plugin, e.g. Shopify, UNAS, Shoprenter) or it is embedded manually (if you use a custom platform).

The snippet for manually embedding the widget looks like this:

```html theme={null}
<script defer src="https://widget.molin.ai/shop-ai.js?w=YOUR_WIDGET_ID"></script>
```

You can always find yours on the [Publish](https://molin.ai/app/publish) page in our dashboard.

### Option 1. Automatic injection (recommended)

Simply include your data in a `<script>` tag, placed anywhere inside the `<head></head>` section of your website:

```html theme={null}
<script>
  window.molinSettings = {
    userData: {
      user_id: 'u123',
      name: 'John Doe',
      email: 'john@doe.com',
      created_at: '2021-01-01T00:00:00Z',
    },
    customInstructions: `
The user's most recent order ID is 12345. The total amount was 25.90 USD.
They are not eligible for new customer discounts, so do not recommend any.
`,
  };
</script>
```

When the widget loads, it will automatically read the data from `window.molinSettings`.

<Note>
  Using this method, you must ensure that the `<script>` snippet above exists inside the `<head></head>` section of your website before the browser emits the [load](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event) event. Ideally, it should be rendered on the server.
</Note>

### Option 2. Inject directly into the component (advanced)

If you manually render the custom components `<molin-shop-ai>` or `<molin-shop-ai-chat>`, you can assign data programmatically:

```javascript theme={null}
// using properties (preferred)
const el = document.querySelector('molin-shop-ai');
el.userData = { name: 'John Doe' };
el.customInstructions = `Never give this user a coupon code.`;
```

```javascript theme={null}
// using attributes
const el = document.querySelector('molin-shop-ai');
el.setAttribute('user-data', JSON.stringify({ name: 'John Doe' }));
el.setAttribute('custom-instructions', `Never give this user a coupon code.`);
```

<Note>Pay attention to the type of each property: `userData` is an object, `customInstructions` is a string. Please see below the data format section.</Note>

## Data formats

### User data

You must pass user data as a stringified JSON object. Only primitve types are allowed, no nested objects or arrays.

The user data must satisfy this TypeScript type:

```ts theme={null}
type XUserData = {
  [x: string]: string | number | boolean | null;
};
```

And this [valibot](https://valibot.dev/) schema:

```js theme={null}
const xUserDataSchema = v.record(
  v.string(), // key
  v.union([v.string(), v.number(), v.boolean(), v.null()]), // value
);
```

This is an example of valid user data:

```json theme={null}
{
  "user_id": "u123",
  "name": "John Doe",
  "email": "john@doe.com",
  "created_at": "2021-01-01T00:00:00Z"
}
```

This is an example of bad user data (it contains nested objects/arrays):

```json theme={null}
{
  "user": { "id": "u123" },
  "names": ["John", "Doe"]
}
```

### Custom instructions

You must pass custom instructions as a string, in plain text or markdown.

The minimum length is 1 character and the maximum is 5000 characters. If you pass an empty string, the attribute will be ignored.

## Dashboard access

Your customers' name and email will be shown inside the Molin AI dashboard on the Inbox page, in the right sidebar.

To ensure that this information is displayed correctly, you should include the following built-in fields in your user data:

```json theme={null}
{
  "name": "John Doe",
  "email": "john@doe.com"
}
```

## Data persistence

Molin's client side widget remembers the most recently active conversation. If you inject user data or custom instructions, they will be remembered for the duration of the conversation. Therefore, it is mandatory to reset the widget when the user logs out:

```javascript theme={null}
if (window.Molin) {
  window.Molin.reset();
}
```

## Security

### Data handling

You must understand how user data and custom instructions are handled by Molin:

1. Both are stored in our database, encrypted at rest and in transit.

2. Both are visible to your agents in the dashboard. Verify the [Settings > Members](https://molin.ai/app/settings/members) page in our dashboard to check who has access to view this data.

3. Both are shown to the LLM we use to generate AI responses. Assume that this data can be shown to the user in its entirety, even if the AI is usually smart enough to only disclose the specific information the user is asking for.

### Protection against session reuse

You must ensure that you reset the widget when the user logs out. This is to prevent the next user from seeing the previous user's data when continuing the conversation. See [Data persistence](#data-persistence).


# Show/Hide Widget
Source: https://docs.molin.ai/apis/experimental/show-hide-widget

Control when the Molin AI widget is visible on your site, so you can hide it on checkout, terms, or any other page where chat isn't wanted.

## Overview

You can programmatically control when the Molin AI widget is shown or hidden on your pages. This is useful for:

* hiding the widget on specific pages (e.g. checkout, terms of service)
* showing the widget only after certain conditions are met
* managing widget visibility inside iframes

## Default Behavior

By default, the widget:

* is visible on all pages where it's installed
* is hidden when loaded inside an iframe
* remembers its open/closed state between page navigations (on desktop only)

## Customizing visibility

### Option 1. Using settings JSON (recommended)

Simply include your settings in a `<script>` tag, placed anywhere inside the `<head></head>` section of your website:

```html theme={null}
<script>
  window.molinSettings = {
    hidden: false,
  };
</script>
```

If you set `hidden: true`, the widget launcher will be hidden when it loads, in all cases, on both mobile and desktop.

If you set `hidden: false`, the widget launcher will be visible when it loads, in all cases, on both mobile and desktop, even if the page was loaded inside an iframe.

If you do not set `hidden` to any value, then the default behavior explained above will apply.

### Option 2. Programmatically using JavaScript (advanced)

The widget exposes these methods:

```javascript theme={null}
// Show the widget launcher (floating bubble)
window.Molin.showLauncher();

// Hide the widget launcher (floating bubble)
window.Molin.hideLauncher();

// Open the chat window (as if the launcher was clicked)
window.Molin.openChat();

// Close the chat window (as if the launcher was clicked)
window.Molin.closeChat();
```

<Note>`window.Molin` is only available after the widget script has fully loaded. We use various algorithms to delay the loading of the script to minimize impact on your website's performance.</Note>

The widget's visibility methods are only available after the widget script has loaded.

The recommended way to know when the widget is ready is to listen for the [`molin:ready`](/home/marketing/javascript-events#molinready) event:

```javascript theme={null}
window.addEventListener('molin:ready', () => {
  window.Molin.showLauncher();
});
```

Alternatively, you can check if `window.Molin` is defined:

```javascript theme={null}
if (window.Molin) {
  window.Molin.showLauncher();
}
```

## Examples

### Hide on specific pages

Either implement some logic on your backend that controls the value assigned to the `hidden` property inside `window.molinSettings`:

```html theme={null}
<script>
  window.molinSettings = {
    hidden: false,
  };
</script>
```

or use JavaScript to hide the widget on specific pages:

```javascript theme={null}
// hide widget launcher on checkout pages
if (window.location.pathname.includes('checkout')) {
  window.Molin.hideLauncher();
}
```

### Show chat window on button click

You can add a "Chat with us" button to your page that opens the chat window when clicked:

```html theme={null}
<button onclick="window.Molin.openChat()">Chat with us</button>
```


# Introduction
Source: https://docs.molin.ai/apis/get-started/api-introduction

Start integrating with the Molin API: how versioning works, which APIs are available, and what you need before sending your first request.

## Versioning

The Molin API is versioned. Whenever you configure a webhook via our dashboard, you will need to select a version. The version you select will determine the format of the request that Molin will send to you and the format of the response you must respond with.

## Available APIs

<CardGroup>
  <Card title="Custom actions API" icon="pen-to-square" href="/apis/custom-actions">
    Supercharge your AI so it can take any action for your users
  </Card>

  <Card title="Product Sync with Schema.org API" icon="pen-to-square" href="/apis/product-sync-with-schema-org">
    Sync your products using Schema.org structured data format
  </Card>
</CardGroup>


# Security
Source: https://docs.molin.ai/apis/get-started/security

Keep your Molin API integration safe with HMAC signature verification and rules for handling sensitive information in responses.

## Sensitive information in responses

Do not include sensitive information in any response. You should assume that the response will be visible to the user in its entirety. If you need to include sensitive information, you should provide a link to a secure page where the user can view the information.

## HMAC signature verification

We are working on implementing HMAC signatures on all requests so you can verify that the request is coming from Molin. This feature is not yet available, but we will update this document when it is.

## Encryption

You must use `https` to ensure that the data is encrypted in transit. Our API does not support `http` connections.


# Validation
Source: https://docs.molin.ai/apis/get-started/validation

Use our published Valibot schemas to validate Molin API request and response payloads and get full type-safety in your integration.

## Intro

We use [valibot](https://valibot.dev/) schemas to validate the request and response payloads. We also publish these schemas via npm at [@molin.ai/api](https://www.npmjs.com/package/@molin.ai/api) so you can use them to validate the response payloads in your code. Using the [@molin.ai/api](https://www.npmjs.com/package/@molin.ai/api) package is optional as long as your implementation is compliant and follows the schemas of each API.

## Required fields

Unless a field is marked as optional using `v.optional()`, it is required and cannot be `null` or `undefined`. Generally, all top-level fields are required, nested fields may be optional, and you may provide additional data in the `extra` field.

## Example

Install our npm package, including `valibot` because it is a required peer dependency:

```sh theme={null}
npm install --save @molin.ai/api valibot
```

Then, whenever your server receives a request from our API, make sure you run your response through the validator:

```js theme={null}
// make sure you use the correct API version
import { OrderCancellationResponseSchema } from '@molin.ai/api/v20240910.js';

// valibot is required for schema validation
import * as v from 'valibot';

// respond with the data required depending on the request received
const response = {
  cancelled: false,
  reason: 'Invalid order ID',
};

// use valibot's parse or safeParse
v.parse(OrderCancellationResponseSchema, response);

// if validation passes, your response is valid
// if it fails, please double check the schema
```


# Product Sync with Schema.org
Source: https://docs.molin.ai/apis/product-sync-with-schema-org

Sync your product catalog to Molin with a JSON-LD API built on the Schema.org standard, using header-based authentication.

This spec describes a JSON API served via HTTP that uses the [Schema.org](https://schema.org/) structured data format for product synchronization, with header-based authentication.

## Intro

We chose the [Schema.org](https://schema.org/) format with [JSON-LD spec](https://json-ld.org/) because it's the web standard for structured data that most e-commerce platforms already use. If you visit any product page hosted by Shopify, WooCommerce, or other major platforms, you'll find a `type="application/ld+json"` script tag encoding product information in Schema.org format. This API leverages that same standardized structure to make product data integration seamless.

## Endpoints

We require the following endpoints if you are creating a custom API for Molin.

### Retrieving all products

We need an endpoint that we can call frequently to download your products.

#### Spec

* Content-Type must be **application/json**

* The body must contain a list of products encoded as a JSON string

* Each product object must be of type [schema.org/Product](https://schema.org/Product)

#### Example

GET `https://shop.example/molin/products.json`

```json theme={null}
[
  {
    "@context": "http://schema.org",
    "@type": "Product",
    "name": "Coffee Lenoa | Espresso",
    "description": "The best coffee beans imported from...",
    "brand": "Coffee Lenoa",
    "image": "//lenoacoffeeandshop.hu/cdn/shop/files/...",
    "url": "https://lenoacoffeeandshop.hu/products/lenoa-espresso",
    "offers": {
      "@type": "AggregateOffer",
      "priceCurrency": "USD",
      "lowPrice": "12.99",
      "highPrice": "19.99",
      "itemCondition": "http://schema.org/New",
      "availability": "http://schema.org/InStock",
      "offerCount": "2",
      "offers": [
        {
          "@type": "Offer",
          "name": "Coffee Lenoa | Espresso — 1000 gramm",
          "availability": "http://schema.org/InStock",
          "priceCurrency": "USD",
          "price": "19.99"
        },
        {
          "@type": "Offer",
          "name": "Coffee Lenoa | Espresso — 250 gramm",
          "availability": "http://schema.org/InStock",
          "priceCurrency": "USD",
          "price": "12.99"
        }
      ]
    },
    "additionalProperty": [
      {
        "@type": "PropertyValue",
        "name": "Origin",
        "value": "Ethiopia"
      },
      {
        "@type": "PropertyValue",
        "name": "Roast Level",
        "value": "Medium"
      },
      {
        "@type": "PropertyValue",
        "name": "Caffeine Content",
        "value": "High"
      }
    ]
  }
]
```

The above response contains 1 product along with price and stock information.

<Note>You don’t have to use an [schema.org/AggregateOffer](https://schema.org/AggregateOffer), you can just return a single [schema.org/Offer](https://schema.org/Offer).</Note>

#### Mandatory fields

* **name**

* **offers** (so we can extract a price — must include **price** and **priceCurrency**)

* **url** (so we can uniquely identify the product)

#### Optional but recommended fields

* **image**
* **sku** or **mpn** (set at the **Product** level — see [Product identifiers](#product-identifiers) below)

### Handling of multiple offers

Each entry in your feed represents **one indexed product row**. If a `Product` contains multiple `Offer` entries (or an `AggregateOffer` wrapping multiple inner offers), Molin only reads the **first offer** to extract `price`, `priceCurrency`, `availability`, and `mpn`. **All subsequent offers are ignored.**

If you sell product variants (different sizes, colors, SKUs, etc), you must return them as **separate `Product` objects** in the feed, each with its own `url`, `price`, and identifiers. Putting variants inside the `offers` array will cause every variant except the first to be silently dropped.

### Product identifiers

Molin stores a single `sku` value per product, used for keyword search (e.g. when a customer searches by part number). The value is resolved in this priority order:

1. `Product.sku` (top-level) — **recommended**
2. `Product.mpn` (top-level) — fallback when `sku` is missing
3. `offers[0].mpn` — fallback for feeds that put MPN only on the first offer
4. A `PropertyValue` named `MPN`/`SKU` inside `additionalProperty`
5. `Product.productGroupID` or `Product.isVariantOf.productGroupID` — see [Grouping variants](#grouping-variants)
6. `Product.productID` — per-variant identifier, used as a last resort

<Warning>
  Setting `mpn` on each `Offer` variant inside a single `Product` does **not** work for variant lookup. Only the first offer's `mpn` is read, and the rest are dropped. To make every MPN searchable,
  return each variant as its own top-level `Product` with the MPN set at the Product level (or inside its first/only `Offer`).
</Warning>

GTIN values are read from `gtin14`, `gtin13`, `gtin12`, `gtin8`, or `gtin` at the Product level (in that order of preference).

### Grouping variants

Variants must be emitted as **separate `Product` objects**, each with a **unique `url`** since rows are keyed by URL. To express that several rows belong to the same product line, use the standard schema.org [ProductGroup](https://schema.org/ProductGroup) fields:

* **`productID`** — unique identifier for the variant (per-Product). Used as a last-resort `sku` fallback when no `sku`/`mpn`/`gtin`/`productGroupID` is present.
* **`productGroupID`** — identifier shared by every variant in the same group. Either set it directly on each variant `Product`, or use the canonical nested form `isVariantOf: { "@type": "ProductGroup", "productGroupID": "..." }`. When no first-class `sku`/`mpn`/`gtin` is present, this value becomes the row's `sku` so all sibling variants are searchable by the group identifier.

#### Example: two variants of the same product line

```json theme={null}
[
  {
    "@context": "http://schema.org",
    "@type": "Product",
    "name": "Coffee Lenoa | Espresso — 250 g",
    "url": "https://shop.com/products/espresso?variant=250g",
    "productID": "ESP-250",
    "productGroupID": "ESPRESSO",
    "sku": "ESP-250",
    "offers": {
      "@type": "Offer",
      "price": "12.99",
      "priceCurrency": "USD",
      "availability": "http://schema.org/InStock"
    }
  },
  {
    "@context": "http://schema.org",
    "@type": "Product",
    "name": "Coffee Lenoa | Espresso — 1000 g",
    "url": "https://shop.com/products/espresso?variant=1000g",
    "productID": "ESP-1000",
    "isVariantOf": {
      "@type": "ProductGroup",
      "productGroupID": "ESPRESSO"
    },
    "sku": "ESP-1000",
    "offers": {
      "@type": "Offer",
      "price": "19.99",
      "priceCurrency": "USD",
      "availability": "http://schema.org/InStock"
    }
  }
]
```

### Providing extra attributes

You can include additional product attributes using the `additionalProperty` field from the [schema.org](https://schema.org/) specification. This allows you to provide custom properties that aren't part of the standard Product schema.

The `additionalProperty` field accepts an array of [PropertyValue](https://schema.org/PropertyValue) objects, each containing:

* **name** - The property name (e.g., "Origin", "Material", "Size")
* **value** - The property value (e.g., "Ethiopia", "Cotton", "Large")

#### Example usage

```json theme={null}
"additionalProperty": [
  {
    "@type": "PropertyValue",
    "name": "Origin",
    "value": "Ethiopia"
  },
  {
    "@type": "PropertyValue",
    "name": "Roast Level",
    "value": "Medium"
  },
  {
    "@type": "PropertyValue",
    "name": "Caffeine Content",
    "value": "High"
  }
]
```

This is particularly useful for:

* Product specifications (dimensions, materials, etc.)
* Custom categorization
* Brand-specific attributes
* Technical details that customers might ask about

<Note>Molin uses these additional properties to provide more detailed and accurate responses about your products when customers ask specific questions.</Note>

<Note>There is a limit of 20 attributes per product. Molin will ignore any additional attributes beyond this limit.</Note>

<Note>Product descriptions are limited to 4000 characters. Longer descriptions will be truncated.</Note>

### Retrieving 1 product

This is an optimization that we have not built yet.

If you have lots of products, it is more efficient to also offer a single product endpoint. For example, if a customer asks Molin about the stock of 1 specific product, we will update only this specific product (quicker than downloading all of them).

## Authentication

You may add header-based authentication that relies on a simple shared secret (token).

### Example

If you give us the token `M123ABC`, we will include the following header in all requests:

```
Authorization: M123ABC
```


# Feature releases
Source: https://docs.molin.ai/changelog/changelog

Stay updated with the latest Molin AI features, updates, and product improvements for your shop, from new channels to a smarter AI and a faster dashboard.

<AccordionGroup>
  <Accordion title="12 September 2026">
    * Shops with [voice mode](/home/widget/voice) on: the assistant now greets shoppers with a small bubble above the chat input saying it can talk too, in the language your widget speaks. It fades after 15 seconds and comes back on the next page the shopper opens, until they close it or tap the voice button
  </Accordion>

  <Accordion title="2 September 2026">
    * Ninja users: attach files up to 100 MB, twice the previous limit
    * Ninja users: attach Word, PowerPoint, RTF, and ZIP files, plus MP3, WAV, and M4A audio, on top of the [file types Ninja already accepted](/ninja/features#upload-files)
    * Ninja users: an MP4 or an audio file you attach now plays inside the chat, and you can jump to any point in it instead of downloading it first
  </Accordion>

  <Accordion title="30 August 2026">
    * Ninja users: ask for a video in 360p to try an idea cheaply, then re-run the one you like in 720p, 1080p, or 4K. A 360p draft costs a third of 720p and arrives faster
    * Ninja users: give Ninja a first picture and a last picture, and it creates the movement from one to the other
    * Ninja users: ask Ninja to continue a video it already made, and it adds to the clip instead of starting over. You are charged only for the part it adds
  </Accordion>

  <Accordion title="26 August 2026">
    * All shops: we fixed how we count the orders your assistant helped with. Each purchase now counts, but a conversation stops earning credit after 28 days. Across all shops, July's corrected total is about 1% higher than before, although an individual shop's result may rise or fall by much more
    * Vector Webshop shops: pick [Vector Webshop](/home/platforms/vector-webshop-feed) when you set up your assistant and paste the token from your Vector admin. Every variant of a product stays searchable on its own, so a monitor sold in 14 sizes is 14 products rather than one
    * Shops on any platform where something covers the chat bubble, like an add-to-cart bar that slides in when visitors scroll: [move the bubble out of the way](/home/widget/bubble-offset) with a CSS variable in your theme, and it returns to its normal spot when the bar goes away
  </Accordion>

  <Accordion title="20 August 2026">
    * All shops: ask the assistant for a product section and it now searches the whole section, not just the products filed directly at the top of it. Shops whose categories are several levels deep gain the most
    * UNAS shops selling spare parts: when a product description lists the machines a part fits, shoppers can ask for a part for their exact model and get it
    * [Search API](/home/general/search-api): a `category` filter now covers everything below that category, so you can build a category page from whichever level you want to show
  </Accordion>

  <Accordion title="19 August 2026">
    * Shopify and Shoprenter shops on a [product feed](/home/general/product-feeds): connect your platform directly to the assistant you already have, from Products → Source. You keep its settings, conversations, billing; and a direct connection gives you live stock, order status, and add-to-cart in chat
    * Shopify shops: uninstalling the app no longer deletes an assistant you had before you installed it. It now just disconnects your shop and leaves your products and chat history in place
  </Accordion>

  <Accordion title="18 August 2026">
    * Ninja users: rate answers with a thumbs up or down. We may also ask for a quick 0-10 score
    * UNAS shops: the assistant now recommends products whose stock has run out, as long as the shop is set to keep accepting orders for them. Previously it treated them as unavailable even while the storefront was still selling them
    * All new shops: out-of-stock products are recommended by default. Turn this off under Products settings
  </Accordion>

  <Accordion title="17 August 2026">
    * See delivery and bounce status on the emails you send from the Inbox
    * A faster dashboard and accessibility fixes across the app
  </Accordion>

  <Accordion title="14 August 2026">
    A big release: dynamic pop-ups, cart management in chat, and message feedback.

    * [Dynamic pop-up](/home/widget/dynamic-popup): the AI writes a fresh pop-up message for every visitor, based on the page they're viewing, their cart, previous conversations, and whether they arrived from an ad campaign
    * Shoppers and the AI can now add products to the cart directly from chat, and edit or view it too
    * Chat messages now have thumbs up/down buttons, so you get feedback from your shoppers
    * An AI disclosure label on the widget for EU AI Act compliance
    * Inbox: Chrome's built-in translation now works, and live chat status messages are translated into your widget's language
    * Improved email folders UI
  </Accordion>

  <Accordion title="5 August 2026">
    * Voice mode and phone calls now use a new transcription model for noticeably better accuracy
    * Compose brand-new emails from a Gmail-style dock in the Inbox
    * Reply drafts are saved server-side, so they follow you across devices and sessions
    * AI email replies are now generated on demand, when you ask for them
    * Your Inbox now automatically sorts conversations into folders
  </Accordion>

  <Accordion title="3 August 2026">
    * [Customers](/home/crm/customers): your chats turned into a lightweight CRM with orders, ticket history, notes, and tags
    * A new Analytics overview page with summary cards
    * A currency exchange tool, so the AI can answer price conversion questions
  </Accordion>

  <Accordion title="24 July 2026">
    * A redesigned link clicks table in Analytics
    * Fixed the dashboard showing an old logo after you upload a new one
  </Accordion>

  <Accordion title="16 June 2026">
    The AI now searches your product catalog in your shop's language first, which fixes irrelevant results on non-English catalogs, plus more product search relevance fixes.
  </Accordion>

  <Accordion title="15 June 2026">
    * [Elements](/home/general/elements): prebuilt components you embed on your store with a single HTML tag, no JavaScript needed
    * A new Intercom-style [floating bar](/home/widget/floating-bar)
    * Full-screen mode for the chat widget
  </Accordion>

  <Accordion title="9 June 2026">
    * [Instagram DM support](/home/channels/instagram): connect your Instagram Professional account and let Molin answer DMs
    * Web search is now available for all widgets, and the AI retries it automatically when it detects a hallucinated answer
    * Reports is now called Analytics
  </Accordion>

  <Accordion title="2 June 2026">
    * Web search tool: the AI can search the live web for answers, enable it per widget
    * Faceted search: shoppers can filter product results by attributes like brand or color, based on what your catalog provides
  </Accordion>

  <Accordion title="May 2026">
    * [Email channel](/home/channels/email): your support emails now land in the Inbox and the AI drafts replies, with a custom sending domain and an onboarding wizard
    * Faster, more stable AI responses with Google's priority mode and OpenAI's latest API
    * Product discovery: the AI recommends products more proactively and accurately
    * Live chat emails are now translated (EN, HU, RO, DE) with Molin branding
  </Accordion>

  <Accordion title="April 2026">
    * Shopify event tracking: checkouts, product views, and cart events flow into your analytics
    * Google feeds now read item\_group\_id as a SKU fallback
    * Shoppers see a friendly modal when they hit your conversation limit
    * The widget now previews inside the Shopify theme editor
  </Accordion>

  <Accordion title="March 2026">
    * Live chat labels and streaming text are translated into your widget's language
    * Redesigned priority selector for conversations
  </Accordion>

  <Accordion title="February 2026">
    * Inbox: search, archive, read status, and email forwarding
    * Voice dictation in the chat widget
    * Priority levels for conversations
    * [Facebook](/home/channels/facebook-messenger): native product cards in Messenger
    * Customer contact details are saved and shown in the Inbox
    * Expand/collapse the chat dialog
    * UNAS multi-language support
  </Accordion>

  <Accordion title="January 2026">
    * Search by SKU
    * Add-to-cart links for Shopify products in chat
    * Molin-branded layout for live chat emails
    * Inbox message translation
    * More reliable Facebook page connections
    * Shipping cost on the order card
  </Accordion>

  <Accordion title="December 2025">
    * The Inbox is now translated into your language
    * Gemini models available for your chatbot
    * Image viewer polish: ESC to close, loading states
  </Accordion>

  <Accordion title="November 2025">
    * GPT-5 now powers chatbots
    * New order cancellations metric for Shopify in Analytics
    * The live chat typing indicator shows the agent's photo
  </Accordion>

  <Accordion title="October 2025">
    * Shopify metafields support for products and orders
    * Document auto-refresh, with a toggle in settings
    * A new Publish page on all platforms
    * A faster products table with search
  </Accordion>

  <Accordion title="September 2025">
    * Shoppers can now send images to your chatbot
    * Full-screen image viewer in chat
    * [Documents](/home/knowledge/documents) auto-refresh to keep the AI's knowledge fresh
    * An optional AI disclaimer in the widget
    * Much faster product search
  </Accordion>

  <Accordion title="August 2025">
    * Semantic product search: the AI finds products by meaning, not just keywords
    * [Google Analytics tracking](/home/marketing/integrations/google-analytics): widget events flow into your GA via dataLayer
    * Product images in chat answers
    * The floating Ask AI element is now available on all plans
    * Lead collection emails now include the store URL
  </Accordion>

  <Accordion title="July 2025">
    * Custom bubble icon and bubble sizing (Scale plan)
    * A [showChat API](/apis/experimental/show-hide-widget) to open the chat programmatically
    * Unified GTIN product identification
    * Better link click analytics
  </Accordion>

  <Accordion title="June 2025">
    Order statuses now include parcel tracking data.
  </Accordion>

  <Accordion title="April–May 2025">
    * A redesigned onboarding flow
    * [Working hours](/home/inbox/working-hours) with proper timezone handling
    * Heureka feed support
  </Accordion>

  <Accordion title="Introducing full personalization with user data - March 2025">
    For all shops connected via [Plugins](https://molin.ai/integrations), we're rolling out the full personalisation feature for logged in user.

    If a user is logged in, the Molin knows the personal details such as name, email, location, and also order history, current items in the cart, loyalty points and coupon codes.

    This way the AI can tailor its responses and product recommendations to the customer offering a fully personalized conversational shopping experience.

    Watch this video: [https://www.loom.com/share/6e7c9112187649e487913ba2907c4b53?sid=16b90ad4-62ee-4d03-82f8-105c7d0f24f9](https://www.loom.com/share/6e7c9112187649e487913ba2907c4b53?sid=16b90ad4-62ee-4d03-82f8-105c7d0f24f9)
  </Accordion>

  <Accordion title="Knowledge of the current page - Feb 2025">
    After we added full website downloads, we're bringing you the first built in personalization feature – current page context.

    Molin knows the current page of the user and can answer vague questions, such as, "Do you have this in size 9?".

    As these questions were lacking context traditionally, Molin always had to ask back and then do a search. This is changing now. See the example below:

    ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/0fd5040a-05f9-42e4-c285-a8683a782e00/q=75,dpr=1)
  </Accordion>

  <Accordion title="PDF uploads + webpage scraping - Feb 2025">
    Today, we're releasing Document support for all Molin chatbots. From now on, you can submit entire websites, sitemaps, single pages and PDFs to train Molin on all of your data. As soon as you add documents, Molin learns them and answers questions accordingly.

    We hope this will help a lot with training your AIs and keeping them up-to-date. Furthermore, we refresh the uploaded pages every 7 days to keep the knowledge fresh.

    Navigate to the [Documents](https://molin.ai/app/documents) page and start uploading your data [here](https://molin.ai/app/documents#add)!

    ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/0c6d7453-b584-4f26-2a4d-bccf9cbd3400/fit=scale-down,q=75)
  </Accordion>

  <Accordion title="New Shopify app with AI actions - Feb 2025">
    We have moved from an embedded Shopify app to a standalone application and added new AI actions. From now on, you can manage your Shopify app support via the Molin [Dashboard](https://molin.ai/app). New AI actions:

    * Order statuses with tracking link
    * Order cancellations with automatic refunds and restocking
    * Human handover with live chat

    Install our brand new app from the Shopify app store [here](https://apps.shopify.com/molin-ai).
  </Accordion>

  <Accordion title="API: Inject custom instructions to user sessions - Jan 25">
    Use our new API to inject specific user data or custom prompt to the AI for each user session. This way Molin's knowledge can be tailord to the end user and the user's current section. Read the docs [here](/apis/experimental/personalization-api)
  </Accordion>

  <Accordion title="API: Show/hide chat programatically - Jan 25">
    You can programmatically control when the Molin AI widget is shown or hidden on your pages. This is useful for hiding the chatbot on specific pages (e.g. checkout, terms of service), showing the widget only after certain conditions are met, managing widget visibility inside iframes. Read the docs [here](/apis/experimental/show-hide-widget)
  </Accordion>

  <Accordion title="Generated UI components in chat - Jan 25">
    The chatbot can now render UI elements, such as product cards, lists, order details, order tracking card in chat on demand. The UI elements support all the languages and can be renderred in many ways.
  </Accordion>

  <Accordion title="Optimising script load speads - Dec 24">
    We made the script lighter and faster. Now the chatbot loads in a few miliseconds, not slowing down the page speed of the website.
  </Accordion>

  <Accordion title="UTM parameters in AI chat links - Nov 24">
    When users click on links in the Molin chat, UTM parameters are automatically added to the links provided by the AI. This way you can track the activity of the AI right in your analytics tool automatically, such as Google Analytics. Read more [here](/home/general/utm).
  </Accordion>

  <Accordion title="Custom Actions API - Nov 2024">
    We have launched the custom AI actions API to allow any kind of custom actions to work with Molin. Connect Molin to all your systems with a generalised custom AI action solution.
  </Accordion>

  <Accordion title="Team functionality - October 2024">
    Invite your colleagues to Molin and work in a team. Team members can have 2 roles - Admin and Agent. Admin has access to all functionality, whereas agents only get to operate the Inbox and their own Sidekick. This way the agents cannot reset the settings of the AI.
  </Accordion>

  <Accordion title="Multiple chatbots in 1 account - October 2024">
    Create and manage an unlimited number of chatbots in one account. Each chatbot works as a separate entity within the same team account, so each of them can be connected to any platform. For example, 1 can be connected to your Shopify shop, the other one to your Woocommerce shop all in the same account.
  </Accordion>

  <Accordion title="Modern chatbot design - September 2024">
    Released a brand new design for the chatbot layout to make it unique.
  </Accordion>
</AccordionGroup>


# Analytics & reports
Source: https://docs.molin.ai/home/analytics/reports

See how many people chat with your AI, how much time and money it saved you, and how much it contributes to your sales.

The Analytics page shows what your chatbot has been doing over the time period you pick.

<Note>Find it in your dashboard under [**Analytics**](https://molin.ai/app/reports).</Note>

## The three tabs

### Customer support

* **Conversations**: how many chats happened.
* **Messages**: how many messages were exchanged.
* **Time saved**: how much support time the AI handled for you.
* **Money saved**: an estimate of the support cost the AI saved.
* **Order status resolutions**: how many times the AI helped a customer with their order.
* **Order cancellations**: how many cancellations went through the chat.
* **Conversation length avg.**: how long an average chat lasts.
* **Response time**: how fast the AI replies.

### Sales

* **Visitor checkouts**: how many people who chatted went on to check out.
* **AI-assisted checkout details**: the individual checkouts behind the visitor checkout count.
* **Leads collected**: how many leads the AI captured.
* **Estimated revenue uplift**: an estimate of the extra revenue from chats.
* **Revenue per lead**: average value of a lead.

<Note>An AI-assisted checkout means the checkout was detected after the visitor received a chatbot response.</Note>

### Live Chat

* **Total Sessions**: how many live chats your team handled.
* **Agents**: who was on live chat.
* **CSAT**: customer satisfaction score for live chat sessions.

## How to use it

* **Pick a time range** at the top of the page.
* **Switch tabs** to look at support, sales, or live chat.
* **Check it once a week** to see if numbers are going up.


# Email
Source: https://docs.molin.ai/home/channels/email

Forward your support inbox to Molin so the AI can read incoming customer emails, draft replies in your tone, and send them for you.

Connect your support email to Molin so the AI can read incoming customer emails, draft replies in your tone, and send them on your behalf. All email conversations show up in the [Inbox](https://molin.ai/app/inbox) alongside web chat, Messenger, and Instagram.

## How it works

Molin gives each widget a unique inbound address (for example `panda-pod-trick@gt010n7t.molin.email`). You set up a forwarding rule in your existing email provider so a copy of every incoming customer email is delivered to that address. From there, Molin:

* detects the customer, threads the conversation, and routes attachments
* generates a draft reply with one click in the Inbox, using the same AI and instructions that power your web widget
* sends the reply from your domain (or from `@molin.email` until you connect a custom domain)

You keep using your existing inbox. Molin acts as an additional recipient, not a replacement.

## Set up forwarding

Pick your email provider and follow the step-by-step guide.

<CardGroup>
  <Card title="Gmail" href="/home/channels/email/forwarding/gmail">
    Google Workspace and personal Gmail accounts
  </Card>

  <Card title="Outlook" href="/home/channels/email/forwarding/outlook">
    Microsoft 365, Outlook.com, and Hotmail
  </Card>

  <Card title="iCloud Mail" href="/home/channels/email/forwarding/icloud">
    Apple iCloud and `@icloud.com` addresses
  </Card>

  <Card title="Yahoo Mail" href="/home/channels/email/forwarding/yahoo">
    Yahoo Mail (requires Yahoo Mail Plus)
  </Card>
</CardGroup>

<Tip>If your provider isn't listed, look for "forwarding" or "auto-forward" in its settings. The Molin inbound address is the only thing you need from us.</Tip>

## Platform-specific guides

If your support email is tied to your ecom platform's domain hosting (rather than to a separate mail provider), use these guides instead.

<CardGroup>
  <Card title="Shopify" href="/home/channels/email/forwarding/shopify">
    Forward from a Shopify-managed custom domain
  </Card>

  <Card title="UNAS" href="/home/channels/email/forwarding/unas">
    Forward from an UNAS-hosted domain
  </Card>
</CardGroup>

## Send from your own domain

By default Molin sends replies from a `@molin.email` subdomain, which works immediately but shows the Molin domain to your customers. To send from your own domain (for example `support@yourshop.com`), connect a custom domain from the email setup wizard. You'll add 4 NS records at your registrar that delegate a subdomain (for example `molin.yourshop.com`) to Molin, so we manage email authentication (DKIM, SPF, MX) for you and your replies don't land in spam.

Step-by-step guides for adding the records at common registrars:

<CardGroup>
  <Card title="Cloudflare" href="/home/channels/email/dns/cloudflare">
    Add the NS records on Cloudflare DNS
  </Card>

  <Card title="GoDaddy" href="/home/channels/email/dns/godaddy">
    Add records via the GoDaddy DNS manager
  </Card>

  <Card title="Namecheap" href="/home/channels/email/dns/namecheap">
    Add records via Namecheap Advanced DNS
  </Card>

  <Card title="Shopify" href="/home/channels/email/dns/shopify">
    Workarounds for Shopify-managed domains
  </Card>

  <Card title="Shoprenter" href="/home/channels/email/dns/shoprenter">
    Find your registrar and add the records there
  </Card>

  <Card title="UNAS" href="/home/channels/email/dns/unas">
    Find your registrar and add the records there
  </Card>
</CardGroup>

If your registrar isn't listed, the wizard still shows the exact records to add and verifies them automatically — most registrars have an **Add record** form with the same Type / Name / Value fields.


# Add Molin DNS records on Cloudflare
Source: https://docs.molin.ai/home/channels/email/dns/cloudflare

Publish the four NS records Molin gives you when connecting a custom sending domain, using Cloudflare's DNS dashboard.

When you connect a custom sending domain in Molin, the wizard shows you 4 NS records to add at your registrar. This guide covers adding them in Cloudflare's DNS dashboard.

<Note>
  You only need this guide if Cloudflare manages DNS for the domain you're connecting. If your domain is registered at Cloudflare but uses another DNS provider's nameservers, follow the guide for that
  provider instead.
</Note>

## Prerequisites

* A Cloudflare account with the domain you want to use already added
* The exact records Molin shows you in the [email setup wizard](https://molin.ai/app/channels/email) (4 NS records)

## Steps

1. Open the [Cloudflare dashboard](https://dash.cloudflare.com/) and select the domain you want to use
2. Click **DNS → Records** in the left sidebar
3. For each **NS** record shown in the Molin wizard:
   1. Click **Add record**
   2. Set **Type** to `NS`
   3. Set **Name** to the value shown in the wizard's **Name** column — this is the subdomain you chose to connect (e.g. enter `molin` if you connected `molin.yourshop.com`, or `@` for a root domain)
   4. Paste the nameserver value (e.g. `ns1.molin.ai`) into **Server**
   5. Click **Save**
   6. Repeat for the remaining 3 NS records

## Critical: keep the proxy off

Cloudflare's orange-cloud proxy must be **off** for NS records. NS records cannot be proxied at all (Cloudflare will reject the save).

For each record you add, ensure the proxy column shows the grey cloud (DNS only), not the orange cloud (proxied). New NS records are forced to grey by default; double-check after saving.

## Verify

1. Return to the Molin email setup wizard
2. Click **Verify now**
3. The wizard polls every 30 seconds automatically, so you can also wait — verification typically completes within 5 minutes of saving in Cloudflare

If verification fails, Cloudflare DNS changes take effect in under a minute, so the cause is almost always a typo in the subdomain or a missing record. The wizard tells you which specific record didn't match.

## Reference

For Cloudflare's own documentation, see [Add DNS records](https://developers.cloudflare.com/dns/manage-dns-records/how-to/create-dns-records/).


# Add Molin DNS records on GoDaddy
Source: https://docs.molin.ai/home/channels/email/dns/godaddy

Publish the four NS records Molin gives you when connecting a custom sending domain, using GoDaddy's DNS management page.

When you connect a custom sending domain in Molin, the wizard shows you 4 NS records to add at your registrar. This guide covers adding them in GoDaddy.

<Note>You only need this guide if GoDaddy manages DNS for the domain you're connecting. If you transferred DNS to another provider (e.g. Cloudflare), follow that provider's guide instead.</Note>

## Prerequisites

* A GoDaddy account with the domain you want to use
* The exact records Molin shows you in the [email setup wizard](https://molin.ai/app/channels/email) (4 NS records)

## Steps

1. Sign in at [godaddy.com](https://godaddy.com/) and open the [Domain Portfolio](https://dcc.godaddy.com/control/portfolio)
2. Select your domain to open the **Domain Settings** page
3. Select **DNS** to view your DNS records
4. For each **NS** record shown in the Molin wizard:
   1. Click **Add New Record** and choose **NS** from the **Type** menu
   2. Set **Name** to the value shown in the wizard's **Name** column — this is the subdomain you chose to connect (e.g. enter `molin` if you connected `molin.yourshop.com`, or `@` for a root domain)
   3. Paste the nameserver value (e.g. `ns1.molin.ai`) into **Value**
   4. Leave **TTL** at the default (1 hour)
   5. Click **Save** (or **Save All Records** if you added multiple at once via **Add More Records**)

## Verify

1. Return to the Molin email setup wizard
2. Click **Verify now**

GoDaddy DNS changes usually take effect in 30 seconds to a few minutes, occasionally up to an hour. The Molin wizard checks every 30 seconds, so you can leave it open while you wait.

## Troubleshooting

* **GoDaddy strips the trailing dot from NS values** — that's fine. Paste `ns1.molin.ai` (no trailing dot) and let GoDaddy normalize it.
* **"This record already exists" error on an NS record** — GoDaddy creates default NS records for new subdomains. Delete any existing NS records on the same Name before adding the Molin ones, otherwise they clash and verification fails.

## Reference

For GoDaddy's own documentation, see [Add an NS record](https://www.godaddy.com/help/add-an-ns-record-19212) for the NS-specific flow and [Manage DNS records](https://www.godaddy.com/help/manage-dns-records-680) for the general DNS editor.


# Add Molin DNS records on Namecheap
Source: https://docs.molin.ai/home/channels/email/dns/namecheap

Publish the four NS records Molin gives you when connecting a custom sending domain, using Namecheap's Advanced DNS panel.

When you connect a custom sending domain in Molin, the wizard shows you 4 NS records to add at your registrar. This guide covers adding them in Namecheap's Advanced DNS panel.

<Warning>
  This guide assumes you're using **Namecheap BasicDNS** or **PremiumDNS** (the default for domains registered at Namecheap). If you pointed your domain's nameservers at a third party (e.g. Cloudflare
  or Google Domains), follow that provider's guide instead — records added in Namecheap will be ignored.
</Warning>

## Prerequisites

* A Namecheap account with the domain you want to use
* The exact records Molin shows you in the [email setup wizard](https://molin.ai/app/channels/email) (4 NS records)

## Steps

1. Sign in at [namecheap.com](https://namecheap.com/) and open the [Domain List](https://ap.www.namecheap.com/domains/list/)
2. Click **Manage** next to the domain you want to use
3. Open the **Advanced DNS** tab
4. Confirm the **Nameservers** field at the top says **Namecheap BasicDNS** or **Namecheap PremiumDNS**. If it says **Custom DNS**, your records belong elsewhere — see the warning above
5. Under **Host Records**, click **Add New Record** for each Molin NS record:
   1. Set **Type** to `NS RECORD`
   2. Set **Host** to the value shown in the wizard's **Name** column — this is the subdomain you chose to connect (e.g. `molin` if you connected `molin.yourshop.com`)
   3. Paste the nameserver value into **Nameserver** (e.g. `ns1.molin.ai`)
   4. Leave **TTL** at **Automatic**
   5. Click the green checkmark to save the row
   6. Repeat for the remaining 3 NS records
6. Click **Save All Changes** at the top of the Host Records table

## Verify

1. Return to the Molin email setup wizard
2. Click **Verify now**

Namecheap BasicDNS changes usually take effect in 1–2 minutes. PremiumDNS is faster, often under 30 seconds.

## Troubleshooting

* **The Advanced DNS tab is missing** — you're on the **Domain** tab. Look for the tab strip at the top of the page; **Advanced DNS** sits next to **Sharing & Transfer**.
* **NS records won't save because of "duplicate host"** — Namecheap auto-creates default NS records on new subdomains. Delete any existing rows on the same Host before adding the Molin ones, then save.
* **Verification fails after a clean copy** — confirm the **Host** field matches Molin's subdomain prefix exactly, a missing or mistyped prefix is the most common cause.

## Reference

For Namecheap's own documentation, see [How can I set up Custom DNS records](https://www.namecheap.com/support/knowledgebase/article.aspx/9776/2237/how-can-i-set-up-custom-dns-records-acname-mx-txt-srv-aaaa-caa-for-my-domain/).


# Add Molin DNS records for a Shopify domain
Source: https://docs.molin.ai/home/channels/email/dns/shopify

Shopify's DNS editor can't add NS records, so here are the workarounds for connecting a custom sending domain on a Shopify-managed domain.

When you connect a custom sending domain in Molin, the wizard shows you 4 NS records to add at your DNS provider. This guide covers what to do when your domain is registered or managed through Shopify.

<Warning>
  Shopify's built-in DNS editor does **not** support `NS` records — it only allows `A`, `AAAA`, `CNAME`, `MX`, `TXT`, and `SRV`. You cannot add Molin's nameserver records inside Shopify directly. The
  two workarounds below are the only paths that work.
</Warning>

## Prerequisites

* A Shopify store with the domain you want to use
* The exact records Molin shows you in the [email setup wizard](https://molin.ai/app/channels/email)

## Option A — recommended: move DNS to Cloudflare (free)

Cloudflare lets you keep the domain registered at Shopify while taking over DNS hosting, so you can add `NS` records that Shopify's editor wouldn't accept.

<Warning>
  Switching nameservers controls your entire domain, including your storefront and existing email. If a record is missed during the move, your website can go offline. We strongly recommend asking your
  developer or IT team to do this for you.
</Warning>

1. Sign up for a free [Cloudflare account](https://dash.cloudflare.com/sign-up).
2. Add your domain to Cloudflare. Cloudflare will scan your existing Shopify DNS and import the `A`, `CNAME`, and `MX` records that point at Shopify so the storefront keeps working.
3. Cloudflare will show you a pair of nameservers (e.g. `gabe.ns.cloudflare.com`, `nora.ns.cloudflare.com`).
4. In the Shopify admin, open **Settings → Domains**, click the domain, then click **DNS settings**. Find the **Nameservers** section near the top and replace Shopify's nameservers with Cloudflare's. Save.
5. Wait for the change to take effect (usually under an hour). Cloudflare will email you when it's done.
6. Once Cloudflare manages your DNS, follow the [Cloudflare guide](/home/channels/email/dns/cloudflare) to add the Molin records.

## Option B — use a subdomain on a different domain

If you can't move DNS off Shopify, you can use a different domain you already own for sending (one whose DNS is managed by Cloudflare, GoDaddy, or Namecheap).

1. Click **Back** at the bottom of the custom-domain step in the Molin wizard.
2. Enter a sending subdomain on a different domain whose DNS is managed by one of the supported providers (e.g. `molin.yourshop.com` if your storefront is `yourshop.myshopify.com`).
3. Add the records there following that provider's guide.

The sending domain doesn't have to match your storefront domain.

## Verify

1. Return to the Molin email setup wizard
2. Click **Verify now**
3. The wizard polls every 30 seconds, so you can also wait. Verification completes within a few minutes of the records being live.

## Reference

For Shopify's documentation on DNS limitations, see [Edit your domain's DNS settings](https://help.shopify.com/en/manual/online-store/domains/managing-domains/edit-dns-settings).


# Add Molin DNS records for a Shoprenter domain
Source: https://docs.molin.ai/home/channels/email/dns/shoprenter

Shoprenter doesn't host DNS, so find your domain registrar and add the NS records Molin shows you when connecting a custom sending domain.

When you connect a custom sending domain in Molin, the wizard shows you 4 NS records to add at your DNS provider. This guide covers what to do when your shop runs on Shoprenter.

<Note>
  Shoprenter doesn't host DNS itself. Your domain's records live at the registrar where you bought the domain — commonly [DotRoll](https://dotroll.com/) or another Hungarian registrar. This guide
  walks you through finding that registrar and adding the records there.
</Note>

## Prerequisites

* A Shoprenter admin login
* Login credentials for whichever registrar manages your domain
* The exact records Molin shows you in the [email setup wizard](https://molin.ai/app/channels/email)

## Step 1 — find your registrar

1. Sign in to your Shoprenter admin
2. Open **Beállítások → Domain nevek** (Settings → Domain names)
3. Note the registrar listed next to your domain — that's where you'll add the DNS records

If Shoprenter's domain panel doesn't show a registrar, the registrar is whoever you paid for the domain (look at your past invoices or check email confirmations).

## Step 2 — add the records at your registrar

The exact UI varies by registrar, but the steps are the same:

1. Sign in to the registrar's control panel
2. Find the **DNS** / **Zone Editor** / **Zóna szerkesztő** section for your domain
3. For each `NS` record shown in the Molin wizard:
   1. Add a new record
   2. Set **Type** to `NS`
   3. Set **Host** / **Name** / **Név** to the value shown in the wizard's **Name** column — this is the subdomain you chose to connect (e.g. `molin` if you connected `molin.yourshop.com`)
   4. Paste the nameserver value (e.g. `ns1.molin.ai`) into **Value** / **Target** / **Nameserver** / **Cél**
   5. Save
   6. Repeat for the remaining 3 NS records

## DotRoll specifics

Many Shoprenter shops use [DotRoll](https://dotroll.com/) as their registrar:

1. Sign in at [dotroll.com](https://dotroll.com/en/login)
2. Click your domain to open it
3. Open the **DNS** tab
4. Use **Új rekord hozzáadása** (Add new record) for each NS row

## If your registrar doesn't let you edit DNS

Some small registrars don't give you a DNS editor at all. The simplest fix:

1. Sign up for a free [Cloudflare account](https://dash.cloudflare.com/sign-up)
2. Add your domain and let Cloudflare scan your existing DNS
3. Cloudflare gives you a pair of nameservers — go back to your registrar and replace your domain's nameservers with Cloudflare's
4. Once it takes effect (under an hour), follow the [Cloudflare guide](/home/channels/email/dns/cloudflare) to add the Molin records

## Verify

1. Return to the Molin email setup wizard
2. Click **Verify now**
3. The wizard polls every 30 seconds — verification completes within a few minutes of the records being live

If you don't know which registrar runs your DNS, use the **Send this to your developer** button in the wizard — it copies a ready-to-send message with all the records.

## Reference

For Shoprenter's own documentation (Hungarian), see [Domain átirányítás](https://support.shoprenter.hu/hc/hu/articles/215106978-Domain-%C3%A1tir%C3%A1ny%C3%ADt%C3%A1s), [Rackhostnál regisztrált domain beállítása](https://support.shoprenter.hu/hc/hu/articles/5008523684509), and [MediaCenternél regisztrált domain beállítása](https://support.shoprenter.hu/hc/hu/articles/115000658588). These cover Shoprenter's general DNS flow at the two most common Hungarian registrars; for NS records specifically you'll still need to follow your registrar's own DNS editor docs.


# Add Molin DNS records for a UNAS domain
Source: https://docs.molin.ai/home/channels/email/dns/unas

UNAS doesn't host DNS, so find your domain registrar and add the NS records Molin shows you when connecting a custom sending domain.

When you connect a custom sending domain in Molin, the wizard shows you 4 NS records to add at your DNS provider. This guide covers what to do when your shop runs on UNAS.

<Note>
  UNAS doesn't host DNS itself. Your domain's records live at the registrar (regisztrátor) where the domain was purchased — commonly [Nethely](https://www.nethely.hu/),
  [DotRoll](https://dotroll.com/), or another Hungarian registrar. This guide walks you through finding that registrar and adding the records there.
</Note>

## Prerequisites

* A UNAS admin login
* Login credentials for whichever registrar manages your domain
* The exact records Molin shows you in the [email setup wizard](https://molin.ai/app/channels/email)

## Step 1 — find your registrar

1. Sign in to your UNAS admin
2. Open **Beállítások → Domain** (Settings → Domain)
3. Look for the **regisztrátor** field listed against your domain — that identifies where the DNS records actually need to go

If UNAS shows no registrar at all, check your past invoices or the original confirmation email from when you purchased the domain.

## Step 2 — add the records at your registrar

The exact UI varies by registrar, but the steps are the same:

1. Sign in to the registrar's control panel
2. Find the **DNS** / **Zóna szerkesztő** (Zone editor) section for your domain
3. For each `NS` record shown in the Molin wizard:
   1. Add a new record
   2. Set **Type** to `NS`
   3. Set **Host** / **Name** / **Név** to the value shown in the wizard's **Name** column — this is the subdomain you chose to connect (e.g. `molin` if you connected `molin.yourshop.com`)
   4. Paste the nameserver value (e.g. `ns1.molin.ai`) into **Value** / **Target** / **Nameserver** / **Cél**
   5. Save
   6. Repeat for the remaining 3 NS records

## Nethely specifics

If your domain is at [Nethely](https://www.nethely.hu/):

1. Sign in to the Nethely admin
2. Open **Domain kezelés** (Domain management)
3. Click your domain, then open **DNS beállítások** (DNS settings)
4. Use the **Új rekord** (New record) button for each NS row

## If your registrar doesn't let you edit DNS

Some small registrars don't give you a DNS editor at all. The simplest fix:

1. Sign up for a free [Cloudflare account](https://dash.cloudflare.com/sign-up)
2. Add your domain and let Cloudflare scan your existing DNS
3. Cloudflare gives you a pair of nameservers — go back to your registrar and replace your domain's nameservers with Cloudflare's
4. Once it takes effect (under an hour), follow the [Cloudflare guide](/home/channels/email/dns/cloudflare) to add the Molin records

## Verify

1. Return to the Molin email setup wizard
2. Click **Verify now**
3. The wizard polls every 30 seconds — verification completes within a few minutes of the records being live

If you don't know which registrar runs your DNS, use the **Send this to your developer** button in the wizard — it copies a ready-to-send message with all the records.

## Reference

For UNAS's own documentation (Hungarian), see [DNS zóna módosítás](https://unas.hu/tudastar/hosting/dns-zona-modositas) and [Domain beállítások](https://unas.hu/tudastar/ugyfelfiok/domain-beallitasok). Note: the UNAS DNS zone editor lists support for A, CNAME, MX, and TXT records but does **not** mention NS records — that's why this guide routes you to the underlying registrar instead.


# Forward Gmail to Molin
Source: https://docs.molin.ai/home/channels/email/forwarding/gmail

Set up Gmail or Google Workspace forwarding so a copy of every customer email reaches your Molin inbound address and the AI can reply.

This guide walks you through Gmail's built-in forwarding setting so a copy of every incoming email is sent to your Molin inbound address. Works for both Google Workspace and personal `@gmail.com` accounts.

<Note>
  The fastest way to set this up is the email setup wizard at [molin.ai/app/channels/email](https://molin.ai/app/channels/email), which guides you through these same steps and detects Google's
  verification email for you.
</Note>

## Prerequisites

* A Gmail or Google Workspace account
* Your **Molin inbound address** from the email setup wizard (looks like `panda-pod-trick@gt010n7t.molin.email`)

## Steps

1. Open Gmail's [forwarding settings](https://mail.google.com/mail/u/0/#settings/fwdandpop) directly, or go to **Settings → See all settings → Forwarding and POP/IMAP**
2. Click **Add a forwarding address**
3. Paste your Molin inbound address and click **Next**
4. Click **Proceed**, then **OK**. Gmail sends a verification email to your Molin address
5. Wait for Molin to receive the verification email
   * In the Molin email setup wizard, the confirmation link surfaces automatically within a few seconds
   * If you're doing this manually, ask your team to fetch the link from the inbound address (or use the wizard)
6. Click the confirmation link Gmail sent. This proves you own the destination address
7. Back in Gmail's forwarding settings, select **Forward a copy of incoming mail to** and pick your Molin address from the dropdown
8. Choose what Gmail should do with the original — we recommend **keep Gmail's copy in the Inbox** so your team still sees the email
9. Click **Save Changes** at the bottom of the page

<Tip>
  Forwarding only applies to mail that arrives *after* you save. To also process emails received earlier, create a Gmail filter with **Forward it to:** set to your Molin address and apply the filter
  to existing matching conversations.
</Tip>

## Filter by sender (optional)

If you only want to forward emails sent to a specific support alias (for example `help@yourshop.com`), use a Gmail filter instead of global forwarding:

1. Click the search bar's filter icon at the top of Gmail
2. Set **To** to your support alias and click **Create filter**
3. Tick **Forward it to:** and choose your Molin address from the dropdown
4. Click **Create filter**

## Troubleshooting

* **The verification email never arrives** — check that you pasted the Molin address correctly. The part before the `@` is three lowercase words joined by dashes (for example `panda-pod-trick`).
* **Forwarding option is greyed out in Google Workspace** — your Workspace admin may have disabled external forwarding. Ask them to allow forwarding to `molin.email`.

## Reference

For Gmail's own documentation, see [Automatically forward Gmail messages to another account](https://support.google.com/mail/answer/10957). If you use Google Workspace and forwarding is disabled in your account, your admin needs to enable it — see [Let users automatically forward their own Gmail emails](https://support.google.com/a/answer/14724207).


# Forward iCloud Mail to Molin
Source: https://docs.molin.ai/home/channels/email/forwarding/icloud

Set up iCloud Mail forwarding, either globally or per rule, so customer emails reach your Molin inbound address and the AI can reply.

iCloud Mail supports two ways to forward: a global "forward all messages" toggle, and a per-rule forward action you create from icloud.com. The per-rule approach is better if you only want to forward specific support emails.

## Prerequisites

* An iCloud Mail account
* Your **Molin inbound address** from the email setup wizard

## Forward all incoming mail

1. Open [icloud.com/mail](https://icloud.com/mail) and sign in
2. Click the **Settings** button at the top of the Mailboxes list, then choose **Settings** in the menu that appears
3. Select **Mail Forwarding** in the sidebar
4. Tick **Forward my email to** and paste your Molin inbound address
5. Leave **Delete messages after forwarding** **off** so your inbox keeps the originals
6. Click **Done**

## Forward only specific emails (rule-based)

If you only want to forward emails sent to your support alias, create a rule instead:

1. Open [icloud.com/mail](https://icloud.com/mail) and sign in
2. Click the **Settings** button at the top of the Mailboxes list, then choose **Settings** in the menu that appears
3. Select **Rules** in the sidebar, then **Add a Rule**
4. Under **If a message**, set the condition (for example, **is addressed to → [support@yourshop.com](mailto:support@yourshop.com)**)
5. Under **Then**, choose **Forward to** and paste your Molin inbound address
6. Click **Done**

## Verification

iCloud sends a verification email to your Molin address before forwarding starts. The email setup wizard at [molin.ai/app/channels/email](https://molin.ai/app/channels/email) surfaces it as a one-click confirmation button — use it for the fastest path. If you're setting up manually, open the verification email in the Molin [Inbox](https://molin.ai/app/inbox) and click the link inside.

## Troubleshooting

* **No emails arrive at Molin** — double-check the destination address in the iCloud settings. The part before the `@` is three lowercase words joined by dashes (for example `panda-pod-trick`).
* **Forwarding option not visible in some regions** — Apple has occasionally restricted iCloud Mail features by region. If the **Mail Forwarding** sidebar entry is missing, sign in to icloud.com on a desktop browser (the mobile web view hides it).

## Reference

For Apple's own documentation, see [Automatically forward email in Mail on iCloud.com](https://support.apple.com/guide/icloud/automatically-forward-email-mm6b1a3960/icloud).


# Forward Outlook to Molin
Source: https://docs.molin.ai/home/channels/email/forwarding/outlook

Set up an Outlook.com, Hotmail, or Microsoft 365 forwarding rule so customer emails reach your Molin inbound address and the AI can reply.

This guide covers Microsoft 365 (work / school accounts), Outlook.com, and Hotmail. The two flows are slightly different — pick the one that matches your account type.

## Prerequisites

* An Outlook.com, Hotmail, or Microsoft 365 mailbox
* Your **Molin inbound address** from the email setup wizard

## Microsoft 365 (work or school)

Microsoft 365 lets you forward at the mailbox level (admin-controlled) or per inbox rule (user-controlled). The inbox rule is faster and doesn't need admin help.

1. Open [Outlook on the web](https://outlook.office.com/) and sign in
2. Click the **Settings** gear in the top-right corner
3. Go to **Mail → Rules → Add new rule**
4. Name the rule (e.g. `Forward to Molin`)
5. Under **Add a condition**, choose **Apply to all messages**
6. Under **Add an action**, choose **Forward to** and paste your Molin inbound address
7. Tick **Stop processing more rules** to prevent conflicts with other rules
8. Click **Save**

<Tip>
  If your Microsoft 365 admin has blocked external forwarding, the rule will save but emails won't be delivered. Ask them to allow forwarding to `molin.email`, or have them set up a transport rule at
  the tenant level instead.
</Tip>

### Tenant-level forwarding (admin)

If you're a Microsoft 365 admin and want to forward at the organization level:

1. Open the [Exchange admin center](https://admin.exchange.microsoft.com/)
2. Go to **Mail flow → Rules → Add a rule → Create a new rule**
3. Set the condition to **Apply to all messages** (or restrict to a specific recipient like `support@`)
4. Set the action to **Bcc the message to** and paste your Molin inbound address
5. Save and enable the rule

Using **Bcc** instead of **Redirect** keeps the original delivery to your team's inbox untouched.

## Outlook.com / Hotmail (personal)

1. Open [outlook.com](https://outlook.com/) and sign in
2. Click the **Settings** gear in the top-right corner
3. Go to **Mail → Forwarding**
4. Toggle **Enable forwarding** on
5. Paste your Molin inbound address into **Forward my email to**
6. Tick **Keep a copy of forwarded messages** so your inbox still receives the originals
7. Click **Save**

Outlook.com may send a verification email to your Molin address. Use the email setup wizard at [molin.ai/app/channels/email](https://molin.ai/app/channels/email) to confirm it automatically.

## Troubleshooting

* **Rule saves but no emails arrive at Molin** — Microsoft 365 blocks external forwarding by default in many tenants. Confirm with your admin that forwarding to `molin.email` is allowed under the [outbound spam policy](https://learn.microsoft.com/en-us/defender-office-365/anti-spam-policies-configure).

## Reference

For Microsoft's own documentation, see [Turn on automatic forwarding in Outlook](https://support.microsoft.com/en-us/office/turn-on-automatic-forwarding-in-new-and-classic-outlook-for-windows-also-outlook-on-the-web-7f2670a1-7fff-4475-8a3c-5822d63b0c8e) for Outlook.com and the web client, [Use rules to automatically forward messages](https://support.microsoft.com/en-us/office/use-rules-to-automatically-forward-messages-45aa9664-4911-4f96-9663-ece42816d746) for rule-based forwarding, and [Configure email forwarding](https://learn.microsoft.com/en-us/microsoft-365/admin/email/configure-email-forwarding) for Microsoft 365 admin-level forwarding.


# Forward Shopify-managed email to Molin
Source: https://docs.molin.ai/home/channels/email/forwarding/shopify

Point Shopify's built-in email forwarding at your Molin inbound address so support emails sent to your Shopify-managed domain reach the AI.

If you bought your domain through Shopify (a "Shopify-managed domain"), Shopify offers a built-in email forwarding feature you can point at your Molin inbound address. No third-party provider needed.

<Warning>
  This guide only applies to **Shopify-managed domains**. If your domain is registered with a third-party (GoDaddy, Namecheap, Cloudflare, etc.), Shopify's email forwarding section doesn't appear. Set
  up forwarding at your provider instead, or transfer the domain to Shopify.
</Warning>

## Prerequisites

* A Shopify-managed domain (purchased through Shopify Domains)
* Your **Molin inbound address** from the email setup wizard (looks like `panda-pod-trick@gt010n7t.molin.email`)
* Admin access to your Shopify store

## Steps

1. From your Shopify admin, go to **Settings → Domains**
2. Click the domain you want to set up forwarding for
3. In the **Email forwarding** section, click **Add forwarding email**
4. In **Forwarding email address**, enter the first part of the address customers will use (e.g. `support`). Do not type `@` or the domain — Shopify appends them automatically
5. In **Receiving email address**, paste your **Molin inbound address** (the full `xxx@gt010n7t.molin.email` string from the wizard)
6. Click **Save**

You can repeat this for as many addresses as you want (e.g. `support@`, `help@`, `info@`). Each Shopify forwarding entry only forwards to **one** destination, so use the same Molin address for all of them.

## Test the forwarding

1. From a different email account (not the one you'd use as a destination), send a test message to the address you created (e.g. `support@yourshop.com`)
2. Open the [Inbox](https://molin.ai/app/inbox) in Molin and look for the new conversation

If nothing arrives within a few minutes, double-check that the destination matches your Molin inbound address exactly.

## How replies work

Shopify warns that replies from a forwarded email show the **forwarding** address as the sender, not your custom domain. This caveat doesn't apply when Molin is the destination — Molin sends replies through its own outbound, automatically setting the `From` to your custom domain (once connected) and `Reply-To` to your support address. Customers always see and reply to your address, never to a `molin.email` one.

## Reference

For Shopify's own documentation on this feature, see [Setting up email forwarding for a Shopify-managed custom domain](https://help.shopify.com/en/manual/domains/email-forwarding-and-hosting/email-forwarding).


# Forward UNAS email to Molin
Source: https://docs.molin.ai/home/channels/email/forwarding/unas

Add an UNAS email forwarder so a copy of every support message reaches your Molin inbound address, plus what to watch out for with SPF.

If your domain and hosting are with UNAS, you can add an email forwarder from the UNAS admin so a copy of every incoming email is delivered to your Molin inbound address.

<Warning>
  UNAS themselves [recommend against external forwarding](https://unas.hu/blog/az-email-tovabbito-halala) because plain forwarding can break SPF/DKIM authentication and degrade deliverability when
  replying from another system. For Molin this is not an issue: Molin sends replies through its own authenticated outbound (with DKIM and SPF for our domain, plus your own domain once you connect it),
  so the original forwarded message only needs to reach us — we don't re-send from a forwarded identity.
</Warning>

## Prerequisites

* An UNAS hosting account with at least one domain
* Your **Molin inbound address** from the email setup wizard (looks like `panda-pod-trick@gt010n7t.molin.email`)

## Steps

1. Sign in to your UNAS admin and open the hosting panel
2. Go to **Email → Email továbbító** (Email forwarder)
3. Click **Hozzáad** (Add)
4. In the forwarder name field, enter the first part of the address customers will use (e.g. `support`, `info`, or `help`)
5. In the destination field, paste your **Molin inbound address**. Press **Enter** to confirm. You can add multiple destinations if needed — separate them with **Enter** — but for Molin a single destination is enough
6. Click **Ment** (Save)

Repeat for each support alias you want forwarded (for example `support@`, `info@`, `rendeles@`).

## Keep a local copy (optional)

By default, UNAS only delivers forwarded mail to the destination — nothing stays in UNAS. If you also want a local copy to read in UNAS WebMail:

1. Create a real mailbox under **Email → Email fiók** with the same name as the forwarder (e.g. `support`)
2. The forwarder will deliver to Molin **and** keep a copy in the local mailbox

This is useful if you want a redundant archive in UNAS in addition to Molin's [Inbox](https://molin.ai/app/inbox).

## Test the forwarding

1. From a different email account, send a test message to the forwarded address (e.g. `support@yourshop.hu`)
2. Open the [Inbox](https://molin.ai/app/inbox) in Molin and look for the new conversation

If nothing arrives within a couple of minutes, double-check that the destination matches your Molin inbound address exactly.

## Reference

For UNAS's own documentation, see [Email továbbító](https://unas.hu/tudastar/hosting/email-tovabbito) (Hungarian).


# Forward Yahoo Mail to Molin
Source: https://docs.molin.ai/home/channels/email/forwarding/yahoo

Set up Yahoo Mail forwarding so customer emails reach your Molin inbound address, including the Yahoo Mail Plus and AOL limitations.

This guide covers Yahoo Mail. Yahoo's forwarding only delivers *new* emails after it's set up — past emails aren't backfilled.

<Warning>
  Yahoo Mail's automatic forwarding requires a **Yahoo Mail Plus** subscription and isn't offered in every locale. AOL Mail (owned by Yahoo) doesn't expose automatic forwarding at all per [AOL's
  current help](https://help.aol.com/products/new-aol-mail) — if you're on AOL Mail, use a Gmail/Microsoft 365 account as the forwarding source instead, or upgrade to Yahoo Mail Plus on a Yahoo
  address.
</Warning>

## Prerequisites

* A Yahoo Mail Plus account
* Your **Molin inbound address** from the email setup wizard

## Yahoo Mail

The exact path differs slightly between the new and older Yahoo Mail interfaces:

1. Open [Yahoo Mail](https://mail.yahoo.com/) and sign in
2. Click the **More options** icon (or the **Settings** gear, depending on UI version) in the top-right, then choose **Settings**
3. In the older interface only, click **More Settings** at the bottom of the panel
4. Choose **Mailboxes** from the left sidebar
5. Click your primary account name under **Mailbox list**
6. Scroll to **Auto-forwarding** (newer UI) or **Forwarding** (older UI) and paste your Molin inbound address into the field
7. Click **Verify** — Yahoo sends a verification email to your Molin address
8. In the Molin [Inbox](https://molin.ai/app/inbox), open Yahoo's email and click the verification link
9. Back in Yahoo settings, the forwarding status flips to **Verified**. Save changes

## Verification

Yahoo forwarding only activates after you click the verification link. The Molin email setup wizard at [molin.ai/app/channels/email](https://molin.ai/app/channels/email) surfaces incoming verification emails as a clickable confirmation button — use it for the fastest path.

## Reference

For Yahoo's own documentation, see [Enable automatic email forwarding in New Yahoo Mail](https://help.yahoo.com/kb/SLN36684.html) (newer interface) or [Enable automatic email forwarding in Yahoo Mail](https://help.yahoo.com/kb/SLN29133.html) (older interface). AOL Mail has no equivalent feature per the [AOL Mail Help hub](https://help.aol.com/products/new-aol-mail) — its automatic forwarding section is absent and the help search returns only filter-based organisation, not destination forwarding.


# Facebook Messenger
Source: https://docs.molin.ai/home/channels/facebook-messenger

Connect your Facebook Page so Molin AI answers Messenger conversations automatically, with every chat visible in your shared Inbox.

Connect your Facebook Page to Molin so your AI chatbot can automatically respond to Facebook Messenger conversations. Your customers get instant replies, and you can monitor all conversations from the [Inbox](https://molin.ai/app/inbox).

<Note>The Facebook Messenger integration is available on the **Startup** plan and above.</Note>

## Prerequisites

Before connecting, make sure you have:

* A **Facebook Page** for your business
* Admin access to the Facebook Page you want to connect
* A Molin AI widget on the **Startup** plan or higher

## Connect your Facebook Page

1. Open the [Integrations](https://molin.ai/app/integrations#facebook-messenger) page and expand the **Facebook Messenger** section
2. Click **Authorize page access**
3. You will be redirected to Facebook to authorize Molin AI
4. Select the Facebook Pages you want to make available, then confirm the permissions
5. After authorization, you will be redirected back to the dashboard
6. Use the dropdown to select which Facebook Page to connect
7. Click **Save**

<Tip>If you manage multiple Facebook Pages, you can authorize all of them at once. Only the page you select in the dropdown will be actively connected to Molin.</Tip>

## How it works

Once connected:

* When a customer sends a message to your Facebook Page via Messenger, Molin AI automatically responds using the same AI and instructions that power your web widget
* All Messenger conversations appear in your [Inbox](https://molin.ai/app/inbox) alongside web chat and other channels
* If live chat is enabled, your support agents can take over Messenger conversations at any time

## Change the connected page

1. Open the [Integrations](https://molin.ai/app/integrations#facebook-messenger) page and expand the **Facebook Messenger** section
2. Select a different page from the dropdown
3. Click **Save**

If the page you want is not in the dropdown, click **Can't find your page? Authorize again** to re-run the authorization flow and grant access to additional pages.

## Disconnect your page

1. Open the [Integrations](https://molin.ai/app/integrations#facebook-messenger) page and expand the **Facebook Messenger** section
2. Clear the page selection in the dropdown (select nothing)
3. Click **Save**

After disconnecting, Molin will stop responding to Messenger conversations on that page.

## Troubleshooting

### My page doesn't appear in the dropdown

* Click **Can't find your page? Authorize again** to re-authorize with Facebook
* Make sure you have **Admin** access to the page
* During the Facebook authorization flow, ensure you select the page you want to connect

### Messages are not being received

* Check that the correct page is selected and saved on the [Integrations](https://molin.ai/app/integrations#facebook-messenger) page
* Try disconnecting and reconnecting the page to refresh the authorization
* Ensure you have not revoked Molin's access in your [Facebook Business settings](https://business.facebook.com/settings/)

If you need further help, please contact us <OpenChatLink>here</OpenChatLink>.


# Instagram DMs
Source: https://docs.molin.ai/home/channels/instagram

Connect your Instagram Professional account so Molin AI answers Direct Messages automatically, with every chat visible in your shared Inbox.

Connect your Instagram Professional account to Molin so your AI chatbot can automatically respond to Instagram Direct Messages. Your customers get instant replies, and you can monitor all conversations from the [Inbox](https://molin.ai/app/inbox).

<Note>The Instagram integration is available on the **Startup** plan and above.</Note>

## Prerequisites

Before connecting, make sure you have:

* A **Professional** Instagram account (Business or Creator). [How to switch to a Professional account](https://help.instagram.com/502981923235522)
* A Molin AI widget on the **Startup** plan or higher

<Tip>
  You do **not** need a Facebook Page linked to your Instagram account. The Instagram integration uses Instagram Business Login, which connects directly to your Instagram Professional account.
</Tip>

## Connect your Instagram account

1. Open the [Integrations](https://molin.ai/app/integrations#instagram) page and expand the **Instagram** section
2. Click **Connect Instagram account**
3. You will be redirected to Instagram to authorize Molin AI
4. Grant the requested permissions so Molin can read and respond to your DMs
5. After authorization, you will be redirected back to the dashboard

Once connected, the Instagram section shows your linked account name with a "Connected" status.

## How it works

Once connected:

* When a customer sends you an Instagram DM, Molin AI automatically responds using the same AI and instructions that power your web widget
* All Instagram conversations appear in your [Inbox](https://molin.ai/app/inbox) alongside web chat and other channels
* If live chat is enabled, your support agents can take over Instagram conversations at any time

## Disconnect your account

1. Open the [Integrations](https://molin.ai/app/integrations#instagram) page and expand the **Instagram** section
2. Click **Disconnect**
3. Confirm the disconnection

After disconnecting, Molin will stop responding to Instagram DMs.

## Troubleshooting

### Authorization fails

* Verify your Instagram account is a **Professional** account (Business or Creator), not a Personal account
* Try logging out of Instagram in your browser, then attempt authorization again
* Clear your browser cache and cookies if the issue persists

### Messages are not being received

* Check that your account is still connected on the [Integrations](https://molin.ai/app/integrations#instagram) page
* Disconnect and reconnect your account to refresh the authorization

If you need further help, please contact us <OpenChatLink>here</OpenChatLink>.


# Custom actions
Source: https://docs.molin.ai/home/chatbot/custom-actions

Let your AI take real actions in your business: issue coupons, book callbacks, look up orders, and anything else you connect to it.

Custom actions let your AI do real things during a chat, not just answer questions. You set up an action in the dashboard, connect it to your own system, and the AI uses it when a customer needs it.

This part needs a developer on your side because you (or someone on your team) needs to build the endpoint that the AI calls.

<Note>Find it in your dashboard under [**Chatbot → Actions**](https://molin.ai/app/actions).</Note>

## Examples

* Give a discount code when a customer asks for one.
* Look up an order by email and order number.
* Send a callback request to your CRM or Slack.
* Check if something is in stock in your warehouse system.
* Cancel or change an order.
* Add the customer to your newsletter list (Klaviyo, Mailchimp, etc).

## How it works

1. You set up the action in the dashboard: a name, a description, the info the AI should collect (for example, the customer’s email or an order number), and whether your endpoint expects a POST or GET request.
2. The AI decides when to use the action based on the description you wrote.
3. Molin calls your endpoint with that info, as a JSON body for POST or as query params/URL segments for GET.
4. Your endpoint sends back a short answer.
5. The AI uses the answer to reply to the customer.

```mermaid theme={null}
sequenceDiagram
  Customer->>Molin AI: "Where is order #1234?"
  Molin AI->>Your API: POST /lookup-order { orderNumber: "1234" }
  Your API->>Molin AI: { status: "Shipped", eta: "Tomorrow" }
  Molin AI->>Customer: "Your order shipped and arrives tomorrow."
```

<Tip>The action description is what the AI reads to decide *when* to use it. Be specific. Write "Look up an order status when the customer asks about delivery" instead of just "Order lookup".</Tip>

## Setup

See the [Custom actions API reference](/apis/custom-actions) for the full request/response spec, security headers, and code examples.

## Best practices

* **One action, one job.** Set up a separate action for each task instead of one big one that does everything.
* **Send back short, clear text** from your endpoint. The AI will turn it into a reply to the customer.
* **Don’t send sensitive info back.** The customer might see it in the answer.
* **Test it in the chat preview** before turning it on for real customers.


# Image search
Source: https://docs.molin.ai/home/chatbot/image-search

Let customers attach photos in the chat so the AI can identify products, answer questions about a scene, and read receipts.

Customers can attach photos to any chat message. The AI reads the image alongside the text, so a shopper can send a picture of a product and ask "do you have this?" instead of guessing at search keywords.

Image search is on by default for every widget. There is nothing to enable or configure.

## What customers can do with it

* **Find a specific product.** A photo of an item they own, or spotted elsewhere, matched against your catalog.
* **Ask about a whole scene.** A picture of a room or an outfit, answered with several products that work together.
* **Get recommendations.** "What goes with this?" against a photo, answered with compatible items from your catalog.
* **Support with proof.** A photo of a damaged item, or of a receipt or invoice, so the AI can see the problem instead of asking the customer to describe it.

The AI treats an image as part of the conversation, so follow-up questions like "do you have it in blue?" keep working without re-attaching the photo.

## Attaching images

In the chat widget, customers add images three ways:

* the attachment button in the message box
* drag and drop onto the chat
* paste from the clipboard

On phones, the attachment button opens the camera or photo library, so a shopper can photograph something and search for it without leaving the chat.

## Limits

| Limit              | Value                           |
| ------------------ | ------------------------------- |
| Images per message | 3                               |
| Maximum file size  | 10 MB per image                 |
| Accepted formats   | JPEG, PNG, GIF, WebP, SVG, HEIC |

Files that are empty, too large, or of an unsupported type are rejected in the widget before any upload starts.

<Note>HEIC is the default camera format on iPhones, so photos taken in the chat upload without conversion.</Note>

## How images are processed

1. The widget uploads the file through Molin's upload endpoint.
2. Molin stores it and records it against the conversation.
3. The AI receives a resized copy of the image, at most 2048×2048.
4. The widget and your [inbox](/home/inbox/inbox) display a smaller copy, at most 800×800.

Both copies are generated on demand from the original upload and cached at the edge, so a customer on a slow connection doesn’t download a full-resolution photo to see their own attachment.

Support agents can attach images too, when replying from the inbox. Those follow the same path and the same limits.

## Content Security Policy

If your shop sends a [Content Security Policy](/home/general/content-security-policy), image search needs no extra origins. Uploads and image display both go through `widget.molin.ai`, which the documented `connect-src` and `img-src` entries already allow.

## Data retention

Images belong to the conversation they were sent in and follow the same lifecycle:

* Attachments a customer selects but never sends are deleted when they start a new chat.
* Sent images stay with the conversation history so you can see what the customer sent when you review it in the inbox.
* When a conversation is erased, either through data retention or a GDPR erasure request, its images are deleted from storage and purged from the cache.

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does it work on Facebook Messenger and Instagram?">
    Image search works in the web chat widget and in the inbox. Photos sent through [Messenger](/home/channels/facebook-messenger) and [Instagram](/home/channels/instagram) aren’t read by the AI
    today. Please give our team a nudge and we will prioritize it for a future update.
  </Accordion>

  <Accordion title="What does the AI match photos against?">
    Your product catalog, as synced from your platform or [product feed](/home/general/product-feeds). It recommends only products you actually sell, the same as any other answer.
  </Accordion>

  <Accordion title="Can customers send several photos at once?">
    Yes, up to 3 per message. The AI considers them together, so a shopper can send a few references and get one answer covering all of them.
  </Accordion>

  <Accordion title="Can the AI read text in an image?">
    Yes. This is what makes receipts, invoices, and order confirmations useful in a support conversation. Accuracy depends on how legible the photo is.
  </Accordion>
</AccordionGroup>


# Lead collection
Source: https://docs.molin.ai/home/chatbot/lead-collection

Capture a customer's name, email, and phone mid-conversation, save the lead, notify your team, and push it straight to your CRM.

When the AI can’t fully answer a question (or the customer wants a callback) Molin can ask for their contact details, save the lead, and notify you.

<Note>Find it in your dashboard under [**Chatbot → Actions → Lead collection**](https://molin.ai/app/actions).</Note>

## When the AI collects a lead

The AI asks for contact details when:

* The customer asks to speak to a human or requests a callback.
* The customer wants details about a specific order (and isn’t logged in).
* You explicitly instruct it to (e.g. "Always ask for an email before quoting custom work").

## What gets captured

* **Customer name**
* **Email or phone** (whichever the customer gave).
* **What they need help with** (their reason for getting in touch).
* **Priority**: low, normal, or urgent, based on the conversation.

The full chat is also kept and you can read it in the Inbox.

## Where leads go

* **Dashboard**: see all leads under [**Inbox**](https://molin.ai/app/inbox) by clicking the **Leads** filter.
* **Email**: Molin sends a notification to the email you set under [**Chatbot → Personality → Contact details**](https://molin.ai/app/personality).


# Personality & instructions
Source: https://docs.molin.ai/home/chatbot/personality

Tell the AI how to sound, what to say, and what to avoid, so Molin feels like your brand instead of a generic chatbot.

Personality is where you tell the AI what to do, what to avoid, and how to sound. This is how you make Molin feel like *your* brand and not a generic chatbot.

<Note>Find it in your dashboard under [**Chatbot → Personality**](https://molin.ai/app/personality).</Note>

## What you can control

* **How the AI sounds**: formal, casual, playful, friendly.
* **What language it replies in**: always English, always Hungarian, or match whatever the customer used.
* **What it should and shouldn’t say**: for example, never recommend competitors, always mention your loyalty program, never promise a delivery date.
* **When to bring in a human**: tell the AI when to ask the customer for contact details and pass it to your team.
* **What to do with off-topic questions**: how to reply when someone asks something not related to your shop.

## How to write good instructions

Use short, plain-sentence rules. One instruction per line works best.

```
You are a friendly assistant for Acme Shop.
Always greet the customer by name if you know it.
Never discuss our suppliers or pricing margins.
If the customer asks about returns, always link to /returns.
If the customer is upset, offer to connect them to a human agent.
Reply in the same language the customer uses.
```

## Limits

* Up to **1,500 lines** of instructions.
* Up to **5,000 characters** per line.

## Best practices

* **Be specific.** "Be helpful" does nothing. Something like "Always suggest the warranty add-on for electronics" works much better.
* **Show examples.** Include one or two good answers in your instructions so the AI knows what you want.
* **Test and adjust.** Try it in the chat preview, spot a bad answer, add a new rule, and try again.
* **Don’t repeat product info here.** The AI already knows your products from the feed. Use Personality to control how the AI behaves, not to list product details.


# Stock and availability
Source: https://docs.molin.ai/home/chatbot/stock-availability

Control whether the AI tells customers how many units are left, and let it check live stock levels directly on your Shopify store.

By default the AI only recommends products that are in stock, and it never states how many units you have. You can also let it tell customers **how many units are left** and, on Shopify, **check stock live** at the moment they ask.

Both are off by default. Contact our customer support team to switch them on for your shop.

## Where stock counts come from

| Platform                                     | Stock count                                                     |
| -------------------------------------------- | --------------------------------------------------------------- |
| [Shopify](/home/platforms/shopify)           | Units on hand per variant                                       |
| [Shoprenter](/home/platforms/shoprenter)     | Summed across your stock records                                |
| [UNAS](/home/platforms/unas)                 | Summed across your stock records, when inventory tracking is on |
| [Shoper](/home/platforms/shoper)             | Units on hand                                                   |
| [Product feeds](/home/general/product-feeds) | Only when your feed carries a numeric stock value               |

Most feed formats state only whether an item is in stock, not how many. If yours includes a number, Molin keeps it.

<Note>
  Some products have no count at all: made-to-order goods, or items where you have inventory tracking switched off. The AI treats these as available to order rather than sold out, and never quotes a
  number for them.
</Note>

## Showing counts to customers

Choose how much the AI discloses:

* **Hidden** (default): the AI says whether an item is in stock, never how many.
* **Only when low**: the AI says "only 3 left" below your threshold (5 by default), and just "in stock" above it. Good for creating urgency without publishing your inventory.
* **Exact**: the AI states the number whenever it has one.

<Warning>Anyone can chat with your widget, including your competitors. **Exact** publishes your inventory levels to whoever asks, so most shops should use **Only when low**.</Warning>

## Live stock checks on Shopify

Product data syncs on a schedule, so a count can be a few hours old. With live stock checks enabled, the AI queries Shopify directly when a customer explicitly asks whether something is still available, and answers with the figure at that moment.

The AI only does this when asked a direct availability question:

* How many are left?
* Is this still in stock?
* Has it been restocked?

It doesn't check on every product answer, so your Shopify API usage stays low.

Live checks are available on Shopify only. On other platforms the AI answers from the last sync instead.

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Will the AI recommend out of stock products?">
    Not by default. Turn on **Let the AI recommend out of stock products** under [**Products → Settings**](https://molin.ai/app/products) if you still take orders for sold-out items.
  </Accordion>

  <Accordion title="Why does the AI say a number that's slightly out of date?">
    Product data syncs on a schedule that depends on your plan, so counts reflect your catalog as of the last sync. Enable live stock checks on Shopify for a real-time figure.
  </Accordion>

  <Accordion title="Can the AI change stock levels?">No. Molin only reads stock. It never writes to your inventory.</Accordion>
</AccordionGroup>


# Customers
Source: https://docs.molin.ai/home/crm/customers

Turn chats into a lightweight CRM: track known customers with their orders, ticket history, follow-up status, notes, and tags.

The Customers page turns your chats into a lightweight CRM. Instead of a list of separate conversations, you see profiles grouped by known contact identity, so you can track who you are talking to and what you have discussed before.

<Note>Find it in your dashboard under [**Customers**](https://molin.ai/app/customers).</Note>

## How customers are grouped

Every time the AI collects a customer's **email** or **phone** (through a chat, a lead, or an email reply), Molin links that conversation to a customer profile.

* when an email is available, Molin recognises the person by email
* when no email is available, Molin recognises the person by phone
* a phone-only profile stays separate if an email becomes available later, which prevents shared household or office phone numbers from merging different people
* conversations with no email or phone stay in the [Inbox](/home/inbox/inbox) but do not create a customer profile

## The customers list

The list shows one row per customer, newest contact first. Each row shows:

* **Customer**: name, email, and phone (whatever was collected)
* **Activity**: when you last heard from them and how many tickets you have had
* **Channels**: whether they reached you by web chat, email, Messenger, or Instagram
* **Signals**: whether they left a **Lead** or have an **Order**
* **Follow-up**: their current follow-up status, if set
* **Tags**: any tags you added

You can **search** by name, email, phone, or tag and filter customers by follow-up status.

## The customer profile

Click any customer to open their profile:

* a **header** with their name, email, phone, and totals (tickets, first contact, last contact)
* recent **orders** from the connected store, when the store platform supports lookup by customer email
* a **timeline** of every ticket they have had across web chat, email, Messenger, and Instagram, newest first, each linking straight into the [Inbox](/home/inbox/inbox) thread
* a right-hand panel for tracking the relationship:

### Orders

For Shopify, Shoprenter, and UNAS stores, the profile loads the customer's latest orders directly from the connected store. Expand an order to see its products and use **Track order** when the store supplied a valid tracking link.

Order history requires an email address on the customer profile. The profile explains when the customer has no email, the store platform does not support customer order lookup, or the live store request fails.

### Follow-up status

Set a status so nothing slips through the cracks:

* **No follow-up** (default)
* **Needs follow-up**
* **Waiting on customer**
* **Done**

### Notes

Add free-text notes about a customer (for example "asked about a refund on order #1042, promised a callback"). Notes show who added them, are timestamped, and are shared with your team.

### Tags

Add tags like `vip` or `wholesale` to group and recognise customers at a glance.

<Tip>Use the [Inbox](/home/inbox/inbox) to read and reply to individual conversations, and Customers to track the person across all of them.</Tip>


# Content Security Policy (CSP)
Source: https://docs.molin.ai/home/general/content-security-policy

Configure the Content Security Policy directives your site needs so the Molin AI widget can load its scripts, styles, and connections.

## What is Content Security Policy?

Content Security Policy (CSP) is a security standard that helps prevent cross-site scripting (XSS) attacks by controlling which resources can be loaded on your website. If your site uses CSP headers, you'll need to configure them to allow the Molin AI widget to function properly.

## Required CSP directives

| Directive     | Value                                                                 | Purpose                              |
| ------------- | --------------------------------------------------------------------- | ------------------------------------ |
| `script-src`  | `'self' https://widget.molin.ai`                                      | JavaScript execution for the widget  |
| `frame-src`   | `'self' https://widget.molin.ai`                                      | Iframes and embedded content         |
| `style-src`   | `'self' 'unsafe-inline' https://widget.molin.ai`                      | Widget stylesheets and inline styles |
| `connect-src` | `'self' wss://molin.ai wss://widget.molin.ai https://widget.molin.ai` | API and WebSocket connections        |
| `img-src`     | `'self' https://widget.molin.ai`                                      | Widget images and assets             |
| `media-src`   | `https://widget.molin.ai`                                             | Audio files for notifications        |

## Complete CSP policy

```
Content-Security-Policy: script-src 'self' https://widget.molin.ai; frame-src 'self' https://widget.molin.ai; style-src 'self' 'unsafe-inline' https://widget.molin.ai; connect-src 'self' wss://molin.ai wss://widget.molin.ai https://widget.molin.ai; img-src 'self' https://widget.molin.ai; media-src https://widget.molin.ai;
```

## Testing your CSP

After implementing CSP headers:

1. Open your browser's developer console
2. Load a page with the Molin widget
3. Check for any CSP violation errors
4. Verify the widget appears and functions correctly


# Dark mode customization
Source: https://docs.molin.ai/home/general/dark-mode

Enable and customize dark mode for your Molin AI chatbot so it stays easy on the eyes in low-light environments, on desktop and mobile.

The dark mode feature allows you to provide a sleek, modern appearance for your Molin AI chatbot that's easier on users' eyes, especially in low-light environments. When enabled, your chatbot and popups automatically switch to a dark design.

<Note>Dark mode is available for all plan types and works seamlessly across desktop and mobile devices.</Note>

## Enable dark mode

### Step 1: Access your widget settings

1. Log in to your [Molin AI dashboard](https://molin.ai/app)
2. Navigate to your chatbot's **Design** settings
3. Scroll to the **Appearance** section

### Step 2: Toggle dark mode

1. Find the **Dark mode** toggle switch
2. Click to enable dark mode for your chatbot
3. Save your changes

![Dark mode toggle in dashboard settings](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/996fb37c-3730-4951-45d2-a46bea8e2900/w=800,h=600,fit=scale-down,q=75,dpr=1)

## How it works

When dark mode is enabled, the chatbot and all popup elements automatically switch to a dark design with appropriate styling for low-light environments.

![Dark mode popup examples](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/68dcfcb5-a0e5-4b56-ac24-2b0ccc414600/w=800,h=600,fit=scale-down,q=75,dpr=1)

## Best practices

### Brand consistency

* Ensure your brand colors maintain sufficient contrast in dark mode
* Test your widget on both light and dark website backgrounds
* Consider your website's overall design when choosing colors


# Elements
Source: https://docs.molin.ai/home/general/elements

Drop-in HTML tags for buttons, inputs, and typewriter animations, plus paste-and-edit recipes for review and product cards.

Elements are prebuilt components you embed on your store with a single HTML tag. No JavaScript, no setup. They theme from their style attributes, with sensible defaults. Override any attribute when you want a different look.

<Note>
  The [Elements admin page](https://molin.ai/app/elements) lets you tweak attributes in a live preview and copy the resulting HTML to paste into your store theme. Use it if you want to iterate on the
  look without editing your site between attempts.
</Note>

## Shared style attributes

Every component accepts these style attributes. Set them on the tag, or copy a pre-styled snippet from the [Elements admin page](https://molin.ai/app/elements), which fills in your brand color for you.

<ParamField type="CSS color">
  Background color. Defaults to the Molin brand purple (`#601feb`). Snippets copied from the Elements admin page set this to your widget's brand color.
</ParamField>

<ParamField type="CSS color">
  Text and icon color. Defaults to white or black, whichever contrasts better with `bg`.
</ParamField>

<ParamField type="'none' | 'sm' | 'md' | 'lg' | 'full'">
  Corner rounding preset.
</ParamField>

<ParamField type="'sm' | 'md' | 'lg'">
  Padding and font size preset.
</ParamField>

<ParamField type="'normal' | 'medium' | 'semibold' | 'bold'">
  Font weight for labels and headings so the component matches your store typography.
</ParamField>

## Open the chat in fullscreen

Every element that opens the chat (`<molin-shop-ai-button>`, `<molin-shop-ai-ask>`, and `<molin-shop-ai-typewriter>`) accepts a `fullscreen` attribute. When present, clicking the element opens the chat window filling the whole screen on desktop. On mobile the chat is always fullscreen.

```html theme={null}
<molin-shop-ai-button fullscreen autosend message="I need help with my order">Get help</molin-shop-ai-button>
```

<ParamField type="boolean">
  When present, the chat opens filling the screen on desktop instead of the floating window. Mobile is always fullscreen.
</ParamField>

## `<molin-shop-ai-button>`

A call-to-action button. Opens the chat, optionally prefilling or auto-sending a message.
The same tag doubles as a quick-question chip via the `variant`, `size`, and `icon` attributes, see the chip recipe below.

```html theme={null}
<molin-shop-ai-button message="Tell me about this product" autosend> Ask about this product </molin-shop-ai-button>
```

Chip configuration for FAQ rows:

```html theme={null}
<molin-shop-ai-button variant="outline" size="sm" icon="none" autosend message="What's your return policy?"> Returns </molin-shop-ai-button>
```

<ParamField type="string">
  Text to prefill or autosend when the chat opens.
</ParamField>

<ParamField type="boolean">
  When present, sends `message` immediately instead of just prefilling the input.
</ParamField>

<ParamField type="'chat' | 'sparkle' | 'none'">
  Leading icon inside the button.
</ParamField>

<ParamField type="'solid' | 'outline' | 'ghost'">
  Visual style.
</ParamField>

<ParamField type="'sm' | 'md' | 'lg'">
  Padding and font size preset. Use `sm` for chip-style pills.
</ParamField>

The button's label is the inner text of the tag (the default slot).

## `<molin-shop-ai-ask>`

An input field with a send button. On submit, opens the chat with whatever the visitor typed.
The same tag doubles as a product search bar via the `prefix` and `icon` attributes, see the second example below.

```html theme={null}
<molin-shop-ai-ask placeholder="Ask anything about our products"></molin-shop-ai-ask>
```

Product-search configuration:

```html theme={null}
<molin-shop-ai-ask icon="search" prefix="Help me find: " placeholder="Search products…" submit-label="Search"></molin-shop-ai-ask>
```

<ParamField type="string">
  Input placeholder text.
</ParamField>

<ParamField type="string">
  Label on the submit button.
</ParamField>

<ParamField type="string">
  Text prepended to the visitor's typed text before it is sent to the chat. Use it to turn an "Ask AI" input into a "Help me find" search prompt.
</ParamField>

<ParamField type="'none' | 'search' | 'sparkle' | 'chat'">
  Leading icon inside the input.
</ParamField>

<ParamField type="boolean">
  When `true`, the typed text is sent immediately on submit. Set to `false` to only prefill it.
</ParamField>

<ParamField type="CSS color">
  Background color of the input field.
</ParamField>

<ParamField type="'solid' | 'none'">
  Whether the input has a visible border.
</ParamField>

## `<molin-shop-ai-search>`

A search box over your catalog. Unlike `<molin-shop-ai-ask>`, it doesn't open the chat: it queries your products through the [Search API](/home/general/search-api) and renders product cards on the page, so it can replace your store's own search.

```html theme={null}
<molin-shop-ai-search widget="abc12345" placeholder="Search products…"></molin-shop-ai-search>
```

Focusing the empty box offers the searches other shoppers on your store ran successfully. Typing filters that list in the browser, so no request goes out per keystroke. When a search finds nothing, the box offers the AI instead, which can answer questions keyword matching can't.

<Note>Copy a pre-filled snippet from the [Elements admin page](https://molin.ai/app/elements), which fills in your widget ID and brand color for you.</Note>

<ParamField type="string">
  Which catalog to search. This is the only element that needs your widget ID, because it fetches its own results rather than going through the chat.
</ParamField>

<ParamField type="string">
  Input placeholder text.
</ParamField>

<ParamField type="string">
  Label on the submit button.
</ParamField>

<ParamField type="number">
  How many products one search returns, between 1 and 60. Out-of-range values fall back to the default.
</ParamField>

<ParamField type="CSS color">
  Background color of the input field.
</ParamField>

## `<molin-shop-ai-typewriter>`

An animated CTA that cycles through up to 3 messages with a typewriter effect. The motion draws attention and the rotating prompts teach visitors what the AI can answer. On click, opens the chat with the current message.

```html theme={null}
<molin-shop-ai-typewriter text-1="Ask AI about this product" text-2="What sizes are available?"></molin-shop-ai-typewriter>
```

<ParamField type="string">
  First message (always displayed).
</ParamField>

<ParamField type="string">
  Second message to cycle through. Leave empty to only show message 1.
</ParamField>

<ParamField type="string">
  Third message to cycle through.
</ParamField>

<ParamField type="boolean">
  When `true`, the current message is sent immediately on click.
</ParamField>

<ParamField type="'help' | 'chat' | 'sparkle' | 'none'">
  Leading icon to the left of the animated text.
</ParamField>

<ParamField type="number">
  Milliseconds per character when typing.
</ParamField>

<ParamField type="number">
  Milliseconds per character when deleting.
</ParamField>

<ParamField type="number">
  Milliseconds to hold the fully-typed message before deleting.
</ParamField>

## Review card recipe

A card with decorative stars that fits into a product review section. Visitors who want a summary of customer reviews tap the button and the chat opens with a ready-to-send question. Paste the snippet below into your product page and edit colors, copy, and spacing to match your store.

<ReviewCardPreview />

```html theme={null}
<div style="border: 1px solid rgba(96, 31, 235, 0.15); border-radius: 16px; padding: 24px; background: linear-gradient(145deg, rgba(96, 31, 235, 0.03), rgba(96, 31, 235, 0.1));">
  <div style="display: flex; gap: 2px; margin-bottom: 12px;">
    <svg width="18" height="18" viewBox="0 0 24 24" fill="#f59e0b" aria-hidden="true"><path d="M12 2l2.9 6.3 6.9.7-5.1 4.6 1.4 6.8L12 17.8 5.9 20.4l1.4-6.8L2.2 9l6.9-.7L12 2z" /></svg>
    <svg width="18" height="18" viewBox="0 0 24 24" fill="#f59e0b" aria-hidden="true"><path d="M12 2l2.9 6.3 6.9.7-5.1 4.6 1.4 6.8L12 17.8 5.9 20.4l1.4-6.8L2.2 9l6.9-.7L12 2z" /></svg>
    <svg width="18" height="18" viewBox="0 0 24 24" fill="#f59e0b" aria-hidden="true"><path d="M12 2l2.9 6.3 6.9.7-5.1 4.6 1.4 6.8L12 17.8 5.9 20.4l1.4-6.8L2.2 9l6.9-.7L12 2z" /></svg>
    <svg width="18" height="18" viewBox="0 0 24 24" fill="#f59e0b" aria-hidden="true"><path d="M12 2l2.9 6.3 6.9.7-5.1 4.6 1.4 6.8L12 17.8 5.9 20.4l1.4-6.8L2.2 9l6.9-.7L12 2z" /></svg>
    <svg width="18" height="18" viewBox="0 0 24 24" fill="#f59e0b" aria-hidden="true"><path d="M12 2l2.9 6.3 6.9.7-5.1 4.6 1.4 6.8L12 17.8 5.9 20.4l1.4-6.8L2.2 9l6.9-.7L12 2z" /></svg>
  </div>
  <h3 style="margin: 0; font-weight: 600; font-size: 15px; color: #111;">What do customers say?</h3>
  <p style="margin: 4px 0 16px; font-size: 14px; color: rgba(96, 31, 235, 0.7);">Ask our AI for a summary of customer reviews</p>
  <molin-shop-ai-button message="What do people think about this product?" autosend bg="#601feb" icon="none">Ask about reviews</molin-shop-ai-button>
</div>
```

## Promotional product card recipe

A dark promotional card that slots into your product grid. Visitors tap the button and the AI helps them find what they need. Paste the snippet below into your grid and adjust copy, colors, or the icon to match your store.

<ProductCardPreview />

```html theme={null}
<div
  style="position: relative; overflow: hidden; border-radius: 16px; padding: 40px 32px; background: linear-gradient(145deg, #0f1225, #1a1d3a); border: 1px solid rgba(255, 255, 255, 0.06); display: flex; flex-direction: column; align-items: center; gap: 20px; text-align: center;">
  <div
    aria-hidden="true"
    style="position: absolute; width: 200px; height: 200px; top: 20%; left: 50%; transform: translate(-50%, -50%); background: radial-gradient(circle, rgba(96, 31, 235, 0.25), transparent 70%); pointer-events: none;"></div>
  <div
    style="position: relative; display: flex; align-items: center; justify-content: center; width: 64px; height: 64px; border-radius: 9999px; background: rgba(96, 31, 235, 0.6); color: white; box-shadow: 0 0 40px rgba(96, 31, 235, 0.4), 0 0 80px rgba(96, 31, 235, 0.15);">
    <svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M12 2l2.4 7.2L22 12l-7.6 2.8L12 22l-2.4-7.2L2 12l7.6-2.8L12 2z" /></svg>
  </div>
  <p style="position: relative; max-width: 260px; margin: 0; font-size: 14px; line-height: 1.5; color: #9ca3af;">Get personalized recommendations in seconds</p>
  <molin-shop-ai-button bg="#601feb">Ask our AI</molin-shop-ai-button>
</div>
```


# Feed allowlisting
Source: https://docs.molin.ai/home/general/feed-allowlisting

Stop your security solution or WAF from blocking Molin, by allowlisting our static IPs so we can download your product feed.

If you are using a security solution for your shop, it can block Molin from downloading your feed.

## Generic instructions

Make sure that your feed is accessible from [our static IPs](/home/general/static-ips).

Configuration can vary depending on your security solution, but generally, you can allowlist the IPs in your firewall or security settings.

Only the feed URLs need to be allowlisted, not your entire domain.

## Cloudflare

You can use a custom security rule to allowlist our IPs.

1. Navigate to the [Security rules](https://developers.cloudflare.com/security/rules/) page
2. Create a new **custom rule**
3. Add a check for field "URI Full" to be equal to your feed URL, e.g. `https://www.shop.com/google-products.xml`
4. Add a check for field "IP Source Address" to be in the list of [our static IPs](/home/general/static-ips)
5. Your expression preview should look similar to this: `(http.request.full_uri eq "https://www.shop.com/google-products.xml" and ip.src in {35.207.69.21 209.38.162.129})`
6. Select the "skip" action and skip ALL components

Example:

![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/2f0cf45c-8478-40a9-b38b-891bff265300/fit=scale-down,q=75)


# Installing via Google Tag Manager
Source: https://docs.molin.ai/home/general/google-tag-manager

Embed the Molin AI widget with a Google Tag Manager custom HTML tag, and why a direct script embed is more reliable for most shops.

<Warning>
  Google Tag Manager is trivially blocked by ad blockers, which would prevent the widget from loading for those visitors. For the most reliable experience, embed the script directly into your
  website's HTML instead.
</Warning>

## Step-by-step instructions

1. Open [Google Tag Manager](https://tagmanager.google.com/) and click **Tags** in the left sidebar, then click **New**.
2. Click **Tag Configuration** and choose **Custom HTML** from the tag type list.
3. Paste the embed snippet from your [Molin dashboard](https://molin.ai/app/shop-ai/publish) into the HTML field.
4. Click **Triggering** and select **All Pages** (or whichever pages you want the widget on).
5. Give the tag a name, click **Save**, then click **Submit** in the top-right corner to publish your changes.
6. Open your website and verify the widget appears in the bottom corner of the page.

## Verifying the installation

After publishing, open your website and reload the page. The Molin widget should appear in the bottom corner within a few seconds.

If it does not appear, click the **Preview** button in the top-right corner of GTM to open the debugger and confirm the tag is firing, then double-check that the widget ID in the snippet matches the one in your [Molin dashboard](https://molin.ai/app/shop-ai/publish).


# Available languages
Source: https://docs.molin.ai/home/general/languages

Molin detects a customer's language automatically and switches mid-conversation. See the full list of languages it understands and speaks.

Molin is revolutionizing customer interactions with its advanced language detection. Not only can it instantly recognize a customer's preferred language from the start, but it also boasts the impressive ability to seamlessly handle issues across a staggering 90+ languages.

What's even more remarkable is Molin's adaptability during live conversations; if a customer decides to switch languages midway, Molin effortlessly transitions with them, ensuring uninterrupted and smooth communication.

* Afrikaans
* Albanian
* Amharic
* Arabic
* Armenian
* Azerbaijani
* Basque
* Belarusian
* Bengali
* Bosnian
* Bulgarian
* Catalan
* Cebuano
* Chichewa
* Chinese (Simplified)
* Chinese (Traditional)
* Corsican
* Croatian
* Czech
* Danish
* Dutch
* English
* Esperanto
* Estonian
* Filipino
* Finnish
* French
* Frisian
* Galician
* Georgian
* German
* Greek
* Gujarati
* Haitian Creole
* Hausa
* Hawaiian
* Hebrew
* Hindi
* Hmong
* Hungarian
* Icelandic
* Igbo
* Indonesian
* Irish
* Italian
* Japanese
* Javanese
* Kannada
* Kazakh
* Khmer
* Korean
* Kurdish (Kurmanji)
* Kyrgyz
* Lao
* Latin
* Latvian
* Lithuanian
* Luxembourgish
* Macedonian
* Malagasy
* Malay
* Malayalam
* Maltese
* Maori
* Marathi
* Mongolian
* Myanmar (Burmese)
* Nepali
* Norwegian
* Pashto
* Persian
* Polish
* Portuguese
* Punjabi
* Romanian
* Russian
* Samoan
* Scots Gaelic
* Serbian
* Sesotho
* Shona
* Sindhi
* Sinhala
* Slovak
* Slovenian
* Somali
* Spanish
* Sundanese
* Swahili
* Swedish
* Tajik
* Tamil
* Telugu
* Thai
* Turkish
* Ukrainian
* Urdu
* Uzbek
* Vietnamese
* Welsh
* Xhosa
* Yiddish
* Yoruba
* Zulu


# Loading behavior
Source: https://docs.molin.ai/home/general/loading-behavior

The Molin AI widget loads after everything else on your page, so your product pages, images, and checkout stay fast.

## How the widget loads

The Molin AI widget loads after everything else on your page finishes, because your product pages, images, and checkout matter more.

<Info>The widget waits for the browser's `load` event, then starts after a short delay. It won't appear until images, stylesheets, fonts, and every other resource finish downloading.</Info>

## Why it works this way

* **Your store comes first.** Customers browse and buy, so the chat widget should never slow that down.
* **Better Core Web Vitals.** Deferring the widget keeps your Largest Contentful Paint (LCP) and other metrics where they were.
* **No layout shifts.** The widget appears smoothly after the page renders, so your layout doesn't jump.

## What this means in practice

On fast sites, the widget appears right after the page loads. On slower sites with heavy images or third-party scripts, it waits for those to finish first.

<Warning>Large unoptimized images or slow third-party scripts delay the widget too. Speed up your site and the widget appears faster.</Warning>

## Troubleshooting

If the widget takes too long to appear:

1. **Check your page load time.** Open DevTools, go to the **Network** tab, and check the total load time. The widget waits for that to finish.
2. **Look for slow resources.** Sort network requests by duration to find bottlenecks, because large images and slow third-party scripts usually cause them.
3. **Optimize slow assets.** Compress images, lazy-load below-the-fold content, and defer non-essential scripts to speed up the page.


# Product Feeds
Source: https://docs.molin.ai/home/general/product-feeds

Product feeds keep your AI in sync with your catalog, pricing, and availability. See supported formats, authentication, and troubleshooting.

Product feeds allow Molin to automatically sync your product catalog and keep your AI assistant up to date with the latest product information, pricing, and availability.

## Supported feed formats

Molin supports the following feed formats:

* [Google Shopping feed](/home/platforms/google-shopping-feed) (XML/CSV)
* [Árukereső/Compari feed](/home/platforms/arukereso-compari-feed) (XML)
* [Prefixbox feed](/home/platforms/prefixbox-feed) (JSON)
* [Vector Webshop feed](/home/platforms/vector-webshop-feed) (XML)
* Heureka XML
* JSON (schema.org format)

## Feed authentication

You can protect your feed with one of the following authentication methods:

* **Basic Auth**: standard HTTP Basic Authentication with username and password
* **Bearer token**: OAuth-style Bearer token authentication
* **Custom header**: any custom HTTP header for authentication

Please reach out to our customer support team to set up feed authentication.

## Feed requirements

Your product feed should include at minimum:

* Link
* Price
* Title
* Description

We strongly recommend including additional attributes like:

* Availability
* Images

If your feed carries a numeric stock value rather than just in stock/out of stock, Molin keeps the number. See [Stock and availability](/home/chatbot/stock-availability) for what the AI does with it.

## Product field limits

Molin enforces character limits on product data to ensure optimal performance and consistent AI responses. Fields exceeding these limits are automatically truncated.

### Core product fields

| Field        | Character limit |
| ------------ | --------------- |
| Title        | 100             |
| Price        | 20              |
| Description  | 4,000           |
| Product ID   | 100             |
| GTIN         | 100             |
| Availability | 50              |

### Product attributes

| Field           | Character limit |
| --------------- | --------------- |
| Attribute name  | 100             |
| Attribute value | 200             |

### Media and categorization

| Field      | Item limit                                         |
| ---------- | -------------------------------------------------- |
| Attributes | 20 per product (additional attributes are ignored) |
| Categories | 5 per product (additional categories are ignored)  |
| Images     | 5 per product (additional images are ignored)      |

## Feed updates

Molin automatically checks your feed for updates regularly to keep your product information current. The frequency depends on your plan.

## Platforms supported without a custom feed

You don't need a custom feed if you connected Molin to one of the supported e-commerce platforms:

* [Shopify](/home/platforms/shopify)
* [Shoprenter](/home/platforms/shoprenter)
* [UNAS](/home/platforms/unas)
* [WooCommerce](/home/platforms/woocommerce)

## Troubleshooting

If Molin cannot access your feed, check:

* The feed URL is publicly accessible from [our static IPs](/home/general/static-ips)
* Your security solution is not blocking our requests (see [Feed allowlisting](/home/general/feed-allowlisting))
* The feed format is valid and follows the expected schema
* Authentication credentials are correct (if using feed authentication)


# Programmatic chat API
Source: https://docs.molin.ai/home/general/programmatic-chat-api

Open the chat from your own JavaScript, or wire up any image, banner, or custom button on your page with an onclick handler.

Need to open the chat from your own JavaScript or from an existing element on your page (an image, a banner, a custom-styled button)? Use the programmatic API on the embedded widget element.

<Note>
  If you just want a "Chat with us" button, paste the prebuilt [`<molin-shop-ai-button>`](/home/general/elements#molin-shop-ai-button) instead. It is one HTML tag, no JavaScript, and you style it with a single `bg` attribute. Use this page when you need to wire up something custom.
</Note>

## API

The embedded widget element exposes two methods you can call from anywhere on the page:

* `document.querySelector('molin-shop-ai').openChat()` opens the chat window
* `document.querySelector('molin-shop-ai').closeChat()` closes it

For sending a message at the same time, see [Send message programmatically](/home/general/send-message).

## Wire up your own button

Wrap any element in an `onclick` that calls `openChat()`:

```html theme={null}
<button type="button" onclick="document.querySelector('molin-shop-ai').openChat()">Chat with us</button>
```

Style it however you want, the API is independent of the markup:

```html theme={null}
<button
  type="button"
  onclick="document.querySelector('molin-shop-ai').openChat()"
  class="rounded-full bg-[#601FEB] px-8 py-2 text-base font-medium text-white transition-colors duration-200 hover:bg-[#8624FF]">
  Chat with us
</button>
```

## Make an existing element clickable

If you already have an image, banner, or text block you want to use as the trigger, wrap it in an anchor that calls `openChat()`:

```html theme={null}
<a href="javascript:void(0);" onclick="document.querySelector('molin-shop-ai').openChat()">
  <!-- your element here -->
</a>
```

## Related

* [Elements](/home/general/elements) — drop-in HTML tags including the prebuilt chat button
* [Send message programmatically](/home/general/send-message) — open the chat AND deliver a message in one call
* [Show/Hide widget](/apis/experimental/show-hide-widget) — control widget visibility


# Search API
Source: https://docs.molin.ai/home/general/search-api

Query your Molin-indexed catalog from your own storefront code, using the same public read-only endpoints the search box calls.

The Search API returns products from the catalog Molin already indexed for your chatbot. Text queries combine semantic intent with keyword matching. It powers [`<molin-shop-ai-search>`](/home/general/elements), and you can call it directly when you want to build your own search or category UI.

All three endpoints are public, read-only, and need no API key: the widget ID identifies the catalog, and shoppers call them straight from the browser.

<Note>
  Call `widget.molin.ai`, never `molin.ai`. Keeping every widget request on one origin means you don't have to add another origin to your [Content Security
  Policy](/home/general/content-security-policy).
</Note>

## `GET /v1/search`

```bash theme={null}
curl "https://widget.molin.ai/v1/search?widgetId=abc12345&q=winter%20jacket&limit=12"
```

<ParamField type="string">
  Your widget ID, which selects the catalog to search.
</ParamField>

<ParamField type="string">
  The search text. Omit it to list the catalog, which is what a category page needs.
</ParamField>

<ParamField type="JSON array">
  Up to 10 product-attribute filters. Each filter has a `key` and `value`, and the whole array is JSON-encoded. Use the stable keys returned by `/v1/search/facets`: `brand`, `category`, `color`,
  `size`, `material`, or `gender`. Existing integrations can continue to send a raw feed attribute key.

  A `category` value matches that category and everything below it, so filtering on `Footwear` also returns products filed under `Footwear > Running Shoes`. Build a category page from whichever
  level you want to show, rather than listing every child. Every other key matches the value itself.
</ParamField>

<ParamField type="number">
  Lowest price to include.
</ParamField>

<ParamField type="number">
  Highest price to include.
</ParamField>

<ParamField type="string">
  Three-letter currency code for the price filters.
</ParamField>

<ParamField type="'newest' | 'oldest' | 'cheapest' | 'priciest'">
  Sort order. Omit it to sort by relevance.
</ParamField>

<ParamField type="number">
  Products per page, from 1 through 60.
</ParamField>

<ParamField type="number">
  Products to skip, up to 500. The ranker scores `limit + offset` candidates, so deep paging is bounded deliberately.
</ParamField>

### Response

```json theme={null}
{
  "results": [
    {
      "url": "https://store.example/products/alpine-winter-jacket",
      "title": "Alpine Winter Jacket",
      "price": "199.00 EUR",
      "originalPrice": "249.00 EUR",
      "priceAmount": 199,
      "image": "https://store.example/cdn/jacket.jpg",
      "sku": "AWJ-001",
      "gtin": "5901234123457",
      "storefrontProductId": "8123456789",
      "stockQuantity": 14
    }
  ],
  "total": 1,
  "exhausted": true
}
```

<ResponseField name="results" type="array">
  Matching products in ranked order. `originalPrice` is empty when the source didn't provide a price before the discount. `priceAmount` and `stockQuantity` are `null` when the source data didn't
  provide them.
</ResponseField>

<ResponseField name="total" type="number">
  For a text query, the number of ranked candidates. For a filter-only listing, the full number of matches before `limit` and `offset`.
</ResponseField>

<ResponseField name="exhausted" type="boolean">
  `true` when this page reached the end of the matches, so there is no next page to request.
</ResponseField>

## `GET /v1/search/facets`

Returns the stable filters available for one catalog. Molin groups equivalent source fields such as `Color`, `Colour`, and `Szín` under `color` without renaming or changing the feed data. Values stay exactly as the feed supplied them.

```bash theme={null}
curl "https://widget.molin.ai/v1/search/facets?widgetId=abc12345"
```

<ParamField type="string">
  Your widget ID.
</ParamField>

### Response

```json theme={null}
{
  "facets": [
    { "key": "color", "values": ["Black", "Fekete", "Blue"] },
    { "key": "size", "values": ["S", "M", "L"] }
  ]
}
```

<ResponseField name="facets" type="array">
  Available `brand`, `category`, `color`, `size`, `material`, and `gender` filters. Each entry contains the most common values from the catalog. Store-specific fields outside this reviewed list are
  not exposed here.
</ResponseField>

## `GET /v1/search/suggest`

Returns the whole suggestion set for a widget in one response. Fetch it once, then filter it in the browser as the shopper types, rather than requesting per keystroke.

```bash theme={null}
curl "https://widget.molin.ai/v1/search/suggest?widgetId=abc12345"
```

<ParamField type="string">
  Your widget ID.
</ParamField>

### Response

```json theme={null}
{
  "queries": ["winter jacket", "ski gloves"],
  "products": [
    {
      "title": "Alpine Winter Jacket",
      "url": "https://store.example/products/alpine-winter-jacket",
      "image": "https://store.example/cdn/jacket.jpg",
      "price": "199.00 EUR",
      "originalPrice": "249.00 EUR"
    }
  ]
}
```

<ResponseField name="queries" type="string[]">
  Searches other shoppers on your store ran and got results for. Searches that always came back empty are excluded, so a suggestion never leads to a dead end. A search only appears once at least two
  different shoppers ran it.
</ResponseField>

<ResponseField name="products" type="array">
  Newest products with their image and prices, as a starting point for a store with no search history yet. `originalPrice` is empty when no discount price was supplied.
</ResponseField>

## Caching and limits

Search responses are cacheable for 60 seconds and revalidate in the background for a further 5 minutes. Facets and suggestions are cached for 5 minutes and can still be served for a week while they refresh in the background, because they move slowly and slightly stale data is harmless.

Search is rate limited per IP. Repeated identical searches are usually served from the edge cache without reaching our worker at all.

## Errors

All three endpoints answer `400` for a missing or unknown widget ID and for any parameter outside the ranges described earlier, with no body. Treat a rejection as a bug in the request rather than something to retry.


# Send message programmatically
Source: https://docs.molin.ai/home/general/send-message

Use the openChat API to programmatically open the chat window and send a message on the customer's behalf from your own code.

## Overview

The `openChat` API allows you to programmatically open the chat window and send a message on behalf of the user. This is useful for:

* Sending automated support requests based on user actions
* Creating contextual help buttons that send specific inquiries
* Triggering chat conversations from forms, errors, or page events
* Automating customer service workflows

<Note>For controlling widget visibility, see [Show/Hide Widget](/apis/experimental/show-hide-widget).</Note>

<Tip>
  **No code required?** You can also open the chat via URL parameters without any JavaScript. See [Open chat via URL](/home/general/url-prefill) for a simple way to create links for marketing
  campaigns, emails, and QR codes.
</Tip>

## Method

The widget exposes this method for opening the chat:

```javascript Open chat with optional message, auto-send, and fullscreen control theme={null}
window.Molin.openChat({ message, autoSend, fullscreen });
```

### Alternative method (web component)

You can also use the web component selector:

```javascript Open chat using web component selector theme={null}
document.querySelector('molin-shop-ai').openChat({ message, autoSend, fullscreen });
```

### Parameters

<ParamField type="object">
  Optional configuration object. Can be omitted entirely to simply open the chat without any message. When provided, can contain the following optional properties:

  <ParamField type="string">
    The message to send when opening the chat. If omitted, the chat opens without any pre-filled message.
  </ParamField>

  <ParamField type="boolean">
    Whether to automatically send the message. When `false` (default), the message will only be prefilled in the input field for the user to review and send manually. When `true`, the message is sent
    immediately.
  </ParamField>

  <ParamField type="boolean">
    Whether to open the chat window filling the whole screen on desktop. When `false` (default), the chat opens in the normal floating window. On mobile the chat is always fullscreen regardless of
    this setting.
  </ParamField>
</ParamField>

**Valid function calls:**

* `openChat()` - Opens chat without any message
* `openChat({ message: "Hello" })` - Opens chat with pre-filled message (not sent)
* `openChat({ message: "Hello", autoSend: true })` - Opens chat and sends message immediately
* `openChat({ fullscreen: true })` - Opens chat fullscreen on desktop

## Open the launcher in fullscreen by default

The `fullscreen` option above controls a single `openChat` call. To make the launcher (the floating bubble) and every other affordance open the chat fullscreen on desktop by default, set it once at the widget level.

Set it before the widget loads via `window.molinSettings`:

```html theme={null}
<script>
  window.molinSettings = {
    fullscreen: true,
  };
</script>
```

Or add the `fullscreen` attribute to the embed tag:

```html theme={null}
<molin-shop-ai widget="your-widget-id" fullscreen></molin-shop-ai>
```

A per-call `openChat({ fullscreen })` always wins over this default, so a specific button can still open the normal floating window. On mobile the chat is always fullscreen regardless of this setting.

## Examples

### Basic Usage - Open Chat Button

<BasicChatButton />

```javascript Basic Usage lines icon="js" theme={null}
// Method 1:
window.Molin.openChat();

// Method 2:
document.querySelector('molin-shop-ai').openChat();
```

### Pre-filled Message - Product Inquiry

<ProductInquiryExample />

```javascript Pre-filled Message lines wrap icon="js" theme={null}
// Method 1:
window.Molin.openChat({
  message: 'I have questions about the product pricing, availability, and features. Can you help me with that?',
  autoSend: false,
});

// Method 2:
document.querySelector('molin-shop-ai').openChat({
  message: 'I have questions about the product pricing, availability, and features. Can you help me with that?',
  autoSend: false,
});
```

### Auto-send Messages - Support Scenarios

<AutoSendExample />

<CodeGroup>
  ```javascript Order Status Help lines wrap icon="js" theme={null}
  // Method 1:
  window.Molin.openChat({
    message:
      "I need help with my order status. Can you please check what's happening with my recent purchase?",
    autoSend: false,
  })

  // Method 2:
  document.querySelector("molin-shop-ai").openChat({
  message:
  "I need help with my order status. Can you please check what's happening with my recent purchase?",
  autoSend: false,
  })

  ```

  ```javascript Return Item lines wrap icon="js" theme={null}
  // Method 1:
  window.Molin.openChat({
    message:
      "I would like to return an item I purchased. Can you help me with the return process?",
    autoSend: false,
  })

  // Method 2:
  document.querySelector("molin-shop-ai").openChat({
    message:
      "I would like to return an item I purchased. Can you help me with the return process?",
    autoSend: false,
  })
  ```

  ```javascript Billing Questions lines wrap icon="js" theme={null}
  // Method 1:
  window.Molin.openChat({
    message: 'I have a question about my billing. There seems to be an issue with my last payment.',
    autoSend: false,
  });

  // Method 2:
  document.querySelector('molin-shop-ai').openChat({
    message: 'I have a question about my billing. There seems to be an issue with my last payment.',
    autoSend: false,
  });
  ```
</CodeGroup>

### Smart Search with AI Integration

<SearchAutocomplete />

```javascript AI Search Integration theme={null}
// When user searches, open chat with search context
const searchQuery = 'wireless headphones';
window.Molin.openChat({
  message: `I'm looking for: ${searchQuery}. Can you help me find what I need?`,
  autoSend: false,
});
```

<Note>The search component integrates AI assistance with product search, allowing users to get personalized recommendations through the chat widget.</Note>

### Product Grid with AI Expert

<ProductGrid />

```javascript Product Grid with AI Expert theme={null}
// When user clicks on AI expert card
window.Molin.openChat({
  message: 'I need help finding the right product. Can you assist me with personalized recommendations?',
  autoSend: false,
});
```

<Note>The product grid includes an AI expert consultation option that opens the chat widget with a pre-filled message for personalized assistance.</Note>

## Interactive Playground

Try the openChat API with this interactive example:

<OpenChatPlayground />

<Note>
  This playground will only work if the Molin widget is installed on this documentation page. If you're viewing this in the documentation, it may show a warning that the widget is not loaded.
</Note>

## Technical note

The `openChat` method is only available after the widget script has loaded. The recommended approach is to listen for the [`molin:ready`](/home/marketing/javascript-events#molinready) event:

```javascript theme={null}
window.addEventListener('molin:ready', () => {
  window.Molin.openChat({ message: 'Your message here' });
});
```

Alternatively, you can check if `window.Molin` already exists:

```javascript theme={null}
if (window.Molin && window.Molin.openChat) {
  window.Molin.openChat({ message: 'Your message here' });
}
```


# Static IPs
Source: https://docs.molin.ai/home/general/static-ips

The static IP addresses Molin uses to reach your server, so you can allowlist us for product feeds and API requests.

## UNAS

Molin always uses the following IP for UNAS feeds and API requests:

```
35.207.69.21
```

## Product feeds

Molin downloads your product feed using the following IPs:

```
35.207.69.21
209.38.162.129
```

<Note>Make sure you allowlist all of them.</Note>

## Custom actions

All calls on behalf of custom actions sent to your server are made through the following IPs:

```
35.207.69.21
209.38.162.129
```

<Note>Make sure you allowlist all of them.</Note>


# Open chat via URL
Source: https://docs.molin.ai/home/general/url-prefill

Create links that open your chatbot with a message already typed in, using nothing but URL parameters on any page of your site.

## Overview

You can open the chat with a prefilled message by adding URL parameters to any page on your website. This is perfect for:

* Marketing campaigns with pre-written questions
* Email links that open chat with context
* QR codes that start specific conversations
* Social media links with call-to-action messages
* Support links with predefined inquiries

<Note>This feature requires no JavaScript code. Just add parameters to your existing URLs.</Note>

## URL builder

Use this tool to generate URLs for your campaigns:

<UrlPrefillBuilder />

## Parameters

| Parameter        | Required | Description                                            |
| ---------------- | -------- | ------------------------------------------------------ |
| `molin_message`  | Yes      | The message to prefill in the chat input (URL-encoded) |
| `molin_autosend` | No       | Set to `1` to automatically send the message           |

## URL encoding

Special characters must be URL-encoded. Common encodings:

| Character | Encoded |
| --------- | ------- |
| Space     | `%20`   |
| `?`       | `%3F`   |
| `&`       | `%26`   |
| `=`       | `%3D`   |
| `!`       | `%21`   |
| `'`       | `%27`   |

<Tip>The URL builder above handles encoding automatically. For manual encoding, use JavaScript's `encodeURIComponent()` function.</Tip>

## Examples

### Product inquiry

Direct users to ask about a specific product:

```
https://yourstore.com/products/blue-sneakers?molin_message=Tell%20me%20more%20about%20these%20sneakers
```

### Support request

Create a support link in your email footer:

```
https://yourstore.com?molin_message=I%20need%20help%20with%20my%20order
```

### Campaign landing page

Add to marketing campaigns with a specific question:

```
https://yourstore.com/summer-sale?molin_message=What%20deals%20are%20available%20today%3F
```

### Order tracking

Link from order confirmation emails:

```
https://yourstore.com/account?molin_message=Where%20is%20my%20order%3F&molin_autosend=1
```

## Use cases

### Email marketing

Add prefilled chat links to your email campaigns:

```html theme={null}
<a href="https://yourstore.com?molin_message=I%20saw%20your%20email%20about%20the%20sale"> Chat with us about deals </a>
```

### QR codes

Generate QR codes that link to URLs with prefilled messages. When scanned, customers immediately start a relevant conversation.

### Social media ads

Use prefilled URLs in your ad campaigns to start targeted conversations:

* Facebook ads → product-specific questions
* Instagram bio → general inquiries
* Twitter links → support requests

### Website buttons

Create buttons that open chat with context:

```html theme={null}
<a href="?molin_message=I%20want%20to%20learn%20more">Ask a question</a>
```

<Tip>For more control over chat behavior, see [Send message programmatically](/home/general/send-message) for the JavaScript API.</Tip>

## Combining with existing URLs

The parameters work with any existing URL on your site:

```
# Homepage
https://yourstore.com?molin_message=Hello

# Product page
https://yourstore.com/products/item-123?molin_message=Is%20this%20in%20stock

# With existing parameters
https://yourstore.com/search?q=shoes&molin_message=Help%20me%20find%20shoes
```

## Technical notes

* Parameters are parsed when the widget script loads
* The chat opens automatically when a valid `molin_message` is detected
* After the chat opens, `molin_*` parameters are automatically removed from the URL (using `history.replaceState`) to keep URLs clean
* Works with all widget embed methods (script tag, Shopify app, etc.)


# Inbox
Source: https://docs.molin.ai/home/inbox/inbox

Read every chat your AI had across web, Messenger, Instagram, and email, assign chats to teammates, filter by channel or priority, and follow up on leads.

The Inbox is where your team reads chats the AI has had, across web, Facebook Messenger, Instagram, and email (when those channels are turned on).

<Note>Find it in your dashboard under [**Inbox**](https://molin.ai/app/inbox).</Note>

## Filters

You can narrow down the list with these filters:

* **Unread** chats only.
* **Leads**: chats where the AI captured contact details.
* **Live Chat**: chats where a human took over.
* **Facebook**, **Instagram**, **Email**: only show chats from that channel.
* **Assignee**: chats owned by you, by a specific teammate, or not yet assigned to anyone. See [Assignment](#assignment).
* **Urgent Priority**, **Normal Priority**, **Low Priority**: by the priority the AI gave the chat.
* **Test**: chats marked as test.

You can also **search** by name, email, or phone, and view **archived** or **spam** chats.

## What you see in a chat

Click any chat in the list to see:

* The full message history.
* The customer’s name, email, or phone (if collected).
* The channel and the widget the chat came from.
* A side panel showing lead details and live chat status.

<Tip>See [Live chat](/home/inbox/live-chat) for how to take over a chat as a human agent.</Tip>

## Assignment

Assign a chat to a teammate so everyone knows who owns it, and nobody answers the same customer twice.

<video />

### Assign a chat

1. Open the chat you want to hand over.
2. In the side panel, open the **Assignee** selector.
3. Pick a teammate. Use **Search teammates** if your team is long.

Their avatar appears on the chat's row in the list straight away, so you can see who owns what without opening anything.

To hand a chat back, choose **Unassigned**.

### Work your own queue

Use the **Assignee** filter at the top of the inbox to narrow the list down to one person:

* **Assigned to me**: your own queue.
* **Unassigned**: chats nobody has picked up yet.
* Any teammate, so a team lead can check on one agent's workload.

### Who you can assign to

You can only assign chats to active members of your team. Someone who has left your team, or who no longer holds a seat, doesn't appear in the selector, and any chat they already owned stays with them until you move it.

<Note>Assigning a chat doesn't notify the assignee.</Note>

### Assignment and live chat

Ownership and [live chat](/home/inbox/live-chat) are separate. Assigning a chat doesn't start a live chat, and the owner stays in place after a live chat session ends.

Taking over a chat in live chat does set ownership, but only when nobody owns it yet: you are assigned automatically, and a chat that already has an owner keeps that owner.


# Live chat
Source: https://docs.molin.ai/home/inbox/live-chat

Take over an AI chat as a human agent straight from the Inbox. The AI stops replying until you end the live chat session.

When the AI can’t solve something or a customer asks to talk to a person, you can take over the chat from the Inbox. While you’re in live chat, the AI stops replying.

<Note>Available in the [**Inbox**](https://molin.ai/app/inbox) on any open chat.</Note>

## How to take over

1. Open the chat in the Inbox.
2. In the side panel, click **Take over from AI**.
3. Type your replies. The customer sees your name and profile picture.
4. When you’re done, click **End Live Chat Session**. The AI takes over again.

If the customer asks for a human, you’ll see **Accept** and **Reject** buttons instead. Accept works the same as taking over.

## Telling the AI when to suggest a handoff

You can write a rule in [Personality & instructions](/home/chatbot/personality) so the AI knows when to bring in a human:

```
If the customer is upset or asks to speak to a person, collect their email and tell them an agent will get back to them.
If the question is about an existing order and the customer is logged in, look up the order first.
Otherwise, collect their contact details.
```

## Notifications

Set the email that gets notified about new leads and live chat requests under [**Chatbot → Personality → Contact details**](https://molin.ai/app/personality).

<Tip>Set when your team is around under [Working hours](/home/inbox/working-hours). When no one is available, the AI tells the customer when you’ll get back to them.</Tip>


# Working hours
Source: https://docs.molin.ai/home/inbox/working-hours

Tell the AI when your team is available, so it sets the right expectations with customers and says when a human will be back.

Working hours define when human agents are available. Outside those hours, the AI handles every conversation and tells the customer when a human will be back.

<Note>Set them under [**Chatbot → Actions → Live chat**](https://molin.ai/app/actions).</Note>

## Example schedule

```
Mon–Fri  09:00–18:00
Sat      10:00–14:00
Sun      closed
```

Times are in the timezone you choose for the widget.


# Overview
Source: https://docs.molin.ai/home/intro/welcome

Molin is the conversational AI platform for e-commerce shops. It connects to your systems, answers customers, and runs support tasks for you.

<Tip>We release new features continuously, so we recommend you to create a free Molin [account](https://molin.ai/login) to not miss anything.</Tip>

<Info>Looking to create your AI chatbot with Molin? Visit [molin.ai](https://molin.ai/)</Info>

## Get started

<CardGroup>
  <Card title="Help articles" icon="circle-info" href="/home/platforms/shopify">
    Find answers to your problems.
  </Card>

  <Card title="API" icon="link" href="/apis/get-started/api-introduction">
    Learn how to make custom AI actions.
  </Card>
</CardGroup>


# Documents
Source: https://docs.molin.ai/home/knowledge/documents

Teach your AI from PDFs, web pages, and policy documents, so it can answer questions about shipping, warranties, and sizing.

Documents let your AI answer questions that aren’t in your product catalog: shipping policies, warranty terms, sizing guides, FAQs from your old help center, anything.

<Note>Find it in your dashboard under [**AI Knowledge → Documents**](https://molin.ai/app/documents).</Note>

## What you can add

* **PDFs**: upload a PDF file (text only, images are skipped). Max 10 MB.
* **Markdown**: upload a `.md`, `.markdown`, or `.txt` file. Max 10 MB.
* **Website**: give Molin a URL and it will find and add all the sub-pages (like a blog).
* **Sitemap**: give Molin a `sitemap.xml` link and it will add every page in it.
* **llms.txt**: give Molin your site's URL and it will add the pages listed in its [llms.txt](https://llmstxt.org/). Because that file is the page list your own site publishes for AI, it's usually cleaner than a sitemap, which also contains tag pages, pagination, and other pages your customers never ask about.
* **Specific web pages**: paste a list of URLs you want to add.

Each document can hold up to 100,000 characters.

## How it works

1. Add a PDF or some URLs.
2. Molin reads the text. This takes a few minutes for new documents.
3. When a customer asks a question, the AI looks through your documents and uses the most relevant parts to answer.

## Best practices

* **One topic per document.** A 200-page PDF that covers ten different topics will give worse answers than ten short documents that each cover one topic.
* **Use clear titles** so you can find them later. Try "Return policy 2026" instead of "doc\_final\_v3".
* **Keep them up to date.** Old documents lead to wrong answers. Delete what no longer applies.
* **Don’t upload your full product list.** Use the product feed for that. Documents are for things like policies and guides.


# FAQs
Source: https://docs.molin.ai/home/knowledge/faqs

Add the questions your customers ask most and write the answers yourself, so the AI replies exactly how you want it to.

FAQs are question and answer pairs you write yourself. The AI uses them when a customer asks something similar.

<Note>Find it in your dashboard under [**AI Knowledge → FAQs**](https://molin.ai/app/faqs).</Note>

## When to use an FAQ vs Personality

| You want…                                      | Where to put it |
| ---------------------------------------------- | --------------- |
| To set the tone or rules the AI follows        | Personality     |
| A specific question with a specific answer     | FAQ             |
| Legal or policy wording you don’t want changed | FAQ             |
| Something customers ask all the time           | FAQ             |

## How it works

1. Write the question and the answer.
2. When a customer asks something similar, the AI uses your answer.

## Examples

* **Q:** Do you ship to the EU?
  **A:** Yes, we ship to all EU countries. Delivery takes 3 to 5 business days and is free above €50.
* **Q:** What is your return policy?
  **A:** You can return any unworn item within 30 days for a full refund. Email [returns@acme.com](mailto:returns@acme.com) to start.

## Best practices

* **Write the question the way a customer would.** For example, "When will my order arrive?" instead of "What is the shipping SLA?".
* **Add the most common ways people ask the same thing.** Customers phrase things differently.
* **Keep answers short.** One or two sentences is enough.


# Google Analytics & GTM
Source: https://docs.molin.ai/home/marketing/integrations/google-analytics

Track how visitors use your AI assistant in Google Analytics, with e-commerce interactions pushed automatically through dataLayer events.

The Molin AI widget automatically sends interaction data to your website's Google Analytics through Google Tag Manager (GTM) integration, allowing you to track how users engage with the AI assistant on your site.

## What is the dataLayer integration?

The dataLayer integration automatically pushes events to the browser's `window.dataLayer` object when users interact with the Molin AI widget. All events are sent automatically, so no configuration is required on your part.

## Custom events

### `molin_chat_open`

Fired when the user opens the chat window.

```json theme={null}
{
  "event": "molin_chat_open",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

### `molin_chat_close`

Fired when the user closes the chat window.

```json theme={null}
{
  "event": "molin_chat_close",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

### `molin_message_sent`

Fired when the user sends a message in the chat.

```json theme={null}
{
  "event": "molin_message_sent",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

### `molin_link_click`

Fired when the user clicks a link inside a Molin AI widget conversation.

```json theme={null}
{
  "event": "molin_link_click",
  "widget_id": "abc123",
  "url": "https://yourstore.com/product/123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |
| `url`       | `string` | The URL of the clicked link       |

### `molin_lead_collected`

Fired when the AI successfully collects a lead (the visitor's name and contact details) in the chat.

This is the strongest conversion signal the widget emits. Unlike engagement events such as `molin_chat_open` or `molin_message_sent`, it fires only when a real lead was captured, so it is the recommended event for conversion tracking and ad campaign optimization.

```json theme={null}
{
  "event": "molin_lead_collected",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

<Tip>
  To optimize ad campaigns on Molin leads: create a GTM trigger for the `molin_lead_collected` dataLayer event, forward it to GA4 as a custom event, then mark it as a key event in GA4 and import it as
  a conversion in Google Ads.
</Tip>

### `molin_order_lookup`

Fired when the AI finds a customer's order and shows its details in the chat (order status, tracking, items). A useful signal for measuring support automation.

```json theme={null}
{
  "event": "molin_order_lookup",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

### `molin_live_chat_requested`

Fired when the AI successfully starts a live chat request, escalating the visitor to a human support agent. It does not fire when agents are unavailable or the request fails.

```json theme={null}
{
  "event": "molin_live_chat_requested",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

### `molin_product_review_shown`

Fired when the AI shows customer product reviews in the chat.

```json theme={null}
{
  "event": "molin_product_review_shown",
  "widget_id": "abc123"
}
```

| Parameter   | Type     | Description                       |
| ----------- | -------- | --------------------------------- |
| `widget_id` | `string` | The unique ID of the Molin widget |

## GA4 e-commerce events

The widget also pushes standard [GA4 e-commerce events](https://developers.google.com/analytics/devguides/collection/ga4/ecommerce) so that AI-driven product recommendations appear natively in your Google Analytics e-commerce reports.

### `view_item_list`

Fired when the AI recommends products in the chat. Each product is included as an item.

```javascript theme={null}
{
  event: 'view_item_list',
  ecommerce: {
    item_list_id: 'molin_ai_chat',
    item_list_name: 'Molin AI chat',
    items: [
      {
        item_name: 'Adidas Ultraboost 5',
        index: 0,
        item_list_id: 'molin_ai_chat',
        item_list_name: 'Molin AI chat',
        price: 189.99,
        google_business_vertical: 'retail'
      },
      {
        item_name: 'Adidas Gazelle Bold',
        index: 1,
        item_list_id: 'molin_ai_chat',
        item_list_name: 'Molin AI chat',
        price: 119.99,
        google_business_vertical: 'retail'
      }
    ]
  }
}
```

### `select_item`

Fired when the user clicks on a product card link. Identifies which product was selected from the recommendation list.

```javascript theme={null}
{
  event: 'select_item',
  ecommerce: {
    item_list_id: 'molin_ai_chat',
    item_list_name: 'Molin AI chat',
    items: [
      {
        item_name: 'Adidas Ultraboost 5',
        index: 0,
        item_list_id: 'molin_ai_chat',
        item_list_name: 'Molin AI chat',
        price: 189.99,
        google_business_vertical: 'retail'
      }
    ]
  }
}
```

### `view_item`

Fired alongside `select_item` when the user clicks a product card link. This event is used by GA4 to track product detail views.

```javascript theme={null}
{
  event: 'view_item',
  ecommerce: {
    items: [
      {
        item_name: 'Adidas Ultraboost 5',
        index: 0,
        item_list_id: 'molin_ai_chat',
        item_list_name: 'Molin AI chat',
        price: 189.99,
        google_business_vertical: 'retail'
      }
    ]
  }
}
```

### E-commerce item fields

| Field                      | Type     | Description                                        |
| -------------------------- | -------- | -------------------------------------------------- |
| `item_name`                | `string` | Product name from the product catalog              |
| `index`                    | `number` | Position of the product in the recommendation list |
| `item_list_id`             | `string` | Always `molin_ai_chat`                             |
| `item_list_name`           | `string` | Always `Molin AI chat`                             |
| `price`                    | `number` | Product price parsed from the catalog              |
| `google_business_vertical` | `string` | Always `retail`                                    |

<Note>The `price` field may be `0` in some cases. We are still upgrading our internal price parsing logic to cover all catalog formats reliably.</Note>

## Technical note

<Note>
  Before each e-commerce event, the widget pushes `{ ecommerce: null }` to clear the previous e-commerce object, following [Google's recommended practice](https://developers.google.com/analytics/devguides/collection/ga4/ecommerce#clear_the_ecommerce_object).
</Note>


# Klaviyo
Source: https://docs.molin.ai/home/marketing/integrations/klaviyo

Understand how Molin AI integrates with Klaviyo for tracking customer interactions and triggering automations.

If you use [Klaviyo](https://www.klaviyo.com/) on your website, the Molin AI widget automatically sends custom events to Klaviyo. You can trigger flows, build segments, and analyze engagement from chat interactions. No setup needed.

## How it works

When a visitor interacts with the widget, we call `klaviyo.push(["track", ...])` on the [Klaviyo client-side API](https://developers.klaviyo.com/en/docs/introduction_to_the_klaviyo_object). You see these events as metrics in your Klaviyo account, and you can use them in flows, segments, and reports.

<Note>If you don't have Klaviyo on your website, we skip these calls. You won't see any performance hit or errors.</Note>

## Custom events

We fire events via `klaviyo.push(["track", name])`. They appear as metrics in Klaviyo.

| Event                        | When it fires                                           |
| ---------------------------- | ------------------------------------------------------- |
| `molin_chat_open`            | User opens the chat window                              |
| `molin_chat_close`           | User closes the chat window                             |
| `molin_message_sent`         | User sends a message in the chat                        |
| `molin_link_click`           | User clicks a link inside the chat conversation         |
| `molin_lead_collected`       | The AI collects a lead (visitor name + contact details) |
| `molin_order_lookup`         | The AI finds an order and shows its details             |
| `molin_live_chat_requested`  | The AI escalates the visitor to a human support agent   |
| `molin_product_review_shown` | The AI shows customer product reviews                   |

## Using events in Klaviyo

Once events are flowing, you can:

* **Create flows** triggered by any of these events (e.g. send a follow-up email after a user interacts with the chat).
* **Build segments** based on event activity (e.g. "users who chatted in the last 7 days").
* **Analyze engagement** in Klaviyo's analytics dashboards.

<Note>Klaviyo's client-side tracking only records events for visitors it has already identified (cookied). It doesn't track events for anonymous visitors.</Note>

## Requirements

You must already have Klaviyo's onsite JavaScript (`klaviyo.js`) on your website.


# Microsoft Clarity
Source: https://docs.molin.ai/home/marketing/integrations/microsoft-clarity

The Molin AI widget sends custom tags and events to Microsoft Clarity, so you can filter session recordings and heatmaps by chat activity.

If you use [Microsoft Clarity](https://clarity.microsoft.com/) on your website, the Molin AI widget automatically sends custom tags and events to Clarity. This lets you filter session recordings and heatmaps by Molin AI interactions, with zero configuration.

## How it works

When a visitor interacts with the widget, we call the [Clarity client API](https://learn.microsoft.com/en-us/clarity/setup-and-installation/clarity-api) (`window.clarity(...)`) to:

1. **Tag the session** with the widget ID so you can filter recordings.
2. **Fire custom events** for key interactions so they appear alongside Clarity's Smart Events.
3. **Upgrade the session** to prioritize it for recording when a user opens the chat.

<Note>If Clarity is not installed on your website, these calls are silently skipped. There is no performance impact and no errors.</Note>

## Custom tags

Tags are set via `window.clarity("set", key, value)` and appear in Clarity's Filters panel.

| Tag               | Value          | Description                                        |
| ----------------- | -------------- | -------------------------------------------------- |
| `molin_widget_id` | your widget ID | Set once per page load so you can filter by widget |

## Custom events

Events are fired via `window.clarity("event", name)` and appear in the Smart Events section.

| Event                        | When it fires                                           |
| ---------------------------- | ------------------------------------------------------- |
| `molin_chat_open`            | User opens the chat window                              |
| `molin_chat_close`           | User closes the chat window                             |
| `molin_message_sent`         | User sends a message in the chat                        |
| `molin_link_click`           | User clicks a link inside the chat conversation         |
| `molin_lead_collected`       | The AI collects a lead (visitor name + contact details) |
| `molin_order_lookup`         | The AI finds an order and shows its details             |
| `molin_live_chat_requested`  | The AI escalates the visitor to a human support agent   |
| `molin_product_review_shown` | The AI shows customer product reviews                   |

## Session upgrade

When a user sends a message, the AI collects a lead, or the visitor escalates to live chat, we call `window.clarity("upgrade", reason)`. This tells Clarity to prioritize recording this session, which is useful if your site exceeds Clarity's daily recording limit and sampling kicks in. Sessions where users interacted with the AI are high-value and worth preserving.

## Requirements

Microsoft Clarity must already be installed on your website (the Clarity `<script>` tag in your page).


# JavaScript lifecycle events
Source: https://docs.molin.ai/home/marketing/javascript-events

React to widget lifecycle events with settings hooks or standard JavaScript listeners, to trigger integrations or adjust your page layout.

The Molin AI widget notifies your website at key moments in its lifecycle. You can use these hooks to trigger custom logic such as initializing integrations, adjusting page layout, or tracking analytics.

## Settings hooks (recommended)

The simplest and most reliable approach is to define callback functions directly in `window.molinSettings`. Because this object is defined before the widget script loads, the `onReady` hook is **guaranteed to fire**.

```html theme={null}
<script>
  window.molinSettings = {
    onReady: (e) => {
      console.log('Widget ready:', e.widgetId);
      window.Molin.openChat();
    },
    onChatOpen: (e) => {
      console.log('Chat opened:', e.widgetId);
    },
    onChatClose: (e) => {
      console.log('Chat closed:', e.widgetId);
    },
    onMessageSent: (e) => {
      console.log('Message sent:', e.widgetId);
    },
    onLinkClick: (e) => {
      console.log('Link clicked:', e.widgetId, e.url);
    },
    onAddToCart: (e) => {
      console.log('Added to cart:', e.widgetId, e.url);
    },
    onLeadCollected: (e) => {
      console.log('Lead collected:', e.widgetId);
    },
  };
</script>
```

### Available hooks

| Hook              | Argument                                                                                                                    | Description                                                                                                  |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `onReady`         | `{ widgetId: string }`                                                                                                      | Called once when the widget has loaded and rendered                                                          |
| `onChatOpen`      | `{ widgetId: string }`                                                                                                      | Called whenever the chat window opens                                                                        |
| `onChatClose`     | `{ widgetId: string }`                                                                                                      | Called whenever the chat window closes                                                                       |
| `onMessageSent`   | `{ widgetId: string }`                                                                                                      | Called when the user sends a message                                                                         |
| `onLinkClick`     | `{ widgetId: string, url: string }`                                                                                         | Called when the user clicks a link in the chat                                                               |
| `onAddToCart`     | `{ widgetId: string, url: string, name: string, price: string, sku?: string, gtin?: string, storefrontProductId?: string }` | Called when the user adds a product to the cart from the chat (see [`molin:add-to-cart`](#molinadd-to-cart)) |
| `onLeadCollected` | `{ widgetId: string }`                                                                                                      | Called when the AI collects a lead (visitor name + contact details)                                          |

<Note>Settings hooks can be combined with other `molinSettings` properties like `hidden` or `userData` in the same object.</Note>

### Custom cart integration

Molin drives the cart out of the box on [Shopify](/home/platforms/shopify#add-to-cart), [Shoper](/home/platforms/shoper#add-to-cart), [Shoprenter](/home/platforms/shoprenter#add-to-cart), and [UNAS](/home/platforms/unas#add-to-cart). On any other platform, register cart handlers in `window.molinSettings` and Molin uses yours instead: the add-to-cart button appears on product cards automatically, and the assistant can read and change the cart during a conversation.

`handleAddToCart` turns the integration on and takes precedence over Molin's built-in platform detection. Add the others to widen what the assistant is allowed to do, and it's offered only what you registered.

| Handler                 | Signature                             | What it enables                                                      |
| ----------------------- | ------------------------------------- | -------------------------------------------------------------------- |
| `handleAddToCart`       | `(product) => Promise<void>`          | Required. The add-to-cart button, and the assistant adding a product |
| `handleGetCart`         | `() => Promise<Cart>`                 | The assistant reading the cart. Required by the two below            |
| `handleRemoveFromCart`  | `(lineId) => Promise<void>`           | The assistant removing a line                                        |
| `handleSetCartQuantity` | `(lineId, quantity) => Promise<void>` | The assistant setting a line to an exact quantity                    |

```html theme={null}
<script>
  window.molinSettings = {
    handleAddToCart: async (product) => {
      // product: { url: string, sku?: string, gtin?: string, storefrontProductId?: string }
      const response = await fetch('/api/my-cart/add', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ id: product.storefrontProductId, sku: product.sku, quantity: 1 }),
      });
      if (!response.ok) {
        throw new Error('could not add to cart');
      }
    },

    handleGetCart: async () => {
      const cart = await fetch('/api/my-cart').then((response) => response.json());
      return {
        lines: cart.items.map((item) => ({
          lineId: item.id, // whatever your cart uses to address one line, passed back to the handlers below
          name: item.title,
          quantity: item.quantity,
          price: item.price,
        })),
        totalPrice: cart.total,
        currency: cart.currency,
      };
    },

    handleRemoveFromCart: async (lineId) => {
      await fetch(`/api/my-cart/${lineId}`, { method: 'DELETE' });
    },

    handleSetCartQuantity: async (lineId, quantity) => {
      await fetch(`/api/my-cart/${lineId}`, { method: 'PATCH', body: JSON.stringify({ quantity }) });
    },
  };
</script>
```

Every handler is **awaited**, unlike the fire-and-forget `onAddToCart` notification. The product card button shows a spinner while your promise is pending, a checkmark when it resolves, and an error indicator when it rejects or doesn't settle within 30 seconds.

Address lines by the `lineId` you returned from `handleGetCart`, not by product ID, because one product can occupy several cart lines.

<Note>
  Your `handleAddToCart` may be called several times in a row for a single request, once per unit, so make it safe to repeat. Registering `handleSetCartQuantity` lets the assistant set a line already
  in the cart in one call instead.
</Note>

<Warning>
  The assistant changes the cart without asking the customer to confirm. Reject in your handler when a change shouldn't be allowed, and the customer is told why instead of the change going through.
</Warning>

<Note>
  When `handleAddToCart` resolves, Molin pushes the standard GA4 `add_to_cart` ecommerce event and fires `molin:add-to-cart`, so don't track your own `add_to_cart` inside the handler or it will be
  double-counted.
</Note>

## Window events (alternative)

The widget also dispatches standard `CustomEvent` events on the `window` object. Use this approach if you need multiple independent listeners for the same event, or if you prefer the DOM event API.

### Available events

#### `molin:ready`

Fired once when the widget has fully loaded its configuration and rendered for the first time.

```javascript theme={null}
window.addEventListener('molin:ready', (e) => {
  console.log('Molin widget is ready:', e.detail.widgetId);

  // safe to call widget methods now
  window.Molin.openChat({ message: 'Welcome!' });
});
```

| Property            | Type     | Description                            |
| ------------------- | -------- | -------------------------------------- |
| `e.detail.widgetId` | `string` | The unique ID of the widget that fired |

<Note>
  If your script loads after the widget, the `molin:ready` event may have already fired. In that case, check if `window.Molin` already exists as a fallback:

  ```javascript theme={null}
  if (window.Molin) {
    // widget is already ready
    onMolinReady();
  } else {
    window.addEventListener('molin:ready', onMolinReady);
  }
  ```

  This race condition does not exist with the settings hooks approach above, which is why it is recommended.
</Note>

#### `molin:chat-open`

Fired whenever the chat window is opened, whether by the user clicking the bubble, a popup click, the floating input, a programmatic call to `openChat()`, or a restored session on mobile.

```javascript theme={null}
window.addEventListener('molin:chat-open', (e) => {
  console.log('Chat opened for widget:', e.detail.widgetId);
});
```

| Property            | Type     | Description                            |
| ------------------- | -------- | -------------------------------------- |
| `e.detail.widgetId` | `string` | The unique ID of the widget that fired |

#### `molin:chat-close`

Fired whenever the chat window is closed, whether by the user clicking the close button, toggling the bubble, or a programmatic call to `closeChat()`.

```javascript theme={null}
window.addEventListener('molin:chat-close', (e) => {
  console.log('Chat closed for widget:', e.detail.widgetId);
});
```

| Property            | Type     | Description                            |
| ------------------- | -------- | -------------------------------------- |
| `e.detail.widgetId` | `string` | The unique ID of the widget that fired |

#### `molin:message-sent`

Fired when the user sends a message in the chat.

```javascript theme={null}
window.addEventListener('molin:message-sent', (e) => {
  console.log('Message sent in widget:', e.detail.widgetId);
});
```

| Property            | Type     | Description                            |
| ------------------- | -------- | -------------------------------------- |
| `e.detail.widgetId` | `string` | The unique ID of the widget that fired |

#### `molin:link-click`

Fired when the user clicks a link inside the chat conversation.

```javascript theme={null}
window.addEventListener('molin:link-click', (e) => {
  console.log('Link clicked:', e.detail.url);
});
```

| Property            | Type     | Description                            |
| ------------------- | -------- | -------------------------------------- |
| `e.detail.widgetId` | `string` | The unique ID of the widget that fired |
| `e.detail.url`      | `string` | The URL of the clicked link            |

#### `molin:add-to-cart`

Fired after the product was successfully added to the cart, either by Molin's built-in integration on [Shopify](/home/platforms/shopify#add-to-cart), [Shoper](/home/platforms/shoper#add-to-cart), [Shoprenter](/home/platforms/shoprenter#add-to-cart), and [UNAS](/home/platforms/unas#add-to-cart) stores (where the button is enabled automatically), or by your own [`handleAddToCart`](#custom-cart-integration) handler on other platforms. Use the event to refresh your theme's cart drawer or cart count badge, since themes usually only update their cart UI in response to their own add-to-cart flows.

```javascript theme={null}
window.addEventListener('molin:add-to-cart', (e) => {
  console.log('Added to cart:', e.detail.url);

  // example: refresh your theme's cart drawer here
});
```

| Property                       | Type     | Description                                                |
| ------------------------------ | -------- | ---------------------------------------------------------- |
| `e.detail.widgetId`            | `string` | The unique ID of the widget that fired                     |
| `e.detail.url`                 | `string` | The URL of the product                                     |
| `e.detail.name`                | `string` | The product name shown on the card                         |
| `e.detail.price`               | `string` | The product price shown on the card                        |
| `e.detail.sku`                 | `string` | The catalog SKU of the product, when known                 |
| `e.detail.gtin`                | `string` | The catalog GTIN/EAN of the product, when known            |
| `e.detail.storefrontProductId` | `string` | The platform-native identifier used by the storefront cart |

#### `molin:lead-collected`

Fired when the AI successfully collects a lead (the visitor's name and contact details) in the chat. Use this to fire your own conversion pixels (e.g. Meta Pixel, TikTok Pixel) on real Molin conversions.

```javascript theme={null}
window.addEventListener('molin:lead-collected', (e) => {
  console.log('Lead collected in widget:', e.detail.widgetId);
});
```

| Property            | Type     | Description                            |
| ------------------- | -------- | -------------------------------------- |
| `e.detail.widgetId` | `string` | The unique ID of the widget that fired |

### Full example

```html theme={null}
<script>
  function onMolinReady(e) {
    console.log('Widget ready:', e.detail.widgetId);
  }

  if (window.Molin) {
    onMolinReady({ detail: { widgetId: 'already-loaded' } });
  } else {
    window.addEventListener('molin:ready', onMolinReady);
  }

  window.addEventListener('molin:chat-open', () => {
    document.body.classList.add('molin-chat-open');
  });

  window.addEventListener('molin:chat-close', () => {
    document.body.classList.remove('molin-chat-open');
  });
</script>
```


# Marketing tracking overview
Source: https://docs.molin.ai/home/marketing/marketing-tracking

An overview of the tracking and analytics built into the Molin AI widget, including UTM tags, dataLayer events, and session integrations.

The Molin AI widget tracks how visitors use the AI assistant on your site. It starts on its own, so you don't need to set anything up.

## UTM tags

When a user clicks a link the AI provided in chat, the widget appends `utm_source=molin.ai` to the URL. You can then attribute that traffic to Molin AI in your analytics platform.

<Card title="UTM tags injection" icon="tag" href="/home/marketing/utm">
  Learn how UTM tags are injected into AI chat links.
</Card>

## Google Analytics & GTM (dataLayer)

The widget pushes events to `window.dataLayer` for Google Tag Manager integration. This includes the `molin_lead_collected` conversion event for ad campaign optimization, a general link click event, and standard GA4 e-commerce events (`view_item_list`, `select_item`, `view_item`) for product recommendations.

<Card title="Google Analytics & GTM" icon="chart-line" href="/home/marketing/integrations/google-analytics">
  See all dataLayer events including GA4 e-commerce tracking.
</Card>

## Klaviyo

If you use Klaviyo, the widget sends custom events to Klaviyo's client-side API automatically. You can trigger flows and build segments from chat interactions without configuring anything.

<Card title="Klaviyo" icon="envelope" href="/home/marketing/integrations/klaviyo">
  See which Klaviyo events are sent automatically.
</Card>

## Microsoft Clarity

If you use Microsoft Clarity, the widget tags sessions and fires custom events automatically. You can then filter your session recordings to see only those with Molin AI interactions.

<Card title="Microsoft Clarity" icon="eye" href="/home/marketing/integrations/microsoft-clarity">
  See which Clarity tags and events are sent automatically.
</Card>

## JavaScript lifecycle events

The widget dispatches `molin:ready`, `molin:chat-open`, and `molin:chat-close` events on `window`. Your site can listen for these to fire your own analytics or run any other custom logic.

<Card title="JavaScript lifecycle events" icon="code" href="/home/marketing/javascript-events">
  Listen for widget lifecycle events with standard JavaScript.
</Card>


# UTM tags in AI chat links
Source: https://docs.molin.ai/home/marketing/utm

Molin adds a UTM tag to every link the AI shares in chat, so you can attribute the traffic and sales it generates in your analytics.

Molin adds a UTM tag to every link that the AI shares in chat. The tag helps you track visits and sales from AI chat.

## Tag added to links

Molin adds this tag:

* `utm_source=molin.ai`

## Example

### Original URL

```text theme={null}
https://example.com/page
```

### URL shared in AI chat

```text theme={null}
https://example.com/page?utm_source=molin.ai
```

## More information

For more information about UTM tags, see the [Google Analytics documentation](https://support.google.com/analytics/answer/1033867?hl=en).


# Android integration
Source: https://docs.molin.ai/home/mobile/android-integration

Embed the Molin AI chatbot in your Android app with a WebView component, with a full working example project on GitHub.

The recommended way to integrate Molin AI in your Android app is by rendering our widget inside a `WebView` component.

See the full working example on GitHub: [molin-ai/molin-ai-android-example](https://github.com/molin-ai/molin-ai-android-example).

## Basic setup

Create an HTML file that loads the widget and displays the chat component fullscreen. Place it at `app/src/main/assets/widget.html`:

```html theme={null}
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover" />
    <style>
      * {
        margin: 0;
        padding: 0;
        box-sizing: border-box;
      }
      html,
      body {
        height: 100%;
        width: 100%;
        overflow: hidden;
        background: #fdfdfd;
      }
      molin-shop-ai-chat {
        display: block;
        width: 100%;
        height: 100%;
      }
    </style>
    <script src="https://widget.molin.ai/shop-ai.js"></script>
  </head>
  <body>
    <molin-shop-ai-chat show-close widget="YOUR_WIDGET_ID"></molin-shop-ai-chat>
  </body>
</html>
```

Replace `YOUR_WIDGET_ID` with your actual widget ID from the Molin dashboard.

The `show-close` attribute is optional. It renders a close button (✕) in the chat header, which is useful when the widget is displayed fullscreen in a webview. You can omit it if your app has its own navigation to dismiss the chat.

## Loading the WebView

Create a layout with a fullscreen `WebView` (`res/layout/activity_main.xml`):

```xml theme={null}
<?xml version="1.0" encoding="utf-8"?>
<WebView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/webView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />
```

Then load the HTML file in your activity:

```kotlin theme={null}
import android.annotation.SuppressLint
import android.os.Bundle
import android.webkit.WebView
import android.webkit.WebViewClient
import android.webkit.WebSettings
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    @SuppressLint("SetJavaScriptEnabled")
    override fun onCreate(savedInstanceState: Bundle?) {
        supportActionBar?.hide()
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val webView: WebView = findViewById(R.id.webView)

        webView.settings.javaScriptEnabled = true
        webView.settings.domStorageEnabled = true
        webView.settings.mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
        @SuppressLint("AllowUniversalAccessFromFileURLs")
        webView.settings.allowUniversalAccessFromFileURLs = true

        webView.webViewClient = WebViewClient()
        webView.loadUrl("file:///android_asset/widget.html")
    }
}
```

## Handling the close button

When the user taps the close button, the `<molin-shop-ai-chat>` element fires a `molin-shop-ai-chat:close-click` event. Navigate to a custom `molin://` URL to tell the native side to go back:

```html theme={null}
<script>
  document.addEventListener('molin-shop-ai-chat:close-click', function () {
    window.location.href = 'molin://close';
  });
</script>
```

On the Kotlin side, intercept the `molin://` scheme in a `WebViewClient`:

```kotlin theme={null}
import android.webkit.WebResourceRequest
import android.webkit.WebView
import android.webkit.WebViewClient

webView.webViewClient = object : WebViewClient() {
    override fun shouldOverrideUrlLoading(
        view: WebView?,
        request: WebResourceRequest?
    ): Boolean {
        val url = request?.url ?: return false
        if (url.scheme == "molin") {
            if (url.host == "close") {
                finish()
            }
            return true
        }
        return false
    }
}
```


# iOS integration
Source: https://docs.molin.ai/home/mobile/ios-integration

Embed the Molin AI chatbot in your iOS app with a WKWebView component, with a full working example project on GitHub.

The recommended way to integrate Molin AI in your iOS app is by rendering our widget inside a `WKWebView` component.

See the full working example on GitHub: [molin-ai/molin-ai-ios-example](https://github.com/molin-ai/molin-ai-ios-example).

## Basic setup

Create an HTML file that loads the widget and displays the chat component fullscreen:

```html theme={null}
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover" />
    <style>
      * {
        margin: 0;
        padding: 0;
        box-sizing: border-box;
      }
      html,
      body {
        height: 100%;
        width: 100%;
        overflow: hidden;
        background: #fdfdfd;
      }
      molin-shop-ai-chat {
        display: block;
        width: 100%;
        height: 100%;
      }
    </style>
    <script defer src="https://widget.molin.ai/shop-ai.js"></script>
  </head>
  <body>
    <molin-shop-ai-chat show-close widget="YOUR_WIDGET_ID"></molin-shop-ai-chat>
  </body>
</html>
```

Replace `YOUR_WIDGET_ID` with your actual widget ID from the Molin dashboard.

The `show-close` attribute is optional. It renders a close button (✕) in the chat header, which is useful when the widget is displayed fullscreen in a webview. You can omit it if your app has its own navigation to dismiss the chat.

## Handling the close button

When the user taps the close button, the `<molin-shop-ai-chat>` element fires a `molin-shop-ai-chat:close-click` event. Navigate to a custom `molin://` URL to tell the native side to go back:

```html theme={null}
<script type="module">
  document.addEventListener('molin-shop-ai-chat:close-click', () => {
    window.location.href = 'molin://close';
  });
</script>
```

On the Swift side, intercept the `molin://` scheme in a `WKNavigationDelegate`:

```swift theme={null}
import WebKit

class Coordinator: NSObject, WKNavigationDelegate {
    var onClose: () -> Void

    init(onClose: @escaping () -> Void) {
        self.onClose = onClose
    }

    func webView(
        _ webView: WKWebView,
        decidePolicyFor navigationAction: WKNavigationAction,
        decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
    ) {
        if navigationAction.request.url?.scheme == "molin" {
            if navigationAction.request.url?.host == "close" {
                DispatchQueue.main.async { self.onClose() }
            }
            decisionHandler(.cancel)
            return
        }
        decisionHandler(.allow)
    }
}

// when creating the WKWebView:
let coordinator = Coordinator(onClose: { /* navigate back */ })
webView.navigationDelegate = coordinator
```


# Mobile app integration
Source: https://docs.molin.ai/home/mobile/mobile-apps

Embed Molin in your iOS or Android app so customers get the same AI sales and support assistant inside your mobile experience.

<CardGroup>
  <Card title="iOS integration" href="/home/mobile/ios-integration">
    Complete guide for integrating Molin AI chatbot into iOS apps using WKWebView
  </Card>

  <Card title="Android integration" href="/home/mobile/android-integration">
    Step-by-step instructions for Android apps using WebView components
  </Card>
</CardGroup>


# AI sitemap scraper
Source: https://docs.molin.ai/home/platforms/ai-sitemap-scraper

No feed and no supported platform? Molin can still build your catalog by crawling your sitemap and reading your product pages.

<Tip>Learn more about [product feeds](/home/general/product-feeds) including authentication options and troubleshooting.</Tip>

If you don't use one of our supported platforms, feeds or the [product sync API](/apis/product-sync-with-schema-org), then Molin can still download your products by crawling your sitemap. This is a great way to get started with Molin if you have a custom store. Our scraper uses AI to understand and extract your product data accurately from pages.

If Molin didn't find your products correctly, then please reach out to us [here](mailto:hey@molin.ai).


# Árukereső/Compari feed
Source: https://docs.molin.ai/home/platforms/arukereso-compari-feed

Connect your existing Árukereső or Compari Merchant feed to Molin and sync your full product catalog without extra setup.

<Tip>Learn more about [product feeds](/home/general/product-feeds) including authentication options and troubleshooting.</Tip>

You can create a new AI from a Arukereso/Compari feed from [here](https://molin.ai/shop-ai/setup).


# Google Shopping feed
Source: https://docs.molin.ai/home/platforms/google-shopping-feed

Sync your products to Molin with a Google Shopping feed, also known as a Google Merchant Center feed, in XML, CSV, or TSV format.

You can create a new AI from a Google Shopping feed [here](https://molin.ai/shop-ai/setup).

<Info>This feed format is also known as **Google Merchant Center feed**. Molin supports XML, CSV, and TSV formats.</Info>

## Feed format

We encourage you to read Google's official documentation [here](https://support.google.com/merchants/answer/14987622?hl=en) on how to create a Google Shopping feed of your products.

## Examples

This is what your product items should look like:

```xml theme={null}
<?xml version="1.0"?>
<rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">
  <channel>
    <title>Example - Google Store</title>
    <link>https://store.google.com</link>
    <description>This is an example of a basic RSS 2.0 document containing a single item</description>
    <item>
      <g:id>TV_123456</g:id>
      <g:title>Google Chromecast with Google TV</g:title>
      <g:description>Chromecast with Google TV brings you the entertainment you love, in up to 4K HDR</g:description>
      <g:link>https://store.google.com/product/chromecast_google_tv</g:link>
      <g:image_link>https://images.example.com/TV_123456.png</g:image_link>
      <g:condition>new</g:condition>
      <g:availability>in stock</g:availability>
      <g:price>49.99 USD</g:price>
      <g:shipping>
        <g:country>US</g:country>
        <g:service>Standard</g:service>
        <g:price>7.99 USD</g:price>
      </g:shipping>
      <g:gtin>123456789123</g:gtin>
      <g:brand>Google</g:brand>
      <g:product_detail>
        <g:attribute_name>Material</g:attribute_name>
        <g:attribute_value>Cotton</g:attribute_value>
      </g:product_detail>
    </item>
  </channel>
</rss>
```

### Product details

To include additional product attributes beyond the standard Google Merchant fields, add `product_detail` elements inside `<item>`:

```xml theme={null}
<item>
  <!-- ... other fields ... -->
  <g:product_detail>
    <g:attribute_name>Material</g:attribute_name>
    <g:attribute_value>Cotton</g:attribute_value>
  </g:product_detail>
  <g:product_detail>
    <g:attribute_name>Care Instructions</g:attribute_name>
    <g:attribute_value>Machine washable</g:attribute_value>
  </g:product_detail>
</item>
```

## Authentication

Read our general [product feeds](/home/general/product-feeds) guidance for authentication options and troubleshooting.


# Migrating from Prefixbox
Source: https://docs.molin.ai/home/platforms/migrating-from-prefixbox

Switch from Prefixbox to Molin AI with zero code changes: we support the Prefixbox JSON feed format and its product search API.

If you are currently using Prefixbox for product search, you can migrate to Molin AI seamlessly. We support both the Prefixbox JSON feed format and the full Prefixbox Product Data API, so your existing integration works with Molin out of the box.

## What you get

* **Prefixbox feed compatibility** — connect your existing Prefixbox JSON feed directly to Molin ([details](/home/platforms/prefixbox-feed))
* **Full Prefixbox Product Data API compatibility** — push real-time product updates to Molin using the same endpoints you already use with Prefixbox, all 5 supported

## Step 1: Connect your feed

If you already have a Prefixbox JSON feed, provide the feed URL to Molin during setup. We parse the same format — no changes needed on your side. See [Prefixbox feed](/home/platforms/prefixbox-feed) for details on the supported fields.

## Step 2: Push real-time updates

If you push real-time product updates to Prefixbox (price, stock, availability changes), you can push the same updates to Molin in parallel. The only differences are the base URL, the API key, and the `websiteTracker` value.

### Connection details

|                     | Prefixbox                               | Molin AI                                        |
| ------------------- | --------------------------------------- | ----------------------------------------------- |
| **Base URL**        | `https://api.prefixbox.com/productData` | `https://molin.ai/api/v0/prefixbox/productData` |
| **Auth header**     | `API-Key: <your Prefixbox key>`         | `API-Key: <your Molin key>`                     |
| **Website tracker** | Your Prefixbox `websiteTracker`         | Your Molin widget ID                            |

<Info>Contact us at [hey@molin.ai](mailto:hey@molin.ai) to receive your API key.</Info>

### Supported endpoints

We support all Prefixbox Product Data API endpoints:

| Method | Endpoint                                | Description                       |
| ------ | --------------------------------------- | --------------------------------- |
| `POST` | `/product`                              | Update a single product           |
| `POST` | `/products`                             | Update multiple products (batch)  |
| `POST` | `/product/add`                          | Add a new product                 |
| `POST` | `/products/add`                         | Add multiple new products (batch) |
| `GET`  | `/product/{websiteTracker}/{productId}` | Get a product (for testing)       |

All endpoints use the same request/response format as Prefixbox. See the [Prefixbox API docs](https://api-docs.prefixbox.com/#product-data-api) for the full specification.

### Update a single product

```sh theme={null}
curl -X POST "https://molin.ai/api/v0/prefixbox/productData/product" \
  -H "Content-Type: application/json" \
  -H "API-Key: <your Molin API key>" \
  -d '{
    "websiteTracker": "<your widget ID>",
    "identifier": "SKU-12345",
    "productData": {
      "price": "49990",
      "oldPrice": "59990",
      "availability": "in stock"
    }
  }'
```

### Update multiple products (batch)

```sh theme={null}
curl -X POST "https://molin.ai/api/v0/prefixbox/productData/products" \
  -H "Content-Type: application/json" \
  -H "API-Key: <your Molin API key>" \
  -d '{
    "websiteTracker": "<your widget ID>",
    "products": [
      {
        "identifier": "SKU-12345",
        "productData": {
          "price": "49990",
          "oldPrice": "59990",
          "availability": "in stock"
        }
      },
      {
        "identifier": "SKU-67890",
        "productData": {
          "price": "29990",
          "availability": "out of stock"
        }
      }
    ]
  }'
```

### Add a new product

```sh theme={null}
curl -X POST "https://molin.ai/api/v0/prefixbox/productData/product/add" \
  -H "Content-Type: application/json" \
  -H "API-Key: <your Molin API key>" \
  -d '{
    "websiteTracker": "<your widget ID>",
    "identifier": "SKU-NEW-001",
    "productData": {
      "displayText": "Samsung TV 55\" OLED",
      "url": "https://shop.com/product/tv-55-oled",
      "price": "499990",
      "description": "55 inch OLED TV with 4K HDR",
      "imageUrl": "https://images.shop.com/tv-55-oled.jpg",
      "availability": "in stock"
    }
  }'
```

<Note>`displayText` and `url` are required when adding a new product.</Note>

### Add multiple new products (batch)

```sh theme={null}
curl -X POST "https://molin.ai/api/v0/prefixbox/productData/products/add" \
  -H "Content-Type: application/json" \
  -H "API-Key: <your Molin API key>" \
  -d '{
    "websiteTracker": "<your widget ID>",
    "products": [
      {
        "identifier": "SKU-NEW-001",
        "productData": {
          "displayText": "Samsung TV 55\" OLED",
          "url": "https://shop.com/product/tv-55-oled",
          "price": "499990",
          "availability": "in stock"
        }
      },
      {
        "identifier": "SKU-NEW-002",
        "productData": {
          "displayText": "LG Washing Machine 8kg",
          "url": "https://shop.com/product/lg-wm-8kg",
          "price": "249990",
          "availability": "in stock"
        }
      }
    ]
  }'
```

### Verify a product

Use `GET /product/{widgetId}/{identifier}` to confirm a product exists and check its current data:

```sh theme={null}
curl "https://molin.ai/api/v0/prefixbox/productData/product/<widget ID>/SKU-12345" \
  -H "API-Key: <your Molin API key>"
```

### Responses

All endpoints return the same response codes:

| Status | Meaning                                                                   |
| ------ | ------------------------------------------------------------------------- |
| `204`  | Success                                                                   |
| `200`  | Success with warnings or partial success — response body contains details |
| `400`  | Validation error                                                          |

A `200` response includes information about which products failed:

```json theme={null}
{
  "warnings": [],
  "productsWithErrorResult": [
    {
      "identifier": "SKU-67890",
      "status": 404,
      "errorCause": "No product was found with identifier: SKU-67890"
    }
  ]
}
```

### Supported fields in `productData`

| Field                 | Description                                            |
| --------------------- | ------------------------------------------------------ |
| `price`               | Current price                                          |
| `oldPrice`            | Original price before discount                         |
| `discount`            | Discount amount                                        |
| `discountStart`       | Discount start date                                    |
| `discountEnd`         | Discount end date                                      |
| `discountAmount`      | Discount value                                         |
| `discountDisplayMode` | How the discount is displayed                          |
| `availability`        | `in stock`, `out of stock`, `preorder`, `discontinued` |
| `visible`             | Product visibility                                     |
| `attributes`          | Custom attributes object                               |
| `availableShops`      | Available store locations                              |

## Differences from Prefixbox

* **Larger batch sizes** — Prefixbox recommends batches of 100 products. Molin supports much larger batches (1,000+ products per request) with no performance penalty.
* **`stores` field** — Prefixbox supports per-store overrides via the `stores` field. Molin currently ignores this field. Each Molin widget represents one store, so if you have multiple stores (e.g. different countries), you will receive a separate widget ID for each.

## Important notes

* Products must already exist in Molin (imported via your feed) before they can be updated via the update endpoints (`POST /product` and `POST /products`).
* The add endpoints (`POST /product/add` and `POST /products/add`) require `displayText` and `url` in `productData`.
* You can run both Prefixbox and Molin in parallel during your migration — just point your update pipeline at both endpoints.


# Prefixbox feed
Source: https://docs.molin.ai/home/platforms/prefixbox-feed

Molin natively supports the Prefixbox JSON feed format, so you can connect an existing Prefixbox product feed without converting it.

Molin natively supports the [Prefixbox JSON feed format](https://docs.prefixbox.com/json-feed-format/). If you already have a Prefixbox JSON product feed, you can connect it directly to Molin without any changes.

<Note>
  Prefixbox supports JSON, XML, and CSV feed formats. Molin currently supports the **JSON** format only. If you use XML or CSV, please [contact us](mailto:hey@molin.ai) — we can add support for your
  format.
</Note>

## Feed format

Molin accepts both the standard Prefixbox format (camelCase keys) and the PascalCase variant used by some implementations. Keys are normalized automatically.

### Example

```json theme={null}
{
  "Timestamp": "03/19/2026 12:00:00 +01:00",
  "Products": [
    {
      "Identifier": "TV_123456",
      "DisplayText": "Samsung TV 55\" OLED",
      "Url": "https://shop.com/product/tv-123456",
      "Description": "55 inch OLED TV with 4K HDR support",
      "Price": "499990",
      "OldPrice": "599990",
      "ImageUrl": "https://images.shop.com/tv-123456.jpg",
      "Availability": "in stock",
      "Category": "Electronics/TVs",
      "Brand": "Samsung",
      "Discount": "100000",
      "Rating": 4.5,
      "UnitPrice": "499990"
    }
  ]
}
```

A flat array format (without the `Products` wrapper) is also supported:

```json theme={null}
[
  {
    "identifier": "TV_123456",
    "displayText": "Samsung TV 55\" OLED",
    "url": "https://shop.com/product/tv-123456",
    "price": "499990"
  }
]
```

### Supported fields

| Field          | Required | Description                                    |
| -------------- | -------- | ---------------------------------------------- |
| `identifier`   | Yes      | Unique product identifier                      |
| `displayText`  | Yes      | Product title                                  |
| `url`          | Yes      | Product page URL                               |
| `price`        | Yes      | Current price                                  |
| `description`  | No       | Product description                            |
| `oldPrice`     | No       | Original price before discount                 |
| `imageUrl`     | No       | Product image URL                              |
| `availability` | No       | Stock status (e.g. `in stock`, `out of stock`) |
| `category`     | No       | Product category (use `/` as separator)        |
| `brand`        | No       | Product brand                                  |
| `discount`     | No       | Discount amount                                |
| `rating`       | No       | Product rating (numeric)                       |
| `unitPrice`    | No       | Price per unit                                 |
| `attributes`   | No       | Custom attributes object                       |

## Real-time product updates

In addition to the feed, Molin offers a Prefixbox-compatible Product Data API for pushing real-time updates (price changes, stock changes, etc.) without waiting for the next feed sync.

See [Migrating from Prefixbox](/home/platforms/migrating-from-prefixbox) for details on how to set this up.

## Authentication

Read our general [product feeds](/home/general/product-feeds) guidance for authentication options and troubleshooting.


# Shoper
Source: https://docs.molin.ai/home/platforms/shoper

Install Molin on your Shoper store with our official Shoper app, and get your AI sales and support assistant live in a few minutes.

You can connect Molin to your Shoper store using our official [Shoper app](https://www.shoper.pl/).

Start by creating a Molin account or just click [here](https://molin.ai/shop-ai/setup).

## Setup instructions

1. Log in to your Shoper admin panel
2. Navigate to the Apps section
3. Search for "Molin AI" and install the app
4. Follow the on-screen instructions to connect your store
5. Configure your AI assistant settings in the Molin dashboard

Once connected, Molin will automatically sync your product catalog and start assisting your customers.

## Add to cart

When Molin recommends products in the chat, product cards on a Shoper store show an add-to-cart button. Clicking it instantly adds 1 unit of the recommended product to the visitor's cart via Shoper's official Front API, without leaving the conversation.

This is enabled automatically on all Shoper stores, no configuration needed.

* The button shows a spinner while adding, then a checkmark on success or an error indicator if the item cannot be added (e.g. sold out).
* Each add to cart is tracked in your Molin analytics and pushed to Google Analytics as a standard GA4 `add_to_cart` ecommerce event.
* If your theme has a cart drawer or cart count badge, you can refresh it by listening to the [`molin:add-to-cart`](/home/marketing/javascript-events#molinadd-to-cart) JavaScript event.

## Support

If you need help with the integration, please reach out to our support team at [hey@molin.ai](mailto:hey@molin.ai).


# Shopify
Source: https://docs.molin.ai/home/platforms/shopify

Install Molin on your Shopify store with our official Shopify app, and follow the video tutorial for a step-by-step walkthrough.

Follow the video tutorial below to see a step-by-step guide on how to setup Molin for your Shopify store. Here's our official [Shopify plugin](https://apps.shopify.com/molin-ai).

<Info>Native AI actions are still under development for Shopify, please use our [Custom AI actions API](/apis/product-sync-with-schema-org) to enable Molin to execute tasks in the meantime.</Info>

<iframe title="YouTube video player" />

## Add to cart

When Molin recommends products in the chat, product cards on a Shopify store show an add-to-cart button. Clicking it instantly adds 1 unit of the recommended product variant to the visitor's cart, without leaving the conversation.

This is enabled automatically on all Shopify stores connected through our Shopify plugin, no configuration needed.

* The button shows a spinner while adding, then a checkmark on success or an error indicator if the item cannot be added (e.g. sold out).
* Each add to cart is tracked in your Molin analytics and pushed to Google Analytics as a standard GA4 `add_to_cart` ecommerce event.
* If your theme has a cart drawer or cart count badge, you can refresh it by listening to the [`molin:add-to-cart`](/home/marketing/javascript-events#molinadd-to-cart) JavaScript event.

## Do you have issues adding the Molin AI script to your Shopify store?

No problem, in this old tutorial we will show you how you can add the script manually into your store.

1. Navigate to the publish page by following this link: [https://molin.ai/app/publish](https://molin.ai/app/publish)
2. Copy your script from the publish page
3. In your Shopify Dashboard, click on Online Store --> Themes --> Customize
4. Click on the `...` in the top left corner --> Edit code --> `theme.liquid`
5. In the `theme.liquid` file, paste your Molin script inside the `<head></head>` tag.

Here's an old video on how to do this:

<iframe title="YouTube video player" />

If you need any help with our Shopify integration, then please contact us <OpenChatLink>here</OpenChatLink>.


# Shoprenter
Source: https://docs.molin.ai/home/platforms/shoprenter

Install Molin on your Shoprenter store with our official Shoprenter plugin, and follow the video tutorial for a step-by-step walkthrough.

Follow the video tutorial below to see a step-by-step guide on how to setup Molin for your Shoprenter store. Here's our official [Shoprenter plugin](https://www.shoprenter.hu/index.php?option=com_login\&redirect=appstore\&app_id=207).

<Info>This video tutorial is in Hungarian as Shoprenter only operates in Hungary.</Info>

Start by creating a Molin account or just click [here](https://molin.ai/shop-ai/setup).

<Steps>
  <Step title="How to setup Molin for your Shoprenter store - part 1.">
    <iframe title="YouTube video player" />
  </Step>

  <Step title="How to setup Molin for your Shoprenter store - part 2.">
    <iframe title="YouTube video player" />
  </Step>
</Steps>

## Add to cart

When Molin recommends products in the chat, product cards on a Shoprenter store show an add-to-cart button. Clicking it instantly adds 1 unit of the recommended product to the visitor's cart, without leaving the conversation.

This is enabled automatically on all Shoprenter stores connected through the official plugin, no configuration needed. The button only appears on products synced through the Shoprenter API, since adding to the cart requires the Shoprenter product ID.

* The button shows a spinner while adding, then a checkmark on success or an error indicator if the item cannot be added (e.g. the product requires options to be chosen on the product page).
* Each add to cart is tracked in your Molin analytics and pushed to Google Analytics as a standard GA4 `add_to_cart` ecommerce event.
* If your theme has a cart drawer or cart count badge, you can refresh it by listening to the [`molin:add-to-cart`](/home/marketing/javascript-events#molinadd-to-cart) JavaScript event.


# UNAS
Source: https://docs.molin.ai/home/platforms/unas

Install Molin on your UNAS store with our official UNAS plugin, and follow the video tutorial for a step-by-step walkthrough.

Follow the video tutorial below to see a step-by-step guide on how to setup Molin for your Shoprenter store. Here's our official [UNAS plugin](https://shop.unas.hu/admin_config_connect_chat.php?tab=molin_ai).

<Info>This video tutorial is in Hungarian as UNAS only operates in Hungary.</Info>

Start by creating a Molin account or just click [here](https://molin.ai/shop-ai/setup).

<Steps>
  <Step title="How to connect Molin to your UNAS store">
    <iframe title="YouTube video player" />
  </Step>

  <Step title="Allow Molin to read order statuses from UNAS">
    <iframe title="YouTube video player" />
  </Step>

  <Step title="Allow Molin to cancel orders">
    <iframe title="YouTube video player" />
  </Step>
</Steps>

## Add to cart

When Molin recommends products in the chat, product cards on a UNAS store show an add-to-cart button. Clicking it instantly adds 1 unit of the recommended product to the visitor's cart, without leaving the conversation.

This is enabled automatically on all UNAS stores, no configuration needed. Molin adds the product through your store's own cart script, so your mini cart updates just like when a visitor clicks a regular add-to-cart button.

* Products are matched by SKU, so make sure your product feed includes SKUs. Products without a SKU do not show the button.
* The button shows a spinner while adding, then a checkmark on success or an error indicator if the item cannot be added (e.g. the product requires a variant to be chosen on the product page).
* Each add to cart is tracked in your Molin analytics and pushed to Google Analytics as a standard GA4 `add_to_cart` ecommerce event.


# Vector Webshop feed
Source: https://docs.molin.ai/home/platforms/vector-webshop-feed

Connect a Vector Webshop shop to Molin with a feed token from your Vector admin, and keep every product variant searchable.

<Tip>Learn more about [product feeds](/home/general/product-feeds) including authentication options and troubleshooting.</Tip>

Vector Webshop shops connect with a token instead of a feed URL. Vector publishes your export at a fixed address on your own domain, so Molin builds the URL for you.

## Connect your shop

1. In your Vector Webshop admin, open the Molin AI settings and copy your feed token.
2. Go to [molin.ai/shop-ai/setup](https://molin.ai/shop-ai/setup) and pick **Vector Webshop** under Product feeds.
3. Enter your shop address and paste the token.

Molin reads your feed before it creates your assistant, so a wrong token stops setup and tells you there and then.

<Note>Vector ships the Molin export in their mid-September 2026 release. If the Molin AI settings are not in your admin yet, ask Vector when your shop is updated.</Note>

## Product variants

Vector lists each variant as its own feed item, and several variants of one product share a single product page. Molin keeps them as separate products, so a monitor sold in 14 sizes stays 14 searchable products rather than collapsing into one.

## Large catalogs

Plans cover up to 50,000 products. Wholesale portals above that, common on Vector, need a raised limit; [contact us](mailto:hey@molin.ai) before you connect one.

## Authentication

The token in your feed URL is the only authentication Vector's export needs. Read our general [product feeds](/home/general/product-feeds) guidance for the other options and for troubleshooting.


# WooCommerce
Source: https://docs.molin.ai/home/platforms/woocommerce

Add the Molin AI chatbot to your WooCommerce or WordPress store step by step, until our official WooCommerce plugin is published.

<Note>The WooCommerce plugin is currently under development. Until it's published officially, follow this guide to add your Molin's chatbot to your Woocommerce shop via a script.</Note>

In this blog, we teach you step-by-step how to add Molin to your WooCommerce or WordPress e-commerce store.

> Before you start the integration, make sure you already created your AI chatbot. If not, [click here](https://molin.ai/shop-ai/setup).

### Short video

<iframe title="Loom video player" />

### Steps

1. On your WordPress dashboard page, in the left sidebar select **Plugins** ➔ **Add New Plugin** with the button in the top left corner.

   ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/c56327a8-4f56-47ff-6c7c-659590af1000/q=75,dpr=1)

2. Search for the Insert [**Headers And Footers plugin**](https://wordpress.org/plugins/wp-headers-and-footers/), then install and Activate it. Note, the images show an older plugin , but the new one works the same way. So, don't worry if you see a different Plugin name.

   ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/52fcf544-1950-40e6-2953-5bf58621df00/q=75,dpr=1)

3. After activation, you should see it in the list of your Plugins, like this and it has to be active.

   ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/586daebf-49c1-4e6f-92fb-071e14a2f500/q=75,dpr=1)

4. In the left sidebar, go to **Settings** and Click on the **Insert Script in Headers And Footers** inside the hoover menu.

   ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/421fcfb6-5220-49ba-55b6-e183e57de800/q=75,dpr=1)

5. Copy your Script from Molin's [**Publish**](https://molin.ai/app/publish) page.

   ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/85a1038b-190d-47e8-1a0d-ee2376120b00/q=75,dpr=1)

6. Insert your script in the **Scripts in Header** textbox, then scroll down and **Save** it.

   ![](https://imagedelivery.net/JWssb2diw2B-JHR2ojV3Ow/7b197f10-2095-4117-58f6-94e182eec300/q=75,dpr=1)

7. After saving the code, reload your e-commerce store's website and you should see your Molin widget appearing in the bottom right corner.

If you encounter any problems with the integration, please contact us at **[hey@molin.ai](mailto:hey@molin.ai)**.


# AI sales & product recommendations
Source: https://docs.molin.ai/home/sales/ai-sales

The AI knows your full product catalog, so it can recommend the right items when a customer describes what they're looking for.

The AI knows your full product catalog from your product feed. When a customer asks about a product, or describes what they’re looking for, the AI can recommend matching items right inside the chat.

<Note>Product recommendations work as soon as your product feed is connected. See [Product feeds](/home/general/product-feeds).</Note>

## What the AI can do

* Recommend products based on what the customer is looking for ("Show me waterproof jackets under €100").
* Compare two products if the customer asks the difference.
* Suggest related items (for example, a memory card for a camera).
* Answer questions about price, materials, warranty, and return policy.
* Identify a product from a photo the customer attaches. See [Image search](/home/chatbot/image-search).

## Product cards

When the AI recommends a product, it shows up as a card with the product image, title, and price. The customer can click the card to open the product page on your shop.

## Make recommendations better

* **Keep your feed up to date.** Out-of-stock items, broken images, or missing prices lead to worse recommendations. See [Product feeds](/home/general/product-feeds).
* **Use Personality** to tell the AI how to recommend. For example: "If the customer mentions gifting, suggest the premium option."
* **Add FAQs** for common buying questions, like "What do you recommend for sensitive skin?". See [FAQs](/home/knowledge/faqs).
* **Use conversation starters** to get people started, like "Help me find a gift under €50". See [Conversation starters](/home/widget/conversation-starters).


# Move the chat bubble out of the way
Source: https://docs.molin.ai/home/widget/bubble-offset

Add a CSS variable to your shop when something covers the chat bubble, like an add-to-cart bar that slides in as visitors scroll.

Shops on any platform can push the chat bubble away from any screen edge with a CSS variable. Use it when something on your page covers the bubble, like an add-to-cart bar that slides in when visitors scroll, a cookie message, or a button fixed to the side of the page.

| Variable                       | Moves the bubble         |
| ------------------------------ | ------------------------ |
| `--molin-bubble-offset-bottom` | up, away from the bottom |
| `--molin-bubble-offset-left`   | in from the left         |
| `--molin-bubble-offset-right`  | in from the right        |

Use the one that matches the corner your bubble sits in, which you pick in [**Chatbot → Design**](https://molin.ai/app/design).

## Add it to your theme

Set the variable to the height of the thing you want to clear, plus a little breathing room. Nothing moves until you set it:

```css theme={null}
body {
  --molin-bubble-offset-bottom: 88px;
}
```

To move the bubble only while the bar is on screen, put the variable on the class your theme adds when the bar appears:

```css theme={null}
body.sticky-atc-visible {
  --molin-bubble-offset-bottom: 88px;
}
```

Or set it from your own code:

```js theme={null}
document.documentElement.style.setProperty('--molin-bubble-offset-bottom', '88px');
```

Set it back to `0px` and the bubble returns to its normal spot. It slides between the two, so the move is smooth.

## What else moves

The pop-up message, the "Try it out" hint, and the [floating bar](/home/widget/floating-bar) move with the bubble, so they stay out of the way too. The open chat window shifts sideways but never up, since it already reaches the bottom of the screen.

## Tips

* One value covers phones and computers. Use your own media queries if the bar is a different height on phones.


# Conversation starters
Source: https://docs.molin.ai/home/widget/conversation-starters

Beat the empty input field: show customers one-tap example questions so they know exactly what they can ask your AI.

The biggest barrier to chat engagement is the empty input field. Conversation starters solve it by showing customers exactly what they can ask. One tap and they’re in a conversation.

<Note>Find it in your dashboard under [**Chatbot → Design → Add conversation starters**](https://molin.ai/app/design).</Note>

## Examples

* "What are your most popular products?"
* "Do you offer free shipping?"
* "Help me find a gift under \$50."
* "How do returns work?"

## Best practices

* **Use 3 to 5 prompts.** More than that feels like a lot to read.
* **Think about what your customers actually want.** "Find a gift" works better than "Tell me about our company".
* **Update them for the season.** Swap in holiday or sale prompts when it makes sense.
* **Keep them short** so they fit on one line on mobile (under 50 characters).

<Tip>Use conversation starters together with the [floating bar](/home/widget/floating-bar) to help more people start a chat.</Tip>

## Override with JavaScript

You usually set conversation starters in the dashboard, but you can also override them per page load from your own code. This is handy when the right prompts depend on the page (a product page, a cart, a help center). Both methods below take precedence over the dashboard-configured starters.

Set them before the widget loads via `window.molinSettings`:

```html theme={null}
<script>
  window.molinSettings = {
    greeting: 'How can we help with this product?',
    conversationStarters: ['Is this in stock?', 'What sizes are available?', 'How do returns work?'],
  };
</script>
```

Or update them at runtime once the widget has loaded:

```javascript theme={null}
window.Molin.setConversationStarters(['Is this in stock?', 'What sizes are available?', 'How do returns work?']);
window.Molin.setGreeting('How can we help with this product?');
```

The prompts and the greeting are independent. Override just one and the other keeps its dashboard value. Call either method with no arguments to revert that part to the dashboard-configured value.

<Note>
  `window.Molin` is only available after the widget script has loaded. Set them inside a [`molin:ready`](/home/marketing/javascript-events#molinready) listener, or use the `window.molinSettings`
  approach above, which is read automatically on load.
</Note>


# Design & branding
Source: https://docs.molin.ai/home/widget/design

Match the chatbot to your brand by setting its name, accent color, profile picture, and chat bubble on the Design page.

The Design page is where you make Molin look like your shop.

<Note>Find it in your dashboard under [**Chatbot → Design**](https://molin.ai/app/design).</Note>

## What you can customize

| Section                                  | What it controls                                                                                              |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| **Change your AI's name and appearance** | The AI's name, profile picture, color, and dark mode (see [Dark mode customization](/home/general/dark-mode)) |
| **Customize bubble**                     | The floating launcher icon, color, style, and position (bottom-left or bottom-right)                          |
| **Floating bar**                         | See [Floating bar](/home/widget/floating-bar)                                                                 |
| **Add conversation starters**            | See [Conversation starters](/home/widget/conversation-starters)                                               |
| **Show pop-up**                          | A small message next to the bubble that nudges people to start a chat                                         |
| **Dynamic pop-up**                       | See [Dynamic pop-up](/home/widget/dynamic-popup)                                                              |

## Best practices

* **Use your brand color** so the chatbot fits in with the rest of your site.
* **Profile picture should be square.** SVG or PNG with a transparent background works best. Max file size is 2 MB.
* **Bubble position** is bottom-right by default. Move it to bottom-left if you already have a button there.
* **Something covering the bubble**, like an add-to-cart bar that slides in on scroll? See [Move the chat bubble out of the way](/home/widget/bubble-offset).
* **Check on mobile.** On phones the chat opens full-screen, so make sure your name and color still look right.

## Removing "Powered by Molin"

The "Powered by Molin" badge can be removed on paid plans under the [**Powered by Molin AI**](https://molin.ai/app/design) section of the Design page.

## Live preview

Every change shows up in the preview pane immediately. Nothing goes live on your site until you click **Save** in that section.


# Dynamic pop-up
Source: https://docs.molin.ai/home/widget/dynamic-popup

Let the AI write a fresh pop-up message for every visitor, based on the page they're viewing, instead of showing the same fixed line to everyone.

The regular pop-up shows one message you write yourself. The dynamic pop-up hands that job to your AI, which writes a new message for each visitor based on the page they're on and types it into the bubble live.

On a product page, that means the AI can mention the product by name instead of falling back to a generic greeting.

<Note>Enable it under [**Chatbot → Design → Dynamic pop-up**](https://molin.ai/app/design).</Note>

## Before you start

The dynamic pop-up reuses the visibility settings of the regular pop-up, so it has nothing to appear in until that one is on.

1. Turn on **Dynamic pop-up**.
2. Click **Save** in that section.

If the regular pop-up is hidden when you turn the dynamic one on, we turn it on for Mobile and Desktop in the same save and tell you so. Change it under **Show pop-up** if you only want one of them.

New chatbots have both switched on from the start.

## What visitors see

* The message arrives about three seconds after the visitor first interacts with the page, the same moment the regular pop-up would have appeared.
* The bubble stays hidden until the AI's first words arrive, then the message types itself in.
* The message is written in the visitor's browser language.
* Messages are kept short, around 150 characters, so they fit the bubble on a phone.

While the dynamic pop-up is on, it replaces the text you wrote for the regular pop-up. Your other pop-up settings, such as the mobile button label and where the bubble sits, still apply.

## What the AI knows

The AI writes the message using the same product catalog and instructions it uses in chat, so the tone matches the rest of your chatbot. On a product page it looks the product up in your catalog first so it can be specific about it.

If it can't work out which product the page is about, it writes a warm general invitation instead. Visitors never see an error, and they're never told that a lookup failed.

## When it falls back

If the AI can't answer at all, for example during an outage, the visitor gets a short generic invitation instead of an empty bubble. That fallback is translated into a number of common languages and defaults to English for the rest.

## When to use it

* **Product-heavy shops**: a pop-up that names the product beats a generic greeting.
* **Large or fast-changing catalogs**: you would never write a pop-up line per product by hand.
* **Multilingual shops**: one toggle covers every language you sell in, with no translations to maintain.

Stick with the regular pop-up when you need to say something exact, such as announcing a sale or a delivery cut-off. A fixed message is the right tool when the wording matters more than the relevance.


# Floating bar
Source: https://docs.molin.ai/home/widget/floating-bar

Embed an always-visible, search-style input in your hero, product page, or navbar, so customers can ask anything from anywhere.

The floating bar is an inline input that sits anywhere on your page: homepage hero, product page, or navbar. Customers type their question right there and the answer opens in the chat.

<Note>Enable it under [**Chatbot → Design → Floating bar**](https://molin.ai/app/design).</Note>

## When to use it

* **Homepage**: give visitors a way to ask anything without clicking the chat bubble.
* **Product pages**: let customers ask product-specific questions inline.
* **Help center**: turn it into your search bar.

## Customization

* Custom **placeholder** ("Ask anything about our shoes…").
* **Dark mode** support to match your site theme.


# Voice conversations
Source: https://docs.molin.ai/home/widget/voice

Shoppers can talk to your assistant out loud from the widget. Here is how microphone selection works and what to check if a call cannot hear the shopper.

Shoppers on desktop and mobile web can tap the microphone in the chat widget to speak to your assistant instead of typing. The assistant replies out loud in real time, and the conversation continues in chat afterward.

While voice mode is on, the assistant greets each shopper with a small bubble above the chat input saying it can talk too, in the language your widget speaks. It fades out on its own after 15 seconds and comes back on the next page the shopper opens. Once the shopper closes it or taps the voice button, it stays away for good. Turn voice mode off and the bubble never appears.

## Microphone selection

The widget asks the browser for whatever it considers the default microphone, the same approach every voice product uses. Most of the time this is correct.

On a shopper's work laptop, a conferencing app like Microsoft Teams or Zoom can install its own virtual audio device and quietly become the operating system's default microphone, even while the app is closed. Left alone, this makes the browser capture silence from the virtual device instead of the shopper's real microphone.

The widget checks for this: if the default microphone's name matches a known conferencing app (Teams, Zoom, and similar), it automatically switches to a real microphone on the same device when one is available.

## If a shopper still cannot be heard

* ask them to check their operating system's sound settings and confirm a real microphone, not a conferencing app's virtual device, is selected as the default input
* ask them to close any open conferencing app and reload the page
* confirm the site is loaded over HTTPS, browsers refuse microphone access on plain HTTP


# Affiliate Terms & Conditions
Source: https://docs.molin.ai/legal/affiliate-terms

The terms and conditions governing the Molin AI affiliate program, including commissions, payouts, and promotional rules for partners.

*Last updated: 02.06.2024*

BY SIGNING UP WITH THE MOLIN’S (“[https://molin.ai”](https://molin.ai”), “Molin”, “Molin AI”, “we”, “us”, and “our”) AFFILIATE PROGRAM (“Program”), YOU AGREE TO BE BOUND BY THESE TERMS AND CONDITIONS (“Agreement”). YOU HEREBY ACKNOWLEDGE THAT YOU HAVE READ AND UNDERSTOOD ALL CLAUSES OF THIS AGREEMENT AND AGREE TO BE BOUND BY ALL TERMS AND CONDITIONS HEREIN. This Agreement constitutes the entire contract between the parties in relation to its subject matter.

YOU (“You”, “Affiliate”, “Referrer”, or “Sender”) AGREE THAT THIS AGREEMENT IS AS ENFORCEABLE AS ANY WRITTEN NEGOTIATED AGREEMENT SIGNED BY YOU, AND IS ENFORCEABLE AGAINST YOU.

## **Introduction**

**1.** Molin's (“Molin”, “we”, “us” or “our”) Affiliate program (“ Affiliate Program”) is valid from the date mentioned above for a period of twelve (12) calendar months, which we may choose to extend at our full discretion. By taking any actions under the Affiliate Program, you (the Sender or Recipient as defined below) 0 to be bound by these Terms & Conditions (“Affiliate Terms & Conditions”). These terms are governed by English law.

**2.** Within the Molin Affiliate Program, rewards will be granted to both the Sender and the Recipient (as defined herein) who have successfully executed an Affiliate in alignment with the stipulated Affiliate Terms & Conditions of Molin.

**3.** We reserve the right, at our sole discretion, to update these Affiliate Terms & Conditions at any time. If we make an update, we will post the updated version of the Affiliate Terms & Conditions on our website [here](https://molin.ai/help/ha/affiliate-terms-conditions) (***website affiliate terms and conditions link***) and provide you notice of the update. Continued participation in the Affiliate Program after any update shall mean that you have agreed to the update(s) made by Molin.

**4.** The Affiliate Terms & Conditions are in addition to Molin's Terms and Conditions (as may be updated from time to time) which can be found [here](https://molin.ai/terms-privacy) (as long as this is not to your detriment). In the event of any conflict between the Affiliate Terms & Conditions and Molin's Terms and Conditions, these Affiliate Terms & Conditions apply.

**5.** Molin may end these Affiliate Terms & Conditions at any time or may decide to not renew the Affiliate Terms & Conditions at the end of a validity period by giving you written notice.

## **Sender's Terms**

**6.** This section of the Affiliate Terms & Conditions apply to existing users (the “Sender”) who refer Recipients (as defined below) to receive a reward. We will consider that a Sender has referred a Recipient to us if: (a) they share the Affiliate link provided by us through Rewardful.com (“Affiliate Link”) with the Recipient; and (b) the Recipient uses the Affiliate Link to successfully register and subscribe for a Molin plan, thereby completing a “Affiliate”

**7.** Affiliate to an existing or previous Molin customer will not qualify for a reward.

**8.** Sender is required to accept and comply with Rewardful.com's Terms and Conditions, in addition to those set forth herein. Failure to accept Rewardful.com's terms will result in ineligibility to participate in the Affiliate Program.

**9.** All commission payments to Senders will be handled directly by Rewardful.com. Participants must register with Rewardful.com and provide accurate payment information to receive their commissions. Molin is not responsible for managing commission payments or resolving payment disputes. All inquiries regarding commission payments should be directed to Rewardful.com's support services.

**10.** Sender(s) found to be engaging in fraudulent activities, including but not limited to self-Affiliates and the creation of multiple accounts, will be immediately removed from the Affiliate Program, and all pending commissions will be forfeited.

**11.** Sender is strictly prohibited from creating or initiating Pay-Per-Click (PPC) advertisements that utilise the Molin brand name, any Molin product names, or any variations or misspellings thereof. This prohibition extends to all PPC platforms, including, but not limited to, Google Ads, Bing Ads, and Facebook Ads. The creation of such PPC ads is considered a violation of these Terms and Conditions and may result in immediate disqualification from the Affiliate Program, forfeiture of any accrued commissions, and potential legal action.

**12.** You may not misrepresent your relationship with Molin or imply any affiliation or endorsement by Molin without express permission.

**13.** The Sender must comply with: (i) the Affiliate Terms & Conditions; and (ii) the terms and policies of any website or application where an Affiliate Link is shared. Affiliate Links may only be used in connection with the Sender’s participation in the Affiliate Program and for no other purpose whatsoever.

**14.** Subject always to conditions 6, 7, and 13, we will only award the Sender if the Recipient has successfully:

(a) Created an account using the unique Affiliate link provided;

(b) Initiated a monthly or annual subscription with Molin;

(c) For monthly subscriptions, completed payment for the first three months of the subscription. For annual subscriptions, completed payment for the annual plan.

**15.** Molin reserves the right to alter the conditions for awarding rewards at any time, without the need to provide prior notice.

**16.** Molin reserves the right to limit the number of customers who can be invited under the Affiliate program.

**17.** The Recipient must complete the required steps in his or her Molin account in accordance with condition 14.

**18.** If the Recipient terminates their account before a reward is distributed by Molin, neither the Sender nor the Recipient will qualify for a reward in accordance with these Affiliate Terms & Conditions. In the case of a monthly subscription, if the Recipient cancels their subscription before the due date of the third monthly payment, the Affiliate reward will not be granted.

**19.** Rewards issued under these Affiliate Terms & Conditions will be valued between $0 USD and $189 USD at the time of the award.

**20.** Payments are processed on the 1st of every month through PayPal or bank transfer, with a minimum payout amount of \$20 USD. However, these transactions are facilitated via Rewardful.com

**21.** Upon the successful processing and receipt of the payout by the Sender, it is important to note that the Recipient's eligibility for requesting a refund for their subscription or any associated services will be forfeited. 

**22.** The Sender acknowledges that employees and contractors of Molin are not eligible to be awarded in connection with our Affiliate Program.

**23.** For the avoidance of doubt, a will be awarded to Recipient(s) who are eligible and accepted as a customer by Molin. We reserve the right to refuse to onboard any prospective Recipients.

**24.** The Sender acknowledges that it may be subject to tax implications upon receiving a . Under no circumstances shall Molin be held liable or responsible for any such tax implications.

**25.** We reserve the right to modify, pause, suspend or end: (i) the Affiliate Program, in whole or in part; and (ii) both the Sender and the Recipient’s ability to either participate in the Affiliate Program, at any time without cause, including for any suspected activity we deem to be abusive, fraudulent, or in violation of these Affiliate Terms & Conditions. In the event that you do not agree with a decision that we make regarding your participation in the Affiliate Program under this condition 25, you can make a complaint to our Customer Service team at [hey@molin.ai](mailto:hey@molin.ai), where your complaint will be handled in accordance with our complaints order handling procedure.

**26.** In the event that we deem an Affiliate to be in material breach of these Affiliate Terms & Conditions, neither the Sender nor the Recipient will be eligible for an award. In the event of such a violation, we reserve the right to retract, cancel, or take any legally permissible actions concerning any rewards or benefits accrued in the accounts of either the Sender or Recipient that are linked to the said breach. This measure is taken to uphold the integrity of our Affiliate Program and enforce compliance with its terms.

**27**. Subscriptions made through third-party platforms, including but not limited to Shopify, do not qualify for Affiliate rewards under the Molin Affiliate program.

## **Recipient's Terms & Conditions**

**28.** This section of the Affiliate Terms & Conditions apply to the new customer (the “Recipient”) who has used an Affiliate Link to sign up as a Molin customer.

**29.** Customers acquired through this Program will be deemed Molin customers, subject to our policies and procedures.

**30.** In accordance with and subject to these Affiliate Terms & Conditions, we will award a reward to the Recipient in the event that they use an Affiliate Link to sign up as a customer of Molin.

**31.** The Recipient must comply with: (i) the Affiliate Terms & Conditions; and (ii) the terms and policies of any website or application where an Affiliate Link is posted. Affiliate Links may only be used in connection with the Recipient’s participation in the Affiliate Program and for no other purpose whatsoever.

**32.** Subject always to conditions 6, 7, and 13, we will only award the Recipient if the Recipient has successfully:

(a) Used the Affiliate Link to become a customer of Molin;

(b) Passed all of our onboarding checks;

(c) Started a subscription plan with Molin following the use of the Affiliate Link; and

(d) Successfully made their first payment after the completion of any applicable free trial period.

**33.** Molin reserves the right to either increase or decrease the discount amount and to modify the criteria for awarding discounts at any moment, without the need for prior notification.

**34.** A discount cannot be claimed by an existing or previous Molin customer under these Affiliate Terms & Conditions.

**35.** If a customer cancels their subscription and later decides to resume it, the previously applied discount will no longer be available.

**36.** The Recipient must understand that the Affiliate reward is exclusive and cannot be combined with or applied alongside any other promotional discounts or offers provided by Molin.

**37.** The Sender must be an existing user of Molin at the time of making an Affiliate in order for the Recipient to be eligible for a under the Affiliate Program.

**38.** The Recipient must complete the required steps in his or her Molin account in accordance with condition 32.

**39.** If the Recipient terminates their account before Molin awards the reward, both the Sender and the Recipient will be ineligible for a reward in accordance with these Affiliate Terms & Conditions.

**40.** Rewards granted under these Affiliate Terms & Conditions will offer a discount ranging between 0-10% on subscription plans, with the discount amount potentially varying between monthly and annual subscriptions.

**41.** We reserve the right to adjust the discount percentage and time length at any time.

**42.** The Recipient is required to use Stripe for payment processing and must apply their generated promo code at the payment page to receive the discount. Failure to utilise the promo code during payment will result in the loss of the discount, and the Affiliate process will not proceed further.

**43.** After signing up through the unique Affiliate link, if the Recipient does not receive a promo code, must email [hey@molin.ai](mailto:hey@molin.ai). For the avoidance of doubt, under no circumstances shall the Recipient be entitled to any form of compensation for our failure to award.

**44.** The Recipient acknowledges that employees and contractors of Molin are not eligible to be awarded in connection with our Affiliate Program.

**45.** For the avoidance of doubt, discounts will be awarded to Recipient(s) who are eligible and accepted as a customer by Molin. We reserve the right to refuse to onboard prospective Recipients who fail to meet the eligibility criteria outlined in these Affiliate Terms & Conditions at any given time.

**46.** The Recipient acknowledges that it may be subject to tax implications upon receiving a . Under no circumstances shall Molin be held liable or responsible for any such tax implications.

**47.** We reserve the right to modify, pause, suspend or end: (i) the Affiliate Program, in whole or in part; and (ii) both the Sender and the Recipient’s ability to either participate in the  Affiliate Program, at any time without cause, including for any suspected activity we deem to be abusive, fraudulent, or in violation of these terms and conditions.

**48.** In the event that we deem an Affiliate to be in material breach of these Affiliate Terms & Conditions, neither the Sender nor the Recipient will be eligible for an award. In the event of such a violation, we reserve the right to retract, cancel, or take any legally permissible actions concerning any rewards or benefits accrued in the accounts of either the Sender or Recipient that are linked to the said breach. This measure is taken to uphold the integrity of our Affiliate Program and enforce compliance with its terms.

**49.** Subscriptions made through third-party platforms, including but not limited to Shopify, do not qualify for Affiliate rewards under the Molin Affiliate program.


# Behaviour Policy
Source: https://docs.molin.ai/legal/behaviour-policy

How Molin AI customer support treats customers, what we expect in return, and how we handle abusive or unacceptable behaviour.

*Last updated: 26.08.2024*

Molin customer support strives to resolve issues as swiftly as possible. Every member of our team will earnestly try to help with any inquiry. Our customers have a right to be heard, understood, and respected. However, there are situations that can make it difficult for our support team to resolve some requests. In some cases, when an individual becomes threatening or abusive to our staff, we must draw the line.

We understand dealing with issues can be stressful, and we want to hear our customers' concerns. Nevertheless, if that frustration becomes aggressive, threatening, or disparaging towards our staff, we consider that behaviour unacceptable and may refuse to provide additional service. All threats of violence are reported to authorities and Molin reserves the right to close the account of any customer making such threats. Everyone has a right to feel safe at work, and that is no different for Molin.

Molin chooses to protect our staff and say no to abusive behaviour. We strive to offer the best support in the industry, but when a customer mistreats our staff with abusive or threatening language, we reserve the right to end the business relationship with that customer.

Thank you for understanding our need to create a respectful and safe workplace. We are happy to help our customers use Molin, but the right to that support comes with an expectation of thoughtful, considerate behaviour and communication. Please feel free to contact us for more information or clarification on this policy.


# Cookie Information
Source: https://docs.molin.ai/legal/cookie-list

A detailed list of the cookies and local storage that Molin AI uses, what each one stores, and how long each is kept.

Molin AI uses cookies and local storage to provide and improve our AI-powered customer service assistant.

## Data storage mechanisms

We use the following browser data storage mechanisms:

| Mechanism    | Description                                                                                              |
| ------------ | -------------------------------------------------------------------------------------------------------- |
| Cookies      | Small text files stored by your browser that remember information about your visit and preferences       |
| localStorage | Browser storage that persists data locally on your device across browser sessions until manually cleared |

## Modules

Molin AI is a growing platform with different websites and products:

| Module          | Website address                              | Description                                                              |
| --------------- | -------------------------------------------- | ------------------------------------------------------------------------ |
| Landing page    | [https://molin.ai/](https://molin.ai/)       | Our main website where visitors learn about our service and sign up      |
| Dashboard       | [https://molin.ai/app](https://molin.ai/app) | The merchant portal where our customers manage their AI chatbot settings |
| Embedded widget | Customer's website                           | The AI chatbot widget that appears on our customers' e-commerce websites |

## Purposes

Reasons for storing data:

| Purpose name       | Description                                                                     |
| ------------------ | ------------------------------------------------------------------------------- |
| Core functionality | To enable essential features such as user authentication and session management |
| Analytics          | To understand how users interact with our website and improve user experience   |
| Referrals          | To track referral sources and manage affiliate/referral programs                |
| Advertising        | To measure which adverts bring people to Molin                                  |

## Tools

Tools used on our website and their associated purposes:

| Tool name             | Vendor              | Privacy policy                                                                      | Module                  | Purpose            |
| --------------------- | ------------------- | ----------------------------------------------------------------------------------- | ----------------------- | ------------------ |
| Tag Management        | Cloudflare, Inc     | [Privacy policy](https://www.cloudflare.com/trust-hub/privacy-and-data-protection/) | Landing page, Dashboard | Core functionality |
| Cloudflare Monitoring | Cloudflare, Inc     | [Privacy policy](https://www.cloudflare.com/trust-hub/privacy-and-data-protection/) | Landing page, Dashboard | Core functionality |
| Google Analytics      | Google LLC          | [Privacy policy](https://policies.google.com/privacy)                               | Landing page, Dashboard | Analytics          |
| PostHog               | PostHog, Inc        | [Privacy policy](https://posthog.com/privacy)                                       | Landing page, Dashboard | Analytics          |
| Rewardful             | Rewardful, Inc      | [Privacy policy](https://www.rewardful.com/privacy)                                 | Landing page, Dashboard | Referrals          |
| Google Ads            | Google LLC          | [Privacy policy](https://policies.google.com/privacy)                               | Landing page            | Advertising        |
| Meta Pixel            | Meta Platforms, Inc | [Privacy policy](https://www.facebook.com/privacy/policy/)                          | Landing page            | Advertising        |

## Data stored

| Item name                          | Storage location    | Expiration time | Tool                                | Module                  | Purpose            | Description                                                               |
| ---------------------------------- | ------------------- | --------------- | ----------------------------------- | ----------------------- | ------------------ | ------------------------------------------------------------------------- |
| `molin_stytch_session_token`       | Cookie              | 1 month         | Molin AI<br />(first party)         | Dashboard               | Core functionality | Secure authentication session token for logged-in merchants               |
| `molin_invited_by`                 | Cookie              | 1 month         | Molin AI<br />(first party)         | Landing page            | Referrals          | Tracks referral sources and invitation codes for analytics                |
| `molin-shop-ai-widget-open`        | localStorage        | Persistent      | Molin AI<br />(first party)         | Embedded widget         | Core functionality | Remembers whether the chat widget was open or closed between page visits  |
| `molin_shop_assistant_distinct_id` | localStorage        | Persistent      | Molin AI<br />(first party)         | Embedded widget         | Analytics          | Unique ID for analytics and end user behavior tracking across visits      |
| `cf_consent`                       | Cookie              | 1 year          | Tag Management<br />(third party)   | Landing page, Dashboard | Core functionality | Stores user consent preferences for Cloudflare Tag Management             |
| `_ga`                              | Cookie              | 2 years         | Google Analytics<br />(third party) | Landing page, Dashboard | Analytics          | Google Analytics tracking cookie for website analytics                    |
| `_ga_*`                            | Cookie              | 2 years         | Google Analytics<br />(third party) | Landing page, Dashboard | Analytics          | Google Analytics 4 property-specific tracking cookie                      |
| `ph_*_posthog`                     | Cookie+localStorage | 1 year          | PostHog<br />(third party)          | Landing page, Dashboard | Analytics          | PostHog analytics containing user distinct ID and session tracking data   |
| `rewardful_referral`               | Cookie              | 30 days         | Rewardful<br />(third party)        | Landing page, Dashboard | Referrals          | Rewardful affiliate tracking cookie                                       |
| `molin_aid`                        | Cookie              | 90 days         | Molin AI<br />(first party)         | Landing page            | Advertising        | Anonymous visitor ID used to credit a signup to the advert that led to it |
| `molin_touch`                      | Cookie              | 90 days         | Molin AI<br />(first party)         | Landing page            | Advertising        | Which advert or campaign brought this visitor to the site                 |
| `_fbp`                             | Cookie              | 90 days         | Meta Pixel<br />(third party)       | Landing page            | Advertising        | Meta browser ID used to measure advert performance                        |

## Opting out of advertising

Everyone can choose which purposes to allow through the cookie banner. Advertising is a separate choice, so you can allow analytics while refusing advertising.

If your browser sends a [Global Privacy Control](https://globalprivacycontrol.org/) signal, we treat it as refusing advertising and set no advertising cookies, whichever country you are in. You do not need to use the banner as well.


# Data Processing Addendum (DPA)
Source: https://docs.molin.ai/legal/data-processing-addendum

The data processing terms that govern Molin AI services, covering roles, security measures, subprocessors, and your rights as a controller.

*Last updated: 28.12.2025*

**Preamble & Incorporation**

This Data Processing Addendum, including its annexes and the Standard Contractual Clauses ("DPA"), is made by and between Molin AI (“Molin AI”), and Customer, pursuant to the Subscription Agreement, the Molin AI Terms of Service or other written or electronic agreement between the parties, as applicable (collectively referred to as the "Agreement").

This DPA is incorporated into the Agreement and governs Molin AI’s processing of Customer Personal Data under Applicable Data Protection Legislation. The purpose of this DPA is to ensure that the processing of Personal Data is undertaken in full compliance with all applicable laws, regulations, and with appropriate regard for the rights and freedoms of data subjects whose Personal Data is processed.

**1. Definitions**

Any capitalized term used but not defined in this DPA has the meaning provided to it in the Agreement.

"Account Data" means Personal Data that relates to Customer’s relationship with Molin AI, including to access Customer’s account and billing information, identity verification, maintain or improve performance of the Services, provide support, investigate and prevent system abuse, or fulfill legal obligations.

"Affiliate" means any entity that controls, is controlled by, or is under common control with a party, where “control” means ownership of or the right to control 50% or more of the voting securities or equivalent ownership interest.

“Aggregated Data” means information that relates to a group or category of data and from which individual identities and characteristics have been removed.

“Applicable Data Protection Legislation” means all laws and regulations governing the Processing of Personal Data that apply to the parties, including Regulation (EU) 2016/679 (GDPR); in respect of the UK, the GDPR as saved into United Kingdom law by virtue of section 3 of the United Kingdom's European Union (Withdrawal) Act 2019 ("UK GDPR") and the Data Protection Act 2018 (together, "UK Data Protection Laws"; the Swiss Federal Act on Data Protection (FADP); U.S. federal and state privacy laws (including the California Consumer Privacy Act (CCPA) as amended by the CPRA, and analogous state privacy laws in force from time to time); and the Australian Privacy Act 1988 (Cth) and the Australian Privacy Principles (APPs); in each case, as amended, replaced or superseded from time to time.

"CCPA" or "CCPA and CPRA" means the California Consumer Privacy Act of 2018 and any binding regulations promulgated thereunder, in each case, as may be amended from time to time. This includes but it is not limited to the California Privacy Rights Act of 2020.

"Controller" or "controller" means the natural or legal person, public authority, agency, or other body which, alone or jointly with others, determines the purposes and means of the processing of Personal Data. It shall have the same meaning ascribed to “controller” under the GDPR and other equivalent terms under Applicable Data Protection Legislation (e.g., ”Business” as defined under the CCPA), as applicable.

"Customer Data" means any data, content or other information of any type that is submitted to the Services by or on behalf of Customer, including without limitation: (a) data, content or other information submitted, uploaded, instructed to be used for or imported to the Services by Customer (including from Third Party Platforms) and (b) data, content or other information provided by or about People (including chat and message logs) that are collected from the Customer Properties using the Services.

“Customer Personal Data” means Personal Data contained within Customer Data that Molin AI processes as a Processor on behalf of Customer.

“Data Privacy Framework” or “DPF” means, as applicable, the EU-U.S. Data Privacy Framework, the UK Extension to the EU-U.S. Data Privacy Framework, and/or the Swiss-U.S. Data Privacy Framework.

“Anonymized Data” means data that has been processed to remove personal identifiers and cannot reasonably be used to identify an individual, whether directly or indirectly, in compliance with Applicable Data Protection Legislation.

"Europe" means for the purposes of this DPA the European Economic Area ("EEA"), the United Kingdom ("UK") and Switzerland, or another country which ensures an adequate level of protection for the rights and freedoms of data subjects in relation to the processing of Personal Data, as determined by the European Commission in the case that EU Data Protection Law applies (e.g. Andorra, Faroe Islands, Guernsey, Isle of Man, Jersey) respectively as determined by the ICO in the case that UK Data Protection Law applies.

"GDPR" means Regulation (EU) 2016/679 of the European Parliament and of the Council of 27 April 2016 on the protection of natural persons with regard to the processing of personal data and on the free movement of such data, and repealing Directive 95/46/EC (General Data Protection Regulation).

"Personal Data" or "personal data" or "personal information" means any information relating to an identified or identifiable natural person (“data subject”) an identifiable natural person is one who can be identified, directly or indirectly, in particular by reference to an identifier such as a name, an identification number, location data, an online identifier or to one or more factors specific to the physical, physiological, genetic, mental, economic, cultural or social identity of that natural person or as defined in and subject to Applicable Data Protection Legislation.

“Privacy Policy” means Molin AI’s publicly available privacy policy describing how Molin AI processes personal data. For clarity, the Privacy Policy is not part of this DPA and does not govern Molin AI’s processing of Customer Personal Data as Processor under this DPA.

"Processing" or "processing" (and "Process" or "process") means any operation or set of operations performed upon Personal Data, whether or not by automated means, such as collection, recording, organization, structuring, storage, adaptation or alteration, retrieval, consultation, use, disclosure by transmission, dissemination or otherwise making available, alignment or combination, restriction, erasure or destruction.

"Restricted Transfer" means: (i) where the GDPR applies, a transfer of personal data from the EEA to a country outside of the EEA which is not subject to an adequacy decision by the European Commission; (ii) where the UK GDPR applies, a transfer of personal data from the UK to any other country which is not based on adequacy regulations pursuant to UK Data Protection Laws; and (iii) where the Swiss FADP applies, a transfer of personal data to a country outside of Switzerland which is not included on the list of adequate jurisdictions.

"Security Breach" means a breach of security leading to any accidental, unauthorized or unlawful loss, disclosure, destruction, alteration, unauthorized disclosure of, or access to Customer Personal Data transmitted, stored or otherwise processed by Molin AI. For clarity, unsuccessful events that do not compromise Customer Personal Data (e.g., pings, port scans, unsuccessful log-on attempts, or denial-of-service attacks without data access) are not Security Breaches.

"Standard Contractual Clauses" or "SCCs" means, as applicable: (i) the standard contractual clauses annexed to Commission Implementing Decision (EU) 2021/914 of 4 June 2021 for transfers of personal data to third countries under the GDPR (“EU SCCs”); (ii) the International Data Transfer Addendum issued by the UK Information Commissioner (“UK Addendum”), which amends the EU SCCs for transfers subject to the UK GDPR (“UK SCCs”); and (iii) any Swiss-specific adaptations recognized by the Swiss Federal Data Protection and Information Commissioner for transfers subject to the FADP; in each case, as updated, amended or superseded from time to time.

"Sub-processor" or "sub-processor" means any third party (excluding Molin AI’s employees and individual contractors) engaged by Molin AI to process Customer Personal Data on behalf of Molin AI in connection with the Services.

“Sub-processor Page” means Molin AI’s web page listing current Sub-processors for the Services ([https://docs.molin.ai/legal/subprocessors](https://docs.molin.ai/legal/subprocessors)), as updated from time to time.

“Technical and Organizational Measures” or “TOMs” means the security measures described in Schedule 2 (Technical and Organizational Measures), as updated from time to time without material degradation of overall protection.

"Third Party Request" means any request, correspondence, inquiry, or complaint from a data subject, regulatory authority, or third party.

"UK Addendum" means the International Data Transfer Addendum to the EU Standard Contractual Clauses issued by the Information Commissioner's Office. This is found in Schedule 4 below.

**2. Applicability and Scope**

2.1. Applicability. This DPA applies to Molin AI’s processing, on Customer’s behalf, of Personal Data subject to Applicable Data Protection Legislation.

2.2. Duration. This DPA remains in force for the Agreement term and until return/deletion of Customer Personal Data as per this DPA.

2.3. Molin AI as a Processor. To the extent Molin AI processes Customer Personal Data on behalf of Customer in connection with the Services, Molin AI acts as Processor and Customer acts as Controller. If Customer processes such personal data on behalf of a third-party controller, Customer warrants that it is authorized by such controller to appoint Molin AI as sub-processor and to issue all instructions to Molin AI on the controller’s behalf.

Molin AI will process Customer Personal Data solely in accordance with Customer’s documented instructions, as set out in this DPA, and any other instructions that are lawful and mutually agreed in writing.

2.iv. Molin AI as a Controller of Account Data. With respect to Account Data - including administrative, billing, authentication, security, and audit-log information relating to Customer’s users - Customer acts as Controller of the personal data it provides to Molin AI, and Molin AI acts as an independent Controller for its own subsequent processing of that data. The parties acknowledge that such processing is separate from Molin AI’s role as Processor of Customer Personal Data, and that the parties do not act as joint controllers for any processing under this DPA.

Molin AI processes Account Data as a controller (a) in order to manage the relationship with Customer; (b) carry out Molin AI’s business operations; (c) in order to detect, prevent, or investigate abuse or misuse of the Services; (d) identity verification; (e) to comply with Molin AI’s legal or regulatory obligations; and (f) as otherwise permitted under Applicable Data Protection Legislation and in accordance with this DPA, the Agreement, and the Privacy Policy. Processing activities Molin performs as an independent Controller—including Account Data, analytics, security operations, and Molin Account data—are governed by the Privacy Policy.

For clarity, Molin Account data is not Account Data and neither Customer Personal Data and is excluded from Processor obligations under this DPA.

**3. Molin AI as a Processor – Processing Customer Personal Data**

The Customer, in connection with its use of the Services, retains sole responsibility for determining what data – including Customer Personal Data – is collected from its end users and for deciding how any information processed through the Services is utilized.

Customer Instructions. Customer appoints Molin AI as a processor to process Customer Personal Data on behalf of, and in accordance with (a) Customer’s instructions as set forth in the Agreement, this DPA, and as otherwise necessary to provide the Services to Customer (including security/abuse prevention); (b) as required by law, including Applicable Data Protection Legislation, in such a case, Molin AI shall inform Customer of that legal requirement before processing, unless the law prohibits such notification on important grounds of public interest; and (c) as otherwise agreed in writing (collectively, the “Permitted Purposes”).

Customer will ensure that its instructions comply with Applicable Data Protection Legislation. Customer acknowledges that Molin AI is neither responsible for determining which laws are applicable to Customer’s business nor whether Molin AI’s Services meet or will meet the requirements of such laws. Customer will ensure that Molin AI’s processing of Customer Personal Data, when done in accordance with Customer’s instructions, will not cause Molin AI to violate any applicable law, including Applicable Data Protection Legislation.

**4. Purpose Limitation**

Molin AI processes Customer Personal Data in order to provide the Services and in accordance with the Agreement. Schedule 1 (Details of Processing) of this DPA further specifies the nature and purpose of the processing, the processing activities, the duration of the processing, the types of Personal Data and categories of data subjects.

**5. Compliance**

Customer shall be responsible for ensuring that: a) all such notices have been given, and all such authorizations have been obtained, as required under Applicable Data Protection Legislation, for Molin AI to process Customer Personal Data as contemplated by the Agreement and this DPA; b) it has complied, and will continue to comply, with all applicable laws relating to privacy and data protection, including Applicable Data Protection Legislation; and c) it has, and will continue to have, the right to transfer, or provide access to, Customer Personal Data to Molin AI for processing in accordance with the terms of the Agreement and this DPA.

**6. Confidentiality**

6.1. Confidentiality Obligations of Molin AI Personnel.

Molin AI will ensure that any person that it authorizes to process Customer Personal Data (including its employees, agents, and subcontractors) shall be subject to a duty of confidentiality (whether in accordance with Molin AI's confidentiality obligations in the Agreement or a statutory duty). Molin AI shall ensure that access to Customer Personal Data is limited to personnel who require such access for the performance of the Agreement or to comply with Applicable Data Protection Legislation.

6.2. Responding to Third Party Requests.

If Molin AI receives a request from a data subject relating to Customer Personal Data, Molin AI shall promptly notify Customer and shall not respond to the request except on Customer’s documented instructions or as required by Applicable Data Protection Legislation. Molin AI shall provide reasonable assistance to Customer, at Customer’s cost, to enable Customer to respond to such requests in accordance with Applicable Data Protection Legislation.

Molin AI shall promptly notify Customer of any legally binding request from a public authority (including supervisory authorities, law-enforcement bodies, or courts) for disclosure of Customer Personal Data, to the extent permitted by Applicable Data Protection Legislation. Molin AI shall not disclose Customer Personal Data in response to such a request unless required to do so by Applicable Data Protection Legislation. Where permitted and practicable, Molin AI shall provide reasonable assistance to Customer in responding to or limiting the scope of the request.

Molin AI shall ensure that its agreements with Sub-processors impose materially equivalent obligations. Molin AI shall notify Customer of any such requests received by a Sub-processor to the extent Molin AI is informed by the Sub-processor and permitted by law.

**7. Sub-processors**

7.1. Authorization for Sub-processing. Customer agrees that (a) Molin AI may engage sub-processors as listed at the Sub-processor Page (which may be updated from time to time) and Sub- processors respectively may engage third party processors to process Customer Personal Data on Molin AI's behalf. Customer provides a general authorization for Molin AI to engage onward sub-processors that is conditioned on the following requirements: (a) Molin AI will restrict the onward sub-processor’s access to Customer Personal Data only to what is necessary and proportionate to provide the Services and in accordance with the Agreement. (b) Molin AI agrees to impose contractual data protection obligations, including appropriate technical and organizational measures to protect personal data, on any sub-processor it appoints that required by Applicable Data Protection Legislation; and (c) Molin AI remains responsible for the performance of each Sub-processor’s obligations and will be liable to the same extent Molin AI would be liable if performing the Services directly.

7.2. Current Sub-processors and Notification of Sub-processor Additions.

a. Customer understands that effective operation of the Services may require the transfer of Customer Personal Data to Molin AI's Sub-processors, see Schedule 3. Customer hereby authorizes the transfer of Customer Personal Data to locations outside Europe (Molin AI’s primary processing facilities are in the US, EU and UK), including to Sub-processors, subject to continued compliance with this DPA throughout the duration of the Agreement. Customer hereby provides general authorization to Molin AI engaging additional third-party Sub-processors to process Customer Personal Data in accordance with the Agreement.

b. Molin AI may, by giving reasonable notice to the Customer, add or replace Sub-processors to the Sub-processor Page. Molin AI will notify Customer if it intends to add or replace Sub-processors from the Sub-Processor Page at least 30 days prior to any such changes. To receive such notification, Customers can send an email to [dataprotection@molin.ai](mailto:dataprotection@molin.ai) to join Molin AI’s distribution list. If Customer reasonably objects to the appointment of a new Sub-processor within 15 days of receiving such notice, on reasonable grounds relating to the protection of the Customer Personal Data, then Molin AI will work in good faith with Customer to find an alternative solution. An objection is considered reasonable only if the Customer demonstrates that the proposed Sub-processor is unable to meet materially equivalent data protection obligations to those required under this DPA. Commercial preferences or general objections to cloud sub-processing do not constitute reasonable grounds. In the event that the parties are unable to reach a mutually acceptable resolution regarding the appointment of a new Sub-processor within a reasonable time after Customer’s objection, either party may initiate dispute resolution proceedings in accordance with the terms set forth in the Agreement.

**8. Impact Assessments and Consultations**

Molin AI shall, to the extent required by Applicable Data Protection Legislation, provide Customer with reasonable assistance (at Customer's cost and expense) with data protection impact assessments or prior consultations with data protection authorities that Customer is required to carry out under such legislation.

AI-Related Assistance. To the extent the Customer uses the Services for processing involving artificial intelligence or automated decision-making, Molin shall, upon request, provide Customer with information about the architecture, safety measures, data-handling practices and model-provider dependencies of the relevant AI features, to the extent such information is reasonably required for Customer’s AI-related impact assessments (including DPIAs) or compliance with the EU AI Act or equivalent legislation. This clause does not require Molin to disclose trade secrets, security-sensitive information or proprietary model weights.

**9. Security**

9.1. Molin AI has in place and will maintain throughout the term of the Agreement appropriate technical and organizational measures designed to protect Customer Personal Data against Security Breaches.

9.2. These measures shall at a minimum comply with Applicable Data Protection Legislation and include the measures identified in Schedule 2 (Technical and Organizational Security Measures). For clarity, such measures include multi-factor authentication, encryption in transit and at rest, role-based access control, periodic access reviews, security logging, vulnerability management, and regular penetration testing.

9.3. Customer acknowledges that the security measures implemented by Molin AI are subject to ongoing technological advancements and developments. Molin AI reserves the right to update or modify such security measures from time to time, provided that any such changes do not result in a reduction of the overall security level of the Services.

9.4. Upon becoming aware of a Security Breach affecting Customer Personal Data, Molin AI shall notify Customer without undue delay. Such notification shall include the information reasonably available to Molin AI at the time, and Molin AI shall provide additional details as they become available. The notification will describe, where known: (i) the nature of the Security Breach, including the categories and approximate number of data subjects and data records concerned; (ii) the likely consequences of the Security Breach; and (iiii) the measures taken or proposed to address the Security Breach, including measures to mitigate possible adverse effects.

Molin AI shall provide Customer with reasonable assistance to enable Customer to meet its obligations under Applicable Data Protection Legislation. Nothing in this DPA prevents Molin AI from complying with its own legal obligations to notify authorities or individuals.

9.5. Customer acknowledges and agrees that it bears sole responsibility for its use of the Service, including but not limited to: (a) implementing and maintaining appropriate security measures and controls proportionate to the risks associated with the processing of Customer Personal Data; (b) safeguarding all authentication credentials, devices, and systems used to access the Service against unauthorized access; and (c) regularly performing backups and ensuring the integrity and availability of Customer Personal Data.

9.6. Operational Human Access. Customer acknowledges that the Services may enable manual review of Customer Personal Data by Customer personnel (for example, reviewing email drafts or taking over live chats). Such review is carried out solely by Customer. Molin may permit limited human access to Customer Personal Data solely where necessary to: (i) provide support requested by Customer, (ii) maintain, secure, or improve the Services, (iii) detect or address service errors, incidents, misuse, or abuse, or (iv) comply with legal obligations. All such access is restricted to authorized personnel, logged, and subject to confidentiality and security controls.

**10. Return or Deletion of Customer Personal Data**

Return or Deletion of Data. Upon termination or expiry of the Agreement, Molin AI will (at Customer’s election) delete or return to Customer all Customer Personal Data (including copies) in its possession or control. Upon written request prior to deletion, Molin AI shall return Customer Personal Data in a commonly used format. (a) Deletion on request. Customer may instruct Molin AI to delete all Customer Personal Data, and Molin AI will do so without undue delay and in any event within 60 days of Customer’s written request. (b) Automatic deletion. If Customer does not request deletion or return, Molin AI will automatically delete Customer Personal Data from active systems within 90 days after termination or expiry of this DPA. (c) Backups. Customer Personal Data contained in backup systems will be overwritten in the ordinary course of backup rotation and deleted within 30–45 days thereafter (and in any case no later than 90 days), and will be isolated, encrypted, and not used for any purpose other than disaster recovery during that period. If a backup is restored, Molin AI will re-apply deletion to the restored copy without undue delay in line with this Section. (d) Legal hold. The foregoing does not apply to the extent Molin AI is required by Applicable Data Protection Legislation or other law to retain some or all Customer Personal Data; in such cases Molin AI will securely isolate the data and protect it from processing except as required by law, and will delete it promptly once the basis for retention ends.

**11. Audits**

11.1. The parties acknowledge that, when Molin AI processes Personal Data on the Customer’s behalf, the Customer must have the ability to verify Molin AI’s compliance with this DPA and with the Applicable Data Protection Legislation.

11.2. Documentation review. Upon written request, Molin AI will provide the Customer and/or its appropriately qualified third-party representative (the “Auditor”) with reasonable access—at no additional charge—to documentation that demonstrates Molin AI’s compliance with this DPA and with its obligations under Applicable Data Protection Legislation.

11.3. Audit rights. The parties intend to rely primarily on Molin AI’s documentation, representations, and third-party audit reports to demonstrate Molin AI’s compliance with this DPA. If the Customer reasonably requires a further audit, Molin AI will permit the Customer or its Auditor to carry out such audit of Molin AI’s processing of Customer Personal Data, at the Customer’s cost (including Molin AI’s reasonable costs), subject to the following terms: (a) Planning. The parties will agree in advance on the audit’s start date, scope, and duration. (b) Frequency. Audits may occur no more than once per calendar year, unless otherwise required by law or a competent authority. (c) Scope and conduct. Audits must be conducted during normal business hours, in a manner that avoids disruption to Molin AI’s operations, and will be limited to data and systems relevant to the Customer. (d) Confidentiality and security. All audits are subject to Molin AI’s security and confidentiality requirements and rules. Molin AI shall make available relevant information reasonably necessary to demonstrate compliance with this DPA. Access to internal systems, logs, or personnel shall be limited to what is strictly required, and subject to confidentiality and security restrictions. (e) Auditor qualification. Molin AI may reasonably object to an Auditor who is not suitably qualified, is a direct competitor, or whose participation could compromise confidentiality or security. In such case, the Customer must appoint a different Auditor or perform the audit itself. (f) Cost responsibility. The Customer will bear its own audit costs and those of any Auditor it appoints, as well as Molin AI’s reasonable expenses incurred in supporting the audit unless: (i) Customer has reasonable grounds to suspect non-compliance and the audit confirms it; or ii) audit is conducted due to a Security Breach affecting Customer Personal Data for which Molin AI or a Sub-processor is responsible. (g) SCC alignment. The audit rights under the Standard Contractual Clauses will be exercised in accordance with this Section 11 (Audits).

11.4. Independent reviews. Molin AI engages qualified external auditors to assess and verify the adequacy of its security and compliance controls related to the processing of Customer Personal Data. Information about Molin AI’s current audit reports, certifications, and related compliance standards is available on Molin AI’s website.

**12. Transfer Mechanisms**

12.1. Location of Processing. Customer acknowledges that Molin AI and its Sub-processors may process Personal Data in the United States and other countries where Molin AI or its Sub-processors operate. Molin AI will ensure that all such transfers comply with this DPA and Applicable Data Protection Legislation.

12.2. Transfer Mechanism. For any Restricted Transfer, the parties agree that the EU Standard Contractual Clauses (Commission Implementing Decision (EU) 2021/914) are incorporated by reference and shall serve as the primary transfer mechanism. Where required, the UK International Data Transfer Addendum to the EU SCCs and/or the Swiss addendum apply to such transfers.

Where Molin AI or its Sub-processors transfer Customer Personal Data to a recipient that maintains a valid certification under the applicable Data Privacy Framework (EU–U.S., UK Extension, or Swiss–U.S.), the parties may rely on such certification as an alternative transfer mechanism to the extent permitted under Applicable Data Protection Legislation.

Molin AI shall provide Customer with information reasonably available to assist Customer in conducting any transfer impact assessment required under Applicable Data Protection Legislation or the SCCs.

a. In relation to transfers of Customer Personal Data that is protected by the GDPR, the EU SCCs shall apply, completed as follows:

\- Module Two (controller → processor) or Module Three (processor → processor) applies, as appropriate.

\- The optional docking clause (Clause 7) applies.

\- For Sub-processor matters (Clause 9), Option 2 applies and the notice period is as stated in Section 7 of this DPA.

\- Clause 11 (redress option) does not apply.

\- Clause 17: governed by the law of Ireland.

\- Clause 18(b): disputes shall be resolved before the courts of Ireland.

\- Annex I and Annex II of the SCCs are completed using the information in Schedules 1 and 2 of this DPA.

b. Account Data Transfers. The parties acknowledge that Molin AI may process certain Account Data as an independent controller for purposes such as billing, account administration, and service improvement. Any international transfers of such Account Data will be conducted in accordance with applicable data-protection laws and valid transfer mechanisms, such as the Data Privacy Framework or the SCCs (Module One, controller → controller), as appropriate.

c. UK and Swiss Transfers. For transfers subject to the UK GDPR, the parties use a valid UK transfer mechanism (e.g., the UK International Data Transfer Addendum used with the EU SCCs, or a UK adequacy decision). For transfers subject to the Swiss FADP, the parties apply the EU SCCs with the Swiss-specific adaptations recognized by the Swiss authority, or rely on an applicable Swiss adequacy decision. In each case, Annex/Appendix information is taken from Schedules 1–2, and Sub-processor notice follows Section 7.

d. SCC Precedence. In case of conflict between the Standard Contractual Clauses and this Agreement (including this DPA), the Standard Contractual Clauses govern.

3\. Alternative or Successor Mechanisms. If a competent authority approves a new, replacement, or additional data transfer mechanism that provides an adequate level of protection under Applicable Data Protection Legislation, Molin AI may adopt such mechanism. Molin AI shall notify Customer of the change. Customer may object only if the new mechanism does not comply with Applicable Data Protection Legislation.

**13. Cooperation and Data Subject Rights**

13.1. Data Subject Rights. Molin AI provides Customers with self-service tools within the Services to help them manage data-subject requests under Applicable Data Protection Legislation. These tools include the ability to delete entire chatbots, which immediately removes access to the underlying data. The deleted chatbot data is permanently erased from Molin AI’s systems after 90 days. Customers may also delete individual conversations or entire conversation histories at any time through the Services’ conversational-delete function.

Upon Customer’s written request, and taking into account the nature of the Processing, Molin AI will provide reasonable assistance without undue delay to enable the Customer to respond to such requests that relate to Customer Personal Data. Customer shall reimburse Molin AI’s reasonable costs incurred in assisting with data subject requests. If Molin AI receives a data-subject request directly and can reasonably identify the Customer as the controller, Molin AI will promptly notify the Customer and will not respond to the request except as legally required. The parties agree that the Customer retains exclusive authority and responsibility for determining how to respond to and fulfill any data subject requests relating to Customer Personal Data.

13.2. Cooperation. Should either party receive (a) any request from a data subject to exercise rights under Applicable Data Protection Legislation, or (b) any Third Party Request concerning the processing of Account Data or Customer Personal Data conducted by the other party, it shall promptly notify the other party in writing. The parties agree to cooperate in good faith and to the extent necessary to respond effectively to any such Third Party Request and to fulfill their respective obligations under Applicable Data Protection Legislation.

**14. No sale or Sharing**

To the extent Molin AI’s Processing of Customer Personal Data is subject to U.S. state privacy laws (including the CCPA/CPRA, VCDPA, CPA, CTDPA, and UCPA), the parties agree that Molin AI acts as a Service Provider or Processor on behalf of the Customer. Accordingly, Molin AI shall not (a) Sell Customer Personal Data or otherwise make it available to any third party for monetary or other valuable consideration; (b) Share Customer Personal Data for cross-context behavioral advertising; (c) Retain, use, or disclose Customer Personal Data for any purpose other than the business purposes specified in this DPA or as otherwise permitted by U.S. data protection laws; (d) Retain, use, or disclose Customer Personal Data outside the direct business relationship between the parties; or (e) Combine Customer Personal Data with personal data that Molin AI receives from another person or collects through its own interactions, except: where the Customer provides documented instructions or consent to such combination, or where the data subject has provided valid consent or opt-in under applicable law.

Molin AI shall promptly notify the Customer if it determines that it can no longer comply with its obligations under applicable U.S. privacy laws. Upon providing such notice, Molin AI shall either cease processing Customer Personal Data or take all reasonable and appropriate measures to remediate any identified non-compliance.

**15. Miscellaneous**

15.1. In the event of any conflict between the terms of this DPA and the Agreement, the terms of this DPA shall prevail. The order of precedence shall be: (a) this DPA; (b) the Agreement; and (c) the Privacy Policy. Furthermore, to the extent of any inconsistency between the Standard Contractual Clauses and any provisions of this DPA, the Agreement, or the Privacy Policy, the Standard Contractual Clauses shall take precedence.

15.2. This DPA replaces any prior data processing addendum that Molin AI and Customer may have previously entered into related to the Services.

15.3. Any claims connected to this DPA shall be governed by the terms and conditions of the Agreement, including its limitations and exclusions.

15.4. In no event does this DPA restrict or limit the rights of any data subject.

15.5. In the event (and to the extent only) of a conflict (whether actual or perceived) among Applicable Data Protection Legislation, the parties (or relevant party as the case may be) shall comply with the more onerous requirement or standard.

15.6. Changes to this DPA. Molin AI may update this DPA where required to comply with applicable data protection laws, approved contractual mechanisms, or regulatory requirements. Such updates become effective upon notice to the Customer.

All other changes to this DPA must be agreed in writing between the parties. If a legally required change materially affects Customer’s use of the Service, Customer may terminate the affected processing activities upon written notice.

15.7. No Consideration for Data. The parties acknowledge that Molin AI’s access to and processing of Customer Personal Data are solely for the purpose of providing the Services under this Agreement. Such access or processing does not constitute part of the consideration or value exchanged between the parties. The parties further agree that no Customer Personal Data is provided to Molin AI in exchange for monetary or other valuable consideration.

15.8. No Third-Party Rights. This DPA is intended solely for the benefit of the parties and does not grant any rights or remedies to any third party, including any Third-Party Controller. Nothing in this clause limits or affects any rights or remedies available to Data Subjects under Applicable Data Protection Legislation, this DPA, or under the Standard Contractual Clauses or Data Privacy Framework, where applicable.

15.9. The parties agree that any notice or communication sent by Molin AI to Customer shall also satisfy any obligation to send such notice or communication to Customer’s Affiliate.

15.10. The Annexes, Schedules, and Appendices form an integral part of this DPA.

**Schedule 1**

**DETAILS OF PROCESSING**

**Annex 1 – Details of Processing of Customer Personal Data**

(This Annex 1 includes certain details of the Processing of Customer Personal Data as required by Article 28(3) GDPR.)

| Item                                       | Details                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| :----------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1. Parties                                 | Data Exporter (Controller/Customer): The entity identified as the 'Customer' in the Agreement and this DPA. Address and Contact Details: As specified in the Agreement. Contact Person / DPO (if any): As specified in the Agreement. Role: Controller. Data Importer (Processor/Molin AI): Molin AI Ltd. Address: As set forth in the Agreement. Contact Email: [dataprotection@molin.ai](mailto:dataprotection@molin.ai) Role: Processor.                                                                                                                                                                                               |
| 2. Subject Matter of Processing            | Processing of Customer Personal Data by Molin AI on behalf of Customer for the purpose of providing and supporting the Services under the Agreement, and any related technical or operational support activities expressly instructed by Customer.                                                                                                                                                                                                                                                                                                                                                                                        |
| 3. Duration of Processing                  | Processing continues for the term of the Agreement and any post-termination period reasonably required to delete, return, or securely isolate Customer Personal Data in accordance with Section 10 of this DPA.                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 4. Nature and Purpose of Processing        | <ul><li>Provide, maintain, and support the Services.</li><li>Host, store, transmit, and display Customer Personal Data.</li><li>Manage user accounts, authentication, and permissions.</li><li>Provide analytics, reporting, or optimization features.</li><li>Ensure security and detect or prevent misuse.</li><li>Comply with applicable laws or regulatory obligations.</li><li>Perform other Processing as instructed by Customer.</li></ul>                                                                                                                                                                                         |
| 5. Categories of Data Subjects             | <ul><li>End users or customers interacting with Customer’s chatbot or digital channels.</li><li>Customer employees, contractors, or agents accessing the Services.</li><li>Individuals whose personal data is contained in communications or content processed through the Services.</li></ul>                                                                                                                                                                                                                                                                                                                                            |
| 6. Categories of Personal Data             | <ul><li>Identification and contact data (name, email, phone, address).</li><li>Login credentials (hashed or tokenized).</li><li>Technical data (IP address, browser, logs, cookies).</li><li>Conversation and interaction data (chat transcripts, uploads, forms, messages, phone calls (and recordings thereof)). Email content, email headers, attachments, recipient/sender metadata.</li><li>Customer account and billing details.</li><li>Any other personal data entered by Customer or its end users. Note: Customer is responsible for ensuring that no unnecessary or prohibited data is entered without lawful basis.</li></ul> |
| 7. Sensitive or Special Categories of Data | Molin AI does not intentionally process special categories of data (Article 9 GDPR). Customer shall avoid transmitting such data unless expressly agreed in writing with appropriate safeguards.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 8. Frequency of Processing / Transfers     | Continuous during the operation of the Services.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 9. Retention and Deletion                  | Customer Personal Data is retained for the duration of the Agreement and deleted or returned per Section 10. Backups are deleted within standard retention cycles unless otherwise required by law.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 10. Sub-Processing and Onward Transfers    | Molin AI may engage approved Sub-Processors bound by equivalent data-protection obligations. A current list is available on Sub-processor page. Transfers outside the EEA/UK/Switzerland occur only under lawful transfer mechanisms (see Section 12 of this DPA).                                                                                                                                                                                                                                                                                                                                                                        |
| 11. Technical and Organizational Measures  | Molin AI maintains TOMs to protect Customer Personal Data against accidental or unlawful destruction, loss, alteration, unauthorized disclosure, or access. See Annex 2 for details (e.g., encryption, access control, monitoring, incident response).                                                                                                                                                                                                                                                                                                                                                                                    |
| 12. Competent Supervisory Authority        | <ul><li>EEA: Supervisory authority of Customer’s Member State of establishment or residence.</li><li>UK: Information Commissioner’s Office (ICO).</li><li>Switzerland: Federal Data Protection and Information Commissioner (FDPIC).</li></ul>                                                                                                                                                                                                                                                                                                                                                                                            |

This Annex 1 forms an integral part of the DPA and shall be deemed accepted and executed by the parties upon execution of the DPA (or the Agreement to which it is attached).

**Schedule 2 TECHNICAL AND ORGANIZATIONAL SECURITY MEASURES (TOMs)**

**Annex II**

1\. Molin AI maintains an information-security program designed to protect the confidentiality, integrity, and availability of Customer Personal Data, taking into account the risks of accidental or unlawful destruction, loss, alteration, unauthorized disclosure, or access. These measures reflect industry standards (ISO 27001 principles) and may evolve with technical progress, provided that such updates do not materially reduce overall security.

Where applicable, this Schedule 2 will serve as Annex II to the Standard Contractual Clauses. The following sections provide information regarding the technical and organizational security measures:

2\. Organizational Security

* Governance and Policies: Molin AI maintains an Information Security Policy, Access Control Policy, and Business Continuity Policy reviewed at least annually.
* Training and Awareness: All personnel receive mandatory privacy and security training, including secure-coding and phishing-resilience modules.
* Vendor Risk Management: Prior to onboarding Sub-processors, Molin AI assesses their security posture.

3\. Access Control and Authentication

* Access to production systems is role-based and limited to authorized personnel on a need-to-know basis.
* Multi-Factor Authentication (MFA) is mandatory for all privileged accounts.
* Passwords follow strong-credential rules (≥ 16 characters, complexity requirements) and are managed via a centralized identity provider.
* Access rights are reviewed at least every 180 days and immediately revoked upon role change or termination.
* Failed login attempts trigger account lockout (at more than 5 consecutive incorrect password attempts), all access events are logged and monitored.

4\. Encryption and Pseudonymization

* In Transit: All data transmitted via HTTPS with TLS 1.2 or higher (default TLS 1.3), AES-256 encryption, SHA-2 signatures.
* At Rest: Customer Data encrypted using AES-256-GCM within Cloudflare-managed storage.
* Key Management: Encryption keys stored and rotated securely with limited personnel access, subject to MFA and audit logging.
* Pseudonymization: When feasible, identifiers are separated or masked for diagnostic and analytics uses.

5\. Physical and Environmental Security

* Customer Data is hosted in secure Cloudflare data centers in the EU and U.S.
* Molin AI maintains no on-premise servers; all operations use virtualized cloud instances for redundancy and resilience.

6\. Operations Security and System Configuration

* Systems are hardened per CIS benchmarks and patched promptly.
* Change management processes ensure peer review, version control, automated testing, and rollback plans for all releases.
* Vulnerability scans and third-party penetration tests are performed regularly.
* Intrusion-prevention systems and network firewalls protect external interfaces; anomalous activity triggers alerts.

7\. Data Minimization, Retention and Deletion

* Data collection is limited to the purposes of processing (or the data that the Customer chooses to provide).
* Security measures are in place to provide only the minimum amount of access (least privilege) necessary to perform required functions.
* Upon termination or expiry of this DPA, Molin AI will (at Customer's election) delete or return to Customer all Customer Personal Data as per Section 10 of this DPA.

8\. Incident and Breach Management

* 24×7 on-call incident response with documented escalation paths.
* Security events are logged, triaged, and investigated; containment and remediation occur under defined SLAs.
* Customers are notified without undue delay after confirmation of a Personal Data Breach.
* Post-incident reviews identify corrective actions and drive continuous improvement.

9\. Business Continuity and Disaster Recovery

* Redundant architecture and automated backups ensure availability.
* Disaster Recovery (DR) plan tested periodically in coordination with cloud provider capabilities.
* Objective: restore service and access to Customer Data within commercially reasonable timeframes after disruption.

10\. Testing and Auditing

* Regular security assessments and internal audits validate control effectiveness.
* External SOC 2 / ISO 27001-aligned audits are conducted annually.

11\. Accountability and Certification

* Documentation of all processing activities maintained.
* Molin AI adheres to the principles of “privacy by design and default.”
* Implementation of ISO 27001 standards and participation in relevant certification programs are ongoing.

12\. Sub-processor Measures

Molin AI requires each authorized Sub-processor to implement adequate security measures.

13\. Updates

Molin AI may modify these Technical and Organizational Measures from time to time to reflect evolving threats and technology, provided that such modifications do not materially diminish the level of protection.

**Schedule 3**

**LIST OF SUB-PROCESSORS**

Annex III

Customer agrees that Molin AI may engage Sub-processors as set in Section 7 in this DPA. The list of Sub-processors are available on the Sub-processor Page.

**Schedule 4**

**UK Addendum to the EU Commission Standard Contractual Clauses (UK GDPR)**

Effective as of the DPA Effective Date.

1\. Purpose and Incorporation

1.1 This Schedule governs Restricted Transfers of Personal Data subject to the UK GDPR and provides Appropriate Safeguards under Article 46 UK GDPR.

1.2 The parties incorporate by reference the UK International Data Transfer Addendum to the EU Standard Contractual Clauses (version B1.0, in force 21 March 2022) (the “UK Addendum”), as issued by the UK Information Commissioner’s Office. The UK Addendum’s Mandatory Clauses apply in full.

1.3 This Schedule supplements the EU Standard Contractual Clauses (2021/914) used elsewhere in this DPA and completes them for transfers of Customer Personal Data subject to the UK GDPR.

2\. Part 1 — Tables (Completion)

The UK Addendum’s Part 1 Tables 1–4 are completed by reference to this DPA as follows:

* Table 1 (Parties): Exporter is the Customer (and its relevant Affiliates, if applicable). Importer is Molin AI. Contact details are as specified in the Agreement or in Annex 1 (Details of Processing).
* Table 2 (Selected SCCs, Modules, Clauses): Approved SCCs – Commission Implementing Decision (EU) 2021/914. Modules – Module 2 (controller to processor) and Module 3 (processor to processor) for Customer Personal Data; Module 1 (controller to controller) for Account Data where Molin acts as an independent controller.
* Table 3 (Appendix / Annex Information): Annex I(A)-(B) – Parties and description of transfers (Annex 1 of this DPA); Annex I(C) – ICO as competent authority; Annex II – Technical and Organizational Measures (Annex 2 of this DPA); Annex III – Sub-processors per the Sub-processor Page (or Annex 3, if applicable).
* Table 4 (ICO Revision Mechanism): Selection – Importer and Exporter (both parties). Either party may terminate the UK Addendum before the effective date of a revised Approved Addendum if that revision would cause a substantial and disproportionate increase in cost or risk, consistent with the ICO mechanism.

3\. Interpretation and Hierarchy

3.1 Terms used but not defined in this Schedule have the meanings given in the DPA, the EU SCCs, or the UK Addendum. Where the UK GDPR applies, references to the GDPR/EU are read as references to UK Data Protection Laws/the UK.

3.2 For Restricted Transfers subject to the UK GDPR: (a) the UK Addendum prevails over conflicting terms in the EU SCCs; (b) the SCCs prevail over the DPA or Agreement; and (c) the provision providing greater protection to data subjects prevails.

4\. UK-Specific Modifications to the EU SCCs

* References to 'Regulation (EU) 2016/679' are read as references to the UK GDPR and the Data Protection Act 2018.
* References to 'EU/Union/Member State' are read as references to the UK or UK law.
* Clause 13(a) and Annex I, Part C (EU authority) do not apply; the ICO acts as the competent supervisory authority.
* Clause 17 (governing law): England and Wales; Clause 18 (forum): courts of England and Wales; data subjects may also bring proceedings in any competent UK jurisdiction.
* Onward transfers: Clause 8.8(i) (Modules 2/3) is read to permit onward transfers to countries with UK adequacy regulations (Section 17A of the Data Protection Act 2018); Clause 8.7(i) (Module 1) similarly applies.
* Footnotes to the EU SCCs do not form part of this UK Addendum unless expressly required by the UK Addendum.

5\. UK Adequacy (Data Bridge) and Transfer Mechanisms

5.1 Where the recipient is certified under the UK Extension to the EU-U.S. Data Privacy Framework (DPF) and listed on the DPF List, the parties may rely on the UK adequacy regulations as the transfer mechanism for that transfer. Otherwise, the EU SCCs together with this UK Addendum shall apply.

5.2 The use of the UK adequacy regulations for certain transfers does not preclude reliance on the SCCs plus this UK Addendum for other transfers.

6\. UK Transfer Risk Assessment (TRA) Assistance

Molin AI shall provide information reasonably available to assist the Customer in conducting any UK Transfer Risk Assessment (TRA) or equivalent evaluation required for transfers under the UK GDPR.

7\. Annex References

* Annex I(A)-(B): Populated by Annex 1 (Details of Processing) to this DPA.
* Annex I(C): ICO as competent authority (UK GDPR).
* Annex II: Populated by Annex 2 (Technical and Organizational Measures).
* Annex III: Sub-processors per Molin AI’s Sub-processor Page or Annex 3 (if included).

8\. Execution and Form

The parties may enter into this UK Addendum by reference, including via electronic acceptance or attachment to the DPA, without separate signature, provided that it is legally binding and enforceable by data subjects as required by the UK Addendum.


# Data retention policy
Source: https://docs.molin.ai/legal/data-retention-policy

How Molin AI stores your data, how long each type is retained, and how our automated deletion processes remove it when it expires.

## What data enters the system

The following types of data are processed and stored:

* **Conversation data**: Message text, images, and documents (document support coming soon)
* **Order retrieval data**: Customer IDs, names, and phone numbers required for order lookups
* **Product database**: Your complete product catalog

## How we store data

All data is stored in secure, monitored environments with comprehensive logging.

The widget uses 30-day cookies and localStorage elements in the end user's browser for session management.

## Continuous aggregation

We maintain only aggregated statistics at the monthly level, such as the total number of messages in a given month.

Source data is not retained unnecessarily after aggregation is complete.

## System and observability data

### Logs and sessions

* **Duration**: 30 days
* **Scope**: IP addresses, session data, application logs
* **Storage**: Grafana Cloud
* **Application**: Uniform across all customers

### Email communications

* **Duration**: 30 days
* **Platform**: Customer.io
* **Application**: Uniform across all customers

### Database backups

* **Duration**: 90 days
* **Process**: Backups older than 90 days are automatically deleted

## Continuous monitoring

Our monitoring system continuously verifies that scheduled processes execute successfully. If any issues are detected, an automatic alert triggers our incident management process.

## Configuring retention periods

The default retention period for end-customer support data is 2 years for each widget. If your organization requires a shorter retention period, such as 90 days, please contact our support team at [hey@molin.ai](mailto:hey@molin.ai) to configure the widget.

The retention period starts from a ticket's most recent activity. Once it expires, automated cleanup removes the ticket, its messages, linked interaction data, and linked files from active systems. Failed external-file deletion is retried automatically.

An end-customer profile and its notes are removed only after the retention period has elapsed since the last contact and no retained ticket references the profile.

The widget retention period doesn't delete the merchant account, widget, preferences, settings, inbox folder definitions, integrations, product catalog, FAQs, or service documents.

<Warning>Reducing a widget's retention period applies to existing data. Tickets already older than the new period can be deleted during the next hourly cleanup, and deletion can't be undone.</Warning>

## Compliance

This data retention policy is designed to comply with GDPR and other data protection regulations. For more information about our GDPR compliance, see our [GDPR documentation](/legal/gdpr).


# DORA customer support
Source: https://docs.molin.ai/legal/dora-readiness

Security evidence and contract support for financial-sector customers assessing Molin AI against DORA requirements in the European Union.

Molin AI provides technology services to financial-sector customers.
DORA applies to the regulated customer, so each customer must assess whether Molin meets its requirements.

Visit the [Molin trust center](https://molin.ai/trust) to review our security information and request internal documents.

## Available now

* [security practices](./security-practices)
* [data processing addendum](./data-processing-addendum)
* [privacy policy](./privacy-policy)
* [subprocessor register](./subprocessors)
* [data retention policy](./data-retention-policy)
* [GDPR information](./gdpr)
* a platform data-flow overview
* security, access, encryption, monitoring, incident, recovery, AI, and vendor controls

## Internal documents

The trust center lists our current security policies individually.
Sign in with a Molin account, select the documents you need, and send an access request.
Approved documents appear in the trust center for a limited time.

Available policies include access control, information security, encryption, incident response, logging and monitoring, vendor management, backups, business continuity, and disaster recovery.
These documents are moving into Molin's internal compliance system, which will manage their versions and approvals.

## Recovery targets

Our current internal disaster recovery targets are:

* **RTO:** 4 hours
* **RPO:** 1 hour

Customer contracts can define the services and recovery commitments in scope.

## Contract support

For an in-scope service, we can cover:

* service levels, support, response, and restoration
* incident and outage notifications
* audit and regulatory cooperation
* resilience tests and remediation
* subprocessors and processing locations
* backups, continuity, RTO, and RPO
* data export, transition, retention, and deletion

## Independent assurance

| Programme        | Status                           |
| ---------------- | -------------------------------- |
| SOC 2 Type II    | Coming soon, expected in Q3 2026 |
| ISO 27001:2022   | Coming soon, expected in Q3 2026 |
| Penetration test | Coming soon, expected in Q3 2026 |

## Regulatory sources

Our approach is informed by [Regulation (EU) 2022/2554](https://eur-lex.europa.eu/eli/reg/2022/2554/oj?uri=CELEX%3A32022R2554) and its supporting regulations.

Questions? Email [compliance@molin.ai](mailto:compliance@molin.ai).


# GDPR
Source: https://docs.molin.ai/legal/gdpr

How Molin AI complies with the EU General Data Protection Regulation, and what that means for the personal data we process for you.

*Last updated: August 4, 2026*

At **Molin AI**, we work hard to comply with the **EU General Data Protection Regulation (GDPR)** to ensure that we fulfill our obligations and maintain transparency about customer messaging and how we use data.

## What's GDPR?

The **GDPR** is a comprehensive data protection law that came into effect on **May 25, 2018**.

It replaced existing EU law to strengthen the protection of *personal data* and the rights of individuals.

GDPR is a single set of rules that governs the processing and monitoring of EU data.

## Does it affect me?

**Yes, most likely.**

If you hold or process the data of **any person in the EU**, the GDPR applies to you — whether you're based in the EU or not.

## How Molin AI complies with GDPR

* Molin AI helps you meet your **data portability requirements**: you can export all data linked to an individual and permanently delete all user-linked data.
* Molin AI automatically removes end-customer support data according to each widget's configured **90 to 730-day** period, as described in our [data retention policy](/legal/data-retention-policy).

## GDPR — US Surveillance Protection

Molin AI carefully considers all third-party requests for data, including from law enforcement or national security agencies.

As policy, we **do not share information** that does not belong to the requesting party.

We respond only to legally binding requests (e.g. **court order, subpoena, warrant, or other valid legal demand**).

Where allowed by law, we **notify customers** of such requests and work with them if they wish to challenge or limit disclosure.

## Our Data Processing Addendum (DPA)

The **DPA**, incorporating the **new SCCs** issued by the European Commission on **June 4, 2021**, is included in the **Terms of Service** that govern Molin AI services — no separate signature required.

Our DPA sets out strong data protection commitments and the terms for Molin AI and our customers to meet GDPR obligations.

It is available for customers to review or sign upon request.

> Please note: We cannot accept alterations to our DPA.

> If you have specific questions, please contact us.

## Certified for International Data Transfers

To meet GDPR's requirements for cross-border data transfers, **Molin AI participates in**:

* **EU-U.S. Data Privacy Framework (DPF)**
* **UK Extension to the EU-U.S. DPF**
* **Swiss-U.S. Data Privacy Framework**

as set forth by the U.S. Department of Commerce.

For more details, see our [Privacy Policy](/legal/privacy-policy).

## Our Data Protection Officer

We have a dedicated **Data Protection Officer (DPO)** who oversees and advises on data management practices.

You can reach them at **[dataprotection@molin.ai](mailto:dataprotection@molin.ai)**.

## Coordination with Our Vendors

Where applicable, we require third-party vendors to **enter into data processing agreements** to ensure customer data remains protected under GDPR and consistent with our obligations.

## Encryption

All data sent to or from Molin AI is **encrypted in transit** using **256-bit encryption**.

We also **encrypt data at rest**.

We continuously monitor new regulatory guidance and may update our data practices to maintain compliance.


# Ninja Referral Program Terms
Source: https://docs.molin.ai/legal/ninja-referral-terms

Terms and conditions governing the Molin Ninja referral program, including eligibility, rewards, and anti-abuse provisions.

*Last updated: 31.03.2026*

## 1. What is the Ninja Referral Program?

Molin AI is offering Ninja Users the opportunity to earn credit rewards ("Rewards") by referring new users ("Invitees") to sign up for Molin Ninja ("Ninja"). This referral program ("Ninja Referral Program") is separate from and independent of any referral programs offered for the Molin AI platform.

These terms and conditions ("Referral Terms") govern participation in the Ninja ([https://ninja.new/](https://ninja.new/)) Referral Program. By participating, you agree to comply with these Referral Terms, the [Molin Ninja Terms and Conditions](/legal/ninja-terms), and the [Molin AI Terms of Service](/legal/terms-of-service).

## 2. Eligibility

a) To be eligible as a referrer, you must have an active Molin account in good standing.

b) The Invitee must be a new Molin User who has not previously created a Ninja account.

c) Molin AI employees, contractors, and their family members are not eligible to participate as either referrers or Invitees.

d) Users whose accounts have been suspended, terminated, or flagged for abuse are not eligible.

## 3. How It Works

### 3.1 Referral Link

Each eligible User receives a unique referral link accessible via the Molin dashboard. You may share this code with prospective Invitees through any lawful means.

### 3.2 Required Steps

For a referral to qualify, the Invitee must:

a) Sign up for a Molin Ninja account using the referrer's unique referral code or link.

b) Complete any additional onboarding or verification steps as specified in the Ninja dashboard at the time of the referral.

c) Any additional conditions communicated through the Ninja dashboard or referral materials at the time of the invitation.

The specific required steps may be updated from time to time and will be communicated through the Ninja dashboard.

### 3.3 Reward Distribution

a) Upon successful completion of all required steps by the Invitee, one or both parties will receive the applicable Reward.

b) Rewards are issued in the form of Ninja credits, which are added to the recipient's Ninja credit balance.

c) The specific Reward amounts for both the referrer and the Invitee will be communicated through the Ninja dashboard at the time of the referral.

d) Molin AI reserves the right to change Reward amounts at any time without prior notice. Changes will not affect Rewards already earned but not yet distributed.

## 4. Reward Terms

a) Referral Rewards are issued as Ninja credits only and have no cash value. They cannot be exchanged for cash, transferred to another User, or applied to Molin AI chatbot platform subscriptions.

b) Referral credits are subject to the same usage terms as purchased credits and are consumed through normal task execution.

c) There may be a maximum number of successful referrals per User per period. Any limits will be communicated through the Ninja dashboard.

d) Rewards will be credited within a reasonable timeframe after all required steps are verified.

## 5. Anti-Abuse and Fraud Prevention

a) The Ninja Referral Program is intended to reward genuine referrals of real, unique new Users to Ninja.

b) The following activities constitute abuse and are strictly prohibited:

* Creating fake, duplicate, or temporary accounts to generate referral Rewards.
* Self-referrals (referring yourself using a different email address or identity).
* Orchestrating campaigns designed to artificially inflate referral Rewards without resulting in genuine new Ninja Users.
* Misrepresenting your relationship with Molin AI or Ninja when soliciting referrals.
* Using paid advertising on search engines (Google Ads, Bing Ads, etc) or social media platforms (Facebook Ads, Instagram Ads, etc) that references Molin AI or Ninja brand names or variations thereof.
* Posting or distributing referral links or codes in public channels, including but not limited to social media posts, public forums, Reddit, coupon or deal-sharing websites, Discord servers, Telegram groups, blog comments, or any other publicly accessible medium. Referral links are intended for direct, personal sharing with individuals you know.
* Using multiple accounts, email aliases, or alternative identities to refer yourself or circumvent the one-referral-per-Invitee rule.

c) If Molin AI determines, in its sole discretion, that a User has engaged in fraud or abuse of the Ninja Referral Program, Molin AI may:

* Revoke any Rewards earned through fraudulent or abusive referrals.
* Suspend or terminate the User's referral privileges.
* Suspend or terminate the User's Ninja account.
* Take any other action deemed appropriate in the circumstances.

## 6. Program Changes and Termination

a) Molin AI reserves the right to modify, suspend, or terminate the Ninja Referral Program at any time, with or without notice.

b) If Molin AI terminates the program, any Rewards already credited to User accounts will remain valid and usable. Pending Rewards (where the Invitee has not yet completed all required steps) may be forfeited.

c) Molin AI will endeavour to provide notice of material changes through the Ninja dashboard or email.

## 7. Tax Obligations

Referral Rewards (whether in credits or any other form) may be subject to income tax or other taxes in your jurisdiction. It is entirely your responsibility to determine and pay any applicable taxes. Molin AI bears no liability for any tax obligations arising from receiving Rewards.

## 8. Limitation of Liability

Molin AI shall not be liable for any failure to award Rewards due to technical issues, system errors, or circumstances beyond its reasonable control. If you believe you are entitled to a Reward that has not been awarded, please contact us at [legal@molin.ai](mailto:legal@molin.ai).

## 9. Governing Law

These Referral Terms and any dispute arising out of or in connection with them shall be governed by and construed in accordance with the laws of England and Wales. The courts of England and Wales shall have exclusive jurisdiction.

## 10. Contact

If you have questions about the Ninja Referral Program, please contact us at: Molin AI Ltd, 124 City Road, London, England, EC1V 2NX, United Kingdom, or email [legal@molin.ai](mailto:legal@molin.ai).


# Molin Ninja Terms and Conditions
Source: https://docs.molin.ai/legal/ninja-terms

Additional terms and conditions governing the use of Molin Ninja, an AI-powered autonomous agent for e-commerce operations.

*Last updated: 31.03.2026*

## 1. Scope and Relationship to Main Terms

These Molin Ninja Terms and Conditions ("Ninja Terms") are a supplementary extension to the [Molin AI Terms of Service](/legal/terms-of-service) ("Main Terms"). These Ninja Terms govern the use of Molin Ninja ("Ninja"), an AI-powered autonomous agent product offered by Molin AI Ltd ("Molin AI", "we", "us"). By accessing or using Ninja, you ("User", "you") agree to be bound by both the Main Terms and these Ninja Terms. In the event of a conflict between these Ninja Terms and the Main Terms with respect to Ninja-specific matters, these Ninja Terms prevail.

These Ninja Terms apply to all Users of Ninja, including those on free and paid plans.

## 2. Description of Ninja

Molin Ninja is an AI-powered autonomous agent that can execute tasks on behalf of Users. Ninja operates within a sandboxed cloud environment and has the ability to:

a) Execute code and shell commands in an isolated cloud sandbox.

b) Browse the web, interact with websites, and extract content.

c) Access and perform operations on connected e-commerce store backends (including but not limited to Shopify, Shoprenter, Shoper, and UNAS) using the permissions granted by the User's installed integrations.

d) Read, create, edit, and manage files within the sandbox environment.

e) Search the web and retrieve information from external sources.

f) Upload and process files provided by the User.

g) Store and retrieve secrets and credentials via the Ninja Vault.

h) Perform any other operations made available through Ninja's toolset as updated from time to time.

## 3. Plans and Pricing

### 3.1 Free Plan

Ninja offers a Free plan that provides Users with a daily credit allowance at no cost. The number of free daily credits is as specified on the [Ninja pricing page](https://ninja.new/#pricing). Daily credits reset each day and do not accumulate. The Free plan does not include a monthly credit allowance.

### 3.2 Paid Plans

Ninja offers paid subscription plans with varying monthly credit allowances. Current plan details, pricing, and included credit allowances are published on the [Ninja pricing page](https://ninja.new/#pricing) and in the applicable Order Form. Molin AI reserves the right to modify plan pricing, credit allowances, and available tiers at any time. Changes to pricing will not affect the current billing period of existing subscribers.

### 3.3 Additional Credits (Top-ups)

Users on paid plans may purchase additional credits outside their monthly allowance through one-time top-up purchases. Top-up credits do not expire at the end of the billing cycle.

### 3.4 Signup Bonus

New Users may receive a one-time signup bonus of credits upon creating their Ninja account. This bonus is awarded once per User and is non-transferable.

### 3.5 Molin Ninja Billing is Independent

**Molin Ninja billing is entirely separate from the Molin AI chatbot platform billing.** Purchasing a Molin AI chatbot subscription plan (Startup, Growth, Scale, or Enterprise) does not grant access to paid Ninja features or credits, and vice versa. Each product has its own independent subscription, billing cycle, and credit system.

## 4. Credit System and Refunds

### 4.1 Credit Consumption

Ninja operates on a credit-based billing model. Credits are consumed when Ninja executes tasks on your behalf. The number of credits consumed per task varies depending on the complexity of the task, the AI models used, and the computational resources required.

### 4.2 Refund Policy for Credits

Ninja's credit system operates in the same manner as telecommunications services (mobile calls, data usage, etc). **Once credits have been consumed through task execution, they are non-refundable.** This applies to both credits included in your subscription plan's monthly allowance and credits purchased through top-ups.

You may request a refund for **unused purchased credits** (top-ups) in accordance with applicable consumer protection laws. However, credits that have already been consumed to execute tasks cannot be reversed, refunded, or credited back to your account, as the underlying computational resources and AI model usage have already been incurred.

### 4.3 Free Daily Credits

The free daily credits provided to all Users (including paid plan subscribers) are complimentary and are excluded from any refund considerations. They carry no monetary value, cannot be transferred, and expire at the end of each day.

### 4.4 Subscription Cancellation

If you cancel your Ninja subscription, your monthly credit allowance will cease at the end of the current billing period. Unused purchased top-up credits are not affected by cancellation and remain available until consumed.

### 4.5 Credit Distribution Disclaimer

Molin AI reserves the right to withhold, delay, adjust, or decline the distribution of credits (including but not limited to free daily credits, monthly plan allowances, signup bonuses, referral rewards, and promotional credits) at any time and for any reason, including but not limited to:

a) Software bugs, system errors, or technical failures affecting credit calculation or distribution.

b) Suspected fraudulent activity, abuse, or manipulation of the credit system.

c) Billing or payment processing errors.

d) Force majeure events or circumstances beyond Molin AI's reasonable control.

e) Errors in credit amounts resulting from system miscalculations or incorrect configurations.

Molin AI shall not be liable for any losses, damages, or claims arising from the failure, delay, or incorrect distribution of credits, regardless of the cause. While Molin AI will make reasonable efforts to resolve credit distribution issues in a timely manner, no guarantee is made that credits will be delivered without interruption or error at all times.

## 5. Assumption of Risk and Limitation of Liability

### 5.1 Autonomous Agent Risks

**IMPORTANT: BY ACCESSING OR USING NINJA (INCLUDING ON THE FREE PLAN), YOU ACKNOWLEDGE AND ACCEPT THAT NINJA IS AN AUTONOMOUS AI AGENT CAPABLE OF PERFORMING ACTIONS THAT MAY BE IRREVERSIBLE.**

Ninja has the ability to access connected e-commerce store backends and perform operations including, but not limited to:

a) Modifying, creating, or deleting products, orders, customers, and inventory data.

b) Executing API calls that alter your store's configuration and settings.

c) Running code that interacts with external services and databases.

d) Performing bulk operations that affect large volumes of data.

e) Making changes to your store that cannot be undone.

Such actions may result in data loss, operational disruption, financial impact, or other consequences that may be difficult or impossible to reverse. **Molin AI does not guarantee the accuracy, safety, or appropriateness of actions taken by Ninja.**

### 5.2 User Responsibility

You are solely responsible for:

a) Reviewing and validating tasks before and after Ninja executes them.

b) Maintaining adequate backups of your store data and configurations.

c) Ensuring that the permissions granted to Ninja through your e-commerce platform integrations are appropriate for your intended use.

d) Monitoring Ninja's actions and intervening when necessary.

e) Any consequences arising from tasks executed by Ninja on your behalf.

### 5.3 No Liability for Ninja Actions

To the fullest extent permitted by applicable law, Molin AI shall not be liable for any direct, indirect, incidental, special, consequential, or punitive damages arising from or related to actions performed by Ninja, including but not limited to data deletion, data corruption, financial losses, lost sales, business interruption, or any other damages resulting from Ninja's execution of tasks on your connected stores or systems.

**By using Ninja, every User (including free plan Users) accepts these risks and acknowledges that Molin AI bears no responsibility for the outcomes of Ninja's autonomous actions.**

## 6. Ninja Vault (Secrets Management)

### 6.1 Description

Ninja Vault is a feature that allows Users to store secrets, credentials, API keys, passwords, and other sensitive information ("Vault Data") for use by Ninja during task execution. Vault Data is stored per-User and is accessible only within the User's Ninja sessions.

### 6.2 User Responsibility for Vault Data

**While Molin AI encrypts and secures Vault Data using industry-standard measures, Users should exercise caution when storing sensitive information in the Ninja Vault.** You acknowledge and accept the following:

a) You store secrets and credentials in the Ninja Vault at your own risk.

b) Vault Data may be transmitted to AI model providers and sandbox environments during task execution. While these providers are contractually prohibited from retaining or training on such data, Molin AI cannot guarantee absolute security of data in transit or at rest within third-party systems.

c) You are solely responsible for the security implications of storing passwords, API keys, access tokens, and other credentials in the Ninja Vault.

d) You should not store credentials that grant unrestricted administrative access to critical production systems unless you fully understand and accept the associated risks.

e) Molin AI shall not be liable for any unauthorized access, data breach, or misuse of Vault Data, except to the extent caused by Molin AI's gross negligence or willful misconduct.

### 6.3 Sensitive Data Advisory

You are advised to use the principle of least privilege when storing credentials in the Ninja Vault. Where possible, use credentials with limited scope and permissions rather than full administrative access. Molin AI recommends rotating any credentials stored in the Vault on a regular basis.

## 7. Task Sharing

### 7.1 Sharing Functionality

Ninja allows Users to share completed tasks, including task prompts, outputs, and associated data, with anyone via shareable links or other sharing mechanisms ("Shared Tasks").

### 7.2 User Responsibility for Shared Content

**You are solely responsible for the content you share and the consequences of sharing it.** You acknowledge that:

a) Shared Tasks may contain sensitive business information, customer data, store configurations, credentials, API responses, or other confidential information generated during task execution.

b) Once a task is shared, any person with access to the shared link or content can view it. Molin AI does not control who accesses Shared Tasks after they are shared by you.

c) You must ensure that sharing a task does not violate any applicable data protection laws, confidentiality obligations, or third-party rights.

d) Molin AI shall not be liable for any damages, losses, or claims arising from your decision to share task content, including exposure of sensitive or confidential information.

### 7.3 Recommendation

Before sharing a task, review its contents carefully to ensure it does not contain any sensitive information (such as passwords, API keys, customer personal data, or proprietary business data) that should not be disclosed.

## 8. Ninja Referral Program

Molin AI may offer a referral program for Ninja. The full terms and conditions governing the Ninja Referral Program are set out in the [Ninja Referral Program Terms](/legal/ninja-referral-terms). By participating in the Ninja Referral Program, you agree to comply with those terms in addition to these Ninja Terms.

## 9. Browser and Web Access

Ninja includes browser automation capabilities that allow it to navigate websites, interact with web content, fill forms, and extract information on your behalf. You acknowledge that:

a) Ninja may access third-party websites and services as part of task execution. You are responsible for ensuring that such access complies with the terms of service of those third-party sites.

b) Molin AI is not responsible for the accuracy, availability, or content of third-party websites accessed by Ninja.

c) You should not instruct Ninja to access websites or services in violation of their terms of use or applicable law.

## 10. Code Execution

### 10.1 Sandbox Environment

Ninja executes code within an isolated cloud sandbox environment. While sandboxed, the execution environment has access to network resources, file systems, and installed software packages.

### 10.2 User Responsibility

You are responsible for reviewing and understanding the code that Ninja generates and executes. Molin AI does not warrant that code generated by Ninja is free from errors, security vulnerabilities, or unintended side effects.

### 10.3 File Uploads

Users may upload files to Ninja for processing within the sandbox. Uploaded files are subject to size and type restrictions as documented in the product. You are responsible for ensuring that uploaded files do not contain malware or content that violates applicable law.

## 11. Data Retention and Deletion

Task data, including prompts, outputs, uploaded files, and execution logs, is retained in accordance with the [Data Retention Policy](/legal/data-retention-policy) and the [Privacy Policy](/legal/privacy-policy). Users may request deletion of their Ninja data in accordance with applicable data protection laws.

## 12. Service Availability and Beta Features

### 13.1 Availability

Ninja is provided on an "as is" and "as available" basis. Molin AI does not guarantee uninterrupted access to Ninja or its features.

### 13.2 Beta Features

Certain Ninja features may be designated as beta, experimental, or early access. Such features are provided without warranty and may be modified or discontinued at any time.

## 13. Modifications to These Terms

Molin AI may update these Ninja Terms from time to time. Updates become effective as soon as they are posted. Continued use of Ninja after changes are posted constitutes acceptance of the updated terms. Molin AI will endeavour to provide reasonable notice of material changes through the Ninja dashboard or other appropriate means.

## 14. Governing Law and Dispute Resolution

These Ninja Terms and any dispute arising out of or in connection with them shall be governed by and construed in accordance with the laws of England and Wales. The courts of England and Wales shall have exclusive jurisdiction.

## 15. Contact

If you have questions about these Ninja Terms, please contact us at: Molin AI Ltd, 124 City Road, London, England, EC1V 2NX, United Kingdom, or email [legal@molin.ai](mailto:legal@molin.ai).


# Privacy Policy
Source: https://docs.molin.ai/legal/privacy-policy

Learn how Molin AI collects, uses, and protects your personal data in compliance with GDPR and data protection laws.

*Last updated: 04.09.2026*

**Introduction**

MOLIN AI LTD. (“Molin AI”, “we”, “our” and “us”) is committed to protect the personal data of its users (“user”, “you”, “your”) and to respect their privacy.

**1. Scope of this Privacy Policy**

This Privacy Policy (“Policy”) sets out how we use and process personal data when:

* you visit or interact with our websites and online properties;
* you create, manage, or use a Molin AI Customer account;
* you communicate with us through support channels or marketing interactions;
* you use the Molin AI platform, including AI Agents, workflows, dashboards, analytics, and other features;
* you engage with Molin AI through our supported communication channels, including:
  * Chat (web chat, in-app chat),
  * Social Messaging (WhatsApp, Facebook Messenger, Instagram),
  * Email (two-way forwarding and replies),
  * Phone (inbound and outbound calls),
  * SMS (two-way messaging).

This Privacy Policy applies to:

* Customers (organizations using Molin AI Services);
* Customer administrators and team members;
* Website visitors and prospective customers;
* Individuals who interact with Customer’s AI Agents (“End Users”).

Please read this Policy carefully to understand our views and practices regarding your personal data.

When Molin AI processes personal data as an independent Controller (for example, account data, usage data, analytics, or data processed through the Molin Account), such processing is governed by this Privacy Policy.\
When Molin AI processes personal data on behalf of a Customer as a Processor (for example, chat transcripts, emails, or end-user interactions with Customer AI Agents), such processing is governed by the Molin AI Data Processing Addendum (“DPA”), which prevails in case of conflict.\
Capitalised terms used but not defined herein have the meanings given in our Terms of Service (available at: [https://docs.molin.ai/legal/terms-of-service](https://docs.molin.ai/legal/terms-of-service)) or in the DPA.

**2. Our Roles Under Data Protection Law**

Molin AI acts either as Controller or Processor depending exclusively on the purposes for which personal data is processed. The same category of data (for example, technical metadata or communication logs) may fall under different roles depending on whether Molin AI determines the purposes and means of the processing, or whether Molin AI processes the data strictly in accordance with Customer instructions.\
**2.1 When Molin AI Acts as a Controller**\
Molin AI is the Controller when we determine the purposes and means of processing personal data. This includes:

**a) Website & Marketing Activities**\
We collect and process personal data when you visit our websites, submit forms, subscribe to communications, or engage with our marketing content.

**b) Customer Account & Workspace Administration**\
We process personal data of Customer administrators and invited users to:

* create and manage accounts and workspaces;
* authenticate users;
* control permissions and roles;
* manage billing, invoicing, and subscription settings;
* maintain security logs and audit trails.

**c) Product Analytics and Service Improvement**\
We process personal data to operate, optimize, and improve the functionality of the Services, including measuring usage patterns, feature performance, and reliability.

**d) Security and Fraud Prevention**\
We process data to protect our systems and users from malicious activity, enforce access controls, prevent abuse, and maintain service integrity.

**e) Molin Account**\
Molin AI acts as an independent Controller for the processing of personal data associated with the creation and operation of optional Molin Accounts.

**2.2 When Molin AI Acts as a Processor**\
We act as a Processor when we process Customer Personal Data strictly based on the Customer’s documented instructions and in accordance with the DPA. This includes personal data processed through the following channels:

**a) Chat**

* Web chat, embedded chat widgets, in-app chat.
* Conversation content, attachments, and metadata.

**b) Social Messaging**

* WhatsApp, Facebook Messenger, Instagram Direct.
* Message content, timestamps, platform IDs, names (if available).

**c) Email (two-way)**

* Incoming emails may be ingested and displayed to the Customer for review. Molin may generate AI-assisted draft replies, but all outbound emails require human review and are only sent by the Customer or its authorized users.
* Headers, subject, recipients, attachments.

**d) Phone (inbound & outbound)**

* Phone numbers, call logs, timestamps, call status.
* Call recordings and optional transcriptions when explicitly enabled.

**e) SMS**

* SMS content, phone numbers, delivery metadata.

**AI Agent / Workflow Data**

* Prompts (inputs), uploaded files, context history.
* AI-generated outputs (responses, summaries, classifications). Molin AI does not send email replies autonomously on behalf of Customers unless explicitly configured.
* Workflow triggers and variables.

**Customer-Provided Sources**

* CRM imports or synchronizations.
* Contact lists, CSV uploads.
* Stored knowledge bases, documents, or business data.
* Product data.

All processing of Customer Personal Data is governed by the DPA.

**2.3 Customer Responsibilities**\
Customers are responsible for:

* determining the appropriate legal basis for processing End User data;
* providing required privacy notices to their End Users;
* complying with applicable communications laws (e.g. PECR, ePrivacy, anti-spam rules, telecom regulations);
* meeting channel-specific obligations (WhatsApp/Meta/Twilio policies, etc.);
* configuring retention, deletion, and workflow logic within Molin AI appropriately.

Molin AI processes Customer Personal Data only as instructed.\
Customers are responsible for informing End Users when interactions involve AI-generated responses, where required by applicable law or under the Terms of Service.

**3. Information We Collect**\
The following categories of personal data may be collected depending on your interaction with Molin AI.

**3.1 Website Visitor & Marketing Interaction Data (Controller)**\
When you interact with our sites or emails, we may collect:

* IP address, device type, OS, browser type;
* language preferences, time zone;
* screen resolution and display settings;
* referring URL (site you visited before ours);
* pages viewed, navigation paths, scroll depth;
* time spent per page or screen;
* links and UI elements clicked;
* email interaction data (opens, clicks);
* cookies and storage identifiers;
* diagnostic, performance, and error logs.

We may use third-party analytics tools (e.g., Google Analytics, Posthog) to collect certain technical information and usage patterns.

**Email open tracking.** The emails we send you may include a small tracking pixel that tells us whether and when an email was opened, which we use to measure engagement and improve our communications. Open tracking is enabled by default (an opt-out model): unless you object, we track opens for the emails we send you. By using the Services or otherwise receiving our emails, Customers acknowledge and consent to this default opt-in. You may withdraw at any time using the “Manage tracking” link included in our emails or by contacting us, and withdrawing does not affect delivery of the emails themselves.

**3.2 Account & Workspace Administration Data (Controller)**\
We process:

* name, email address, role, workspace affiliation;
* hashed authentication credentials;
* multi-factor authentication settings;
* billing details and invoicing contacts;
* workspace configuration, team membership, role assignments;
* activity logs, security logs, access timestamps.

**3.3 AI Agent & Conversation Data (Processor)**\
We process, on behalf of the Customer:

* AI agent inputs (prompts, questions, uploaded documents, context);
* AI-generated outputs (responses, summaries, classifications);
* conversation transcripts, message contents, files, images;
* context variables and workflow logic;
* Customer-configured business rules and routing instructions.

**3.4 Omnichannel Communication Data (Processor)**\
Depending on the channels Customers enable:\
**Chat**

* Chat messages, attachments, timestamps, session identifiers.

**Social Messaging**

* platform user IDs, display names (if provided), message content, attachments.

**Email**

* email content, metadata, headers, attachments, automatically generated replies.

**Phone**

* phone numbers, call metadata and optional call recordings or transcriptions when the Customer explicitly enables recording features.

**SMS**

* message bodies, phone numbers, delivery receipts.

**3.5 Customer-Provided and Integrated Data (Processor)**\
We may process data Customers choose to import or connect, including:

* CRM data from platforms like HubSpot, Salesforce, Intercom;
* contact lists, segmentation groups;
* uploaded files, documents or knowledge base content used to power AI Agents;
* data passed via APIs or integrations.

**3.6 Technical, Security & Log Data (Controller)**

* authentication logs, access logs;
* device metadata, IP address, browser characteristics;
* performance metrics, latency, throughput;
* crash logs, diagnostic traces;
* session identifiers and device fingerprints.

Where technical logs contain Customer Personal Data arising from communication processing, Molin AI processes that data as a Processor in accordance with the DPA.

**3.7 Usage Data (Controller)**\
We also collect Usage Data relating to how the Services are accessed and used, including:

* feature usage metrics;
* performance events;
* workflow execution counts;
* API usage;
* latency & reliability metrics;
* configuration choices and interaction patterns within the dashboard.

Molin AI processes Usage Data as an independent Controller to operate, secure, and improve the Services. Usage Data does not include Customer Personal Data unless such data is inseparable from operational logs, in which case Molin AI processes it as a Processor in accordance with the DPA.\
Where Customers enable performance analytics, Molin AI may process metadata such as response times, interaction statistics, sentiment indicators, and conversation quality metrics. Customers are responsible for ensuring compliance with employment and monitoring laws regarding their personnel. Where performance indicators or interaction metadata relate to specific Customer conversations, Molin AI processes such metadata as Customer Personal Data under the DPA.

**3.8 End-User Molin Account Data (Controller)**\
If End Users choose to create a Molin Account, we process:

* name, email address, phone number;
* authentication credentials (hashed);
* account preferences and communication settings;
* saved interaction history, previous AI Agent conversations, or user-defined preferences;
* identifiers linking the End User to multiple Customer websites or applications where Molin is enabled (subject to user consent).

Creating a Molin Account is optional. End Users may delete their account at any time, and may use Customer websites without creating a Molin Account.

**3.9 Special Categories of Data**\
Molin AI does not intentionally collect or process special categories of personal data (e.g., health, biometric, genetic, racial or ethnic origin, political opinions, religious beliefs, sexual orientation) or other sensitive personal information. Customers must not submit such data unless expressly permitted in writing under the DPA.

**4. How We Use Personal Data**\
Molin AI uses personal data for the following purposes and legal bases:

**4.1 When We Act as Controller**\
**4.1.1 Providing and Operating the Services**\
We use personal data to:

* create and manage Customer accounts and workspaces;
* authenticate users and maintain secure login sessions;
* provide access to the Molin AI platform, AI Agents, workflows, and integrations;
* enable communication features (such as dashboards, analytics, and workspace settings).

**Legal basis:** Performance of a contract / steps prior to entering into a contract.

**4.1.2 Maintaining Security and Preventing Misuse**\
We process personal data to:

* detect and prevent fraud, spam, abuse, or security threats;
* enforce access controls and verify credentials;
* maintain platform reliability and service integrity;
* audit system activity and maintain compliance records.

**Legal basis:** Legitimate interests; in some cases legal obligation.

**4.1.3 Improving and Developing the Services**\
We analyze product usage and performance data to:

* improve existing features;
* troubleshoot and resolve bugs;
* optimize routing, latency, uptime, and resource usage;
* understand product engagement patterns;
* train internal systems using anonymized or aggregated datasets.

Where feasible, analytics data is de-identified before use.\
**Legal basis:** Legitimate interests.\
Customers may review conversation histories for quality assurance and service improvement. Molin AI may provide aggregated insights, topic summaries, or trend analytics to support such evaluations.

**4.1.4 Marketing & Communications**\
We use personal data to:

* send product updates and service notifications;
* communicate with Customers regarding improvements or new features;
* send marketing communications where legally permitted.

**Legal basis:** Consent (where required) or legitimate interest.\
Where individuals subscribe to newsletters or marketing updates, Molin AI may contact them with product news, offers, and promotional communications, in accordance with applicable laws. Marketing communications are sent based on consent or, where permitted, legitimate interest (e.g., existing customer soft opt-in). Subscribers may withdraw consent at any time.

**4.1.5 Compliance With Legal Obligations**\
We process certain data to:

* comply with tax, accounting and regulatory requirements;
* respond to lawful requests from public authorities;
* enforce our Terms and investigate potential violations.

**Legal basis:** Legal obligation.

**4.1.6 Providing the Molin Account Feature (Controller)**\
Where End Users choose to create a Molin Account, we process personal data to:

* create and maintain the End User’s Molin profile;
* enable recognition of the user across Customer websites or applications as part of the Molin Account functionality;
* provide personalized or persistent conversation context to AI Agents;
* store user preferences, history, or interaction settings;
* allow the user to access, view, manage, or delete their profile and associated data.

Legal basis: **Consent** (for recognizing users across Customer properties) and **performance of a contract** (for operating the Molin Account itself).

**4.2 When We Act as Processor (AI Agent & Omnichannel Services)**\
When Customers configure AI Agents or communicate via supported channels, Molin AI processes Customer Personal Data strictly in accordance with:

* Customer instructions, and
* the Molin AI Data Processing Addendum (“DPA”).

Processor activities include, but are not limited to:

* generating AI responses;
* routing messages through chat/social/email/phone/SMS;
* performing context lookups and maintaining conversation state;
* executing Customer-defined workflows and automations;
* enabling Customer dashboards, reporting, auditing, and analytics;
* managing retention and deletion as configured by the Customer.

**Legal basis:** Determined by the Customer as Controller.

**4.3 Security, Abuse Prevention, and Misuse Detection**\
Molin AI may process certain technical signals, usage patterns, metadata, or system-generated indicators to detect spam, abuse, fraud, harmful content, or violations of our security requirements.\
Such processing is carried out either as a Controller for security and integrity purposes or as a Processor when it forms part of Customer-defined instructions.

**4.4 AI-Specific Uses**\
Molin AI uses data processed through the AI Agent features to:

* generate responses, summaries, classifications, suggestions, and actions;
* maintain context across multi-step conversations;
* enable workflow logic such as lead capture, bookings, routing or verification;
* prevent harmful, abusive, or policy-violating content;
* ensure safety, stability, fairness, and correct functioning of the AI.

Any such processing remains within the scope of Customer instructions when Molin AI acts as a Processor.\
The Services are not intended for high-risk or regulated uses such as medical diagnosis, clinical decision-making, or processing subject to health-specific regulations, unless expressly agreed in writing with Molin AI.\
**Model Training**\
Unless explicitly stated otherwise and enabled by the Customer:

* Molin AI does not use identifiable Customer Personal Data to train general-purpose machine learning models.
* We may use anonymized or aggregated usage data to improve model performance in a manner that does not identify any individual.

**4.5 Human Review**\
The Services allow Customers to perform manual review of data (such as reviewing AI-generated email drafts or taking over live chats). These actions are performed solely by the Customer or its authorized users, not by Molin AI.\
Molin AI may permit limited human access to Customer Personal Data solely where necessary to: (i) provide support requested by Customer, (ii) maintain, secure, or improve the Services, (iii) detect or address service errors, incidents, misuse, or abuse, or (iv) comply with legal obligations. All such access is restricted to authorized personnel, logged, and subject to confidentiality and security controls.\
Molin AI does not conduct human review of messages, conversations, or emails on behalf of Customers, except where a Customer explicitly instructs Molin to assist with support or troubleshooting.

**4.6 Automated Decision-Making**\
Molin AI does not engage in solely automated decision-making that produces legal or similarly significant effects on individuals.\
If Customers configure workflows that may have such effects (e.g. automated eligibility outcomes), they are responsible for:

* ensuring transparency to data subjects;
* providing a lawful basis;
* complying with Article 22 UK/EU GDPR where applicable;
* building appropriate human review into their processes.

**5. How We Share Personal Data**\
Molin AI shares personal data only as necessary to offer the Services, or when legally required.

**5.1 Sub-Processors (Processor Role)**\
We use carefully selected sub-processors to support infrastructure and operations, including:

* cloud hosting providers,
* email delivery and routing tools,
* SMS and telecom carriers,
* analytics and logging services,
* content moderation services (if configured).

The current list is kept up-to-date at:\
[https://docs.molin.ai/legal/subprocessors](https://docs.molin.ai/legal/subprocessors)\
All sub-processors are bound by:

* confidentiality obligations,
* technical and organizational measures,
* data processing agreements,
* and international data transfer safeguards.

**5.2 Communication Channel Providers**\
When Customers connect communication channels, we share data with:

* WhatsApp / Meta Platforms,
* Facebook Messenger,
* Instagram Messaging,
* email providers,
* telephony/SMS carriers.

We share only the data necessary to route communications via these platforms, such as:

* phone numbers,
* message content,
* attachments,
* message metadata.

These platforms may act either as (sub-)processors or independent controllers depending on their role.

**5.3 AI Model Providers (Sub-Processors)**\
When Customers enable AI features, Molin AI may transmit inputs, prompts, and contextual data to trusted large language model (LLM) providers acting as Sub-processors.\
These providers process such data solely for the purpose of generating outputs requested by the Customer and are contractually prohibited from:

* using Customer Personal Data for training large language models;
* using Customer Personal Data for their own purposes;
* retaining Customer Personal Data beyond the processing window necessary to generate the output.

Molin AI lists all AI-related Sub-processors on its Sub-processor Page.

**5.4 Service Providers (Controller Role)**\
As a Controller, we share limited data with providers who help us:

* send emails and notifications,
* host our websites and apps,
* analyze website and product performance,
* manage billing and payments,
* provide security monitoring.

We restrict access to what is strictly necessary.

**5.5 Sharing Related to the Molin Account Feature**\
If an End User creates a Molin Account and chooses to enable cross-site recognition, we may share limited identifiers (such as a hashed user token or preferences) with Customer websites or applications that have integrated Molin, solely to recognise the user and to provide the Molin Account features the user has opted into. If an End User subscribes to optional features such as price alerts or product interest notifications, Molin AI may share limited preference data with participating Customers to provide the requested service. Such sharing occurs only with End User’s explicit opt-in.\
We do not share conversation histories between Customers.\
End Users can disable cross-site recognition or delete their Molin Account at any time.

**5.6 Legal Requests and Compliance**\
We may disclose personal data where required to:

* comply with laws and regulations;
* respond to valid legal requests;
* prevent harm or criminal activity;
* protect our rights or those of users or the public.

We review all requests and challenge those we believe are unlawful or overbroad.

**5.7 No Sale or Sharing**\
Molin AI does not engage in cross-context behavioral advertising.\
Molin AI does not sell personal data, and does not share personal data for cross-context behavioral advertising or similar purposes as defined under applicable privacy laws.

**6. Cookies and Tracking Technologies**\
We use cookies and similar technologies to:

* enable website functionality;
* maintain session authentication;
* remember preferences;
* measure website performance;
* analyze engagement and traffic patterns;
* measure which adverts bring visitors to our website;
* debug and secure the platform.

We use strictly-necessary cookies to operate our websites and Services.\
Where required by applicable law (e.g., EEA, UK), we use analytics and marketing cookies only with your prior consent.\
You may change or withdraw your cookie preferences at any time through our cookie banner or settings link available on our website.\
For more information, see our Cookie Policy.

**Categories of Cookies We Use**

* Strictly necessary cookies
* Performance and analytics cookies
* Functional cookies
* Marketing cookies (where permitted)

Where legally required, we obtain consent before placing non-essential cookies.

**Advertising Measurement**\
When you consent to advertising cookies, we record which advert or campaign brought you to our website, so we can tell which advertising is worth paying for. The advertising partners involved are Google Ads (Google LLC) and Meta Pixel (Meta Platforms, Inc).

Advertising is a separate choice in our cookie banner, so you may accept analytics while refusing advertising.\
If your browser sends a Global Privacy Control signal, we treat it as refusing advertising and place no advertising cookies, regardless of where you are located.

**7. International Data Transfers**\
Molin AI is based in the United Kingdom, and some of our service providers and sub-processors may be located in other countries.\
We take steps to ensure that any international transfers comply with applicable data protection laws.

**7.1 Data Transfers Outside the United Kingdom**\
When data is transferred to a country without a UK adequacy regulation, we rely on appropriate safeguards, including:

* the UK International Data Transfer Addendum to the EU Standard Contractual Clauses;
* the EU Standard Contractual Clauses (2021) as recognized by UK law;
* or another mechanism permitted under the UK GDPR.

For Customer Personal Data, these safeguards are set out in the DPA, which prevails where there is any inconsistency.

**7.2 Data Transfers from the EEA**\
If personal data originating from the EEA is transferred to a non-EEA country, we rely on:

* the 2021 EU Standard Contractual Clauses (“SCCs”);
* European Commission adequacy decisions;
* appropriate technical and organizational measures.

Where Molin AI acts as a Processor, the DPA governs these transfers.

**7.3 Data Transfers from Switzerland**\
For personal data subject to the Swiss Federal Act on Data Protection (FADP):

* we use the EU SCCs with Swiss-specific modifications (e.g., references to Swiss authority, Swiss law).

This is also incorporated into the DPA for Customer Personal Data.

**7.4 Transfers to the United States**\
Some of our sub-processors and service providers may be located in the United States.\
Where applicable, we rely on:

* the provider’s certification under the EU–U.S. Data Privacy Framework (“DPF”), the UK Extension to the DPF, or the Swiss–U.S. DPF; or
* Standard Contractual Clauses together with the UK Addendum.

We may rely on DPF-certified sub-processors.

**7.5 Relationship With the DPA**\
For Customer Personal Data, the DPA contains the binding transfer mechanisms, including:

* SCCs
* UK Addendum
* Swiss modifications
* safeguards and supplementary measures

If this Privacy Policy and the DPA conflict regarding processing done in the Processor role, the DPA controls.

**8. Retention of Personal Data**\
We retain personal data only for as long as necessary to fulfil the purposes described in this Policy or as required by law.

**8.1 Retention of Data Where We Act as Controller**\
We retain personal data only for as long as necessary for the purposes described in this Privacy Policy, including:\
**Account & Billing Data**\
Kept until your account is closed, and thereafter for a period required to comply with legal and tax obligations, typically not exceeding 6 years unless a longer period is required by law.\
**Website & Analytics Data**\
Retained for a limited period based on our analytics systems and operational needs.\
**Security Logs**\
Typically retained **90–365 days**, depending on log purpose and threat monitoring requirements.\
**Marketing Data**\
Kept until you unsubscribe or request deletion, or until we determine that the data is no longer needed.\
We maintain suppression lists to record opt-outs.\
**Molin Account Data** — retained until the End User deletes their Molin Account or requests deletion, after which data is deleted without undue delay.

**8.2 Retention of Customer Personal Data (Processor Role)**\
Retention of Customer Personal Data is determined by Customer configuration and the DPA:

* Customers decide how long conversation history, channel logs, AI Agent data, and workflow data are retained (where configurable).
* Molin AI retains Customer Personal Data only for the duration of the Customer’s subscription and as permitted by the DPA.
* Where the Customer requests deletion, Molin AI deletes Customer Personal Data without undue delay and within 60 days.
* Upon account termination, if no instruction is received, Customer Personal Data is automatically deleted from active systems within 90 days of account termination.
* Copies in backup systems are overwritten in the ordinary course of backup rotation and deleted within 30–45 days thereafter (and in any case no later than 90 days).

**9. Security**\
Molin AI implements appropriate technical and organizational measures to protect personal data against loss, misuse, unauthorized access, disclosure, alteration, or destruction.\
These measures include, but are not limited to:\
**Technical Measures**

* encryption in transit and at rest,
* secure TLS communication channels,
* role-based access control,
* multi-factor authentication for internal systems,
* network segmentation and firewalls,
* secure credential hashing and password storage,
* automated monitoring for abuse and anomalies.

**Organizational Measures**

* employee confidentiality obligations,
* role-based access permissions,
* background checks where legally permitted,
* mandatory privacy and security training.

**Operational Measures**

* audit logging,
* vulnerability scanning and patch management,
* incident detection and response procedures,
* disaster recovery and business continuity plans.

For Customer Personal Data, more detailed information about our technical and organizational measures (“TOMs”) is set out in Annex 2 of the DPA.

**10. Your Rights**\
Individuals have the following rights regarding their personal data, subject to applicable law:

**10.1 Rights Under UK/EU GDPR**

* Right of access – to request copies of your personal data.
* Right to rectification – to correct inaccurate or incomplete data.
* Right to erasure – to request deletion in certain circumstances.
* Right to restriction – to limit processing where legally allowed.
* Right to data portability – to receive certain data in machine-readable form.
* Right to object – to object to processing based on legitimate interests or for direct marketing.
* Right not to be subject to certain automated decisions – to require human review for decisions that have significant effects.
* Right to withdraw consent — where you have enabled cross-site recognition for your Molin Account, you may withdraw consent at any time through your account settings.

To exercise your rights, contact us at: [privacy@molin.ai](mailto:privacy@molin.ai)\
We may need to verify your identity before responding.

**10.2 Additional Rights for U.S. Residents (U.S. State Laws)**\
Residents of certain U.S. states (including California, Colorado, Virginia, Connecticut, Utah, and others) may have additional rights under applicable privacy laws, such as:

* right to access and delete personal information;
* right to correct inaccuracies;
* right to opt out of the sale or sharing of personal information;
* right to opt out of targeted advertising;
* right to limit the use of sensitive personal information.

Requests may be submitted to [privacy@molin.ai](mailto:privacy@molin.ai)\
These rights apply only to residents of applicable U.S. states and do not apply to Customer Personal Data handled under the DPA.

**10.3 Rights Concerning Customer Personal Data (Processor Role)**\
If you interact with a Customer’s AI Agent or channels:

* Molin AI processes your data on behalf of the Customer;
* Molin AI cannot directly modify or delete this data without the Customer’s instruction;
* We will forward your request to the applicable Customer whenever possible.

You may also contact the Customer directly.

**10.4 Complaints**\
You may lodge a complaint with:\
**United Kingdom**\
Information Commissioner’s Office (ICO) – [https://ico.org.uk](https://ico.org.uk)\
**European Union**\
List of supervisory authorities – [https://edpb.europa.eu/about-edpb/board/members\_en](https://edpb.europa.eu/about-edpb/board/members_en)\
If you have concerns, we encourage you to contact us first so we can address them.

**11. Children’s Data**\
Molin AI’s Services are designed for business and professional use and are not intended for children or individuals under the age of digital consent as defined by applicable law (typically 13–16 years old).

* We do not knowingly collect or process children’s personal data.
* If we learn that we have inadvertently collected personal data of a child, we will take reasonable steps to delete it as soon as possible.
* Customers are responsible for ensuring that their own use of the Services, including AI Agent interactions and omnichannel communications, does not target children unless they comply with all applicable laws governing the processing of children’s data.

**12. Changes to this Privacy Policy**\
We may update this Privacy Policy from time to time to reflect changes to our Services, technologies, legal requirements, or privacy practices.

**12.1 How We Notify You**\
If we make material updates, we will provide notice through one or more of the following:

* post the updated version on our website;
* through the Service;
* notify Customer administrators by email or through in-Service notifications (where appropriate);
* or by other appropriate means;

**12.2 Effective Date**\
Unless a different date is stated in the notice, updates to this Privacy Policy become effective when the updated version is posted.\
Your continued use of the Services after the effective date constitutes acceptance of the updated Policy.\
Where applicable law requires consent for specific changes, we will seek that consent separately.

**13. Contact Us**\
If you have questions or concerns regarding this Privacy Policy or our privacy practices, you may contact us at:\
**Molin AI Ltd**\
Email: [**privacy@molin.ai**](mailto:privacy@molin.ai)\
Address: 124 City Road, London, EC1V 2NX, England\
Website: [**https://molin.ai**](https://molin.ai)\
If you are an end-user interacting with a Customer’s AI Agent or communication channel, please direct any rights requests or privacy questions to the Customer, as they are the Controller of that data. We will assist the Customer where required by law or the DPA.

**Appendix A — Glossary**\
This Glossary supplements the Policy by clarifying key terms.\
Where a term is defined in the **Molin AI Data Processing Addendum (“DPA”)**, the definition in the DPA prevails.\
**“Account Data”**\
Information associated with Customer accounts and administrator users, including email addresses, authentication credentials (hashed), role assignments, workspace configuration, and billing contacts.\
**“AI Agent Data”**\
Prompts, user messages, AI-generated responses, conversation context, uploaded documents, and workflow-related information processed by Molin AI on behalf of a Customer.\
**“Controller”**\
The entity that determines the purposes and means of processing personal data. Molin AI acts as a Controller only for specific categories of data (e.g., website, account, analytics, security).\
**“Customer”**\
An organization that subscribes to or uses Molin AI Services and controls how Customer Personal Data is processed.\
**“Customer Personal Data”**\
Personal data processed by Molin AI as a Processor on behalf of the Customer through chat, social messaging, email, phone, SMS, or AI Agent interactions.\
**“End User”**\
An individual who interacts with a Customer’s AI Agent or communication channel.\
**“Personal Data”**\
Information relating to an identified or identifiable individual, as defined under applicable data protection laws.\
**“Processing”**\
Any operation performed on personal data, including collection, storage, structuring, transmission, retention, deletion, disclosure, or analysis.\
**“Services”**\
The Molin AI platform and related features, including AI Agents, workflows, dashboards, analytics, and all supported communication channels (chat, social messaging, email, phone, SMS).


# Promotional Terms
Source: https://docs.molin.ai/legal/promotional-terms

General terms and conditions governing promotional offers, discounts, and introductory pricing for Molin AI services.

*Last updated: 26.03.2026*

## 1. Scope

These Promotional Terms ("Terms") apply to all promotional offers, discounts, introductory pricing, coupons, and similar incentives ("Promotions") made available by Molin AI Ltd ("Molin AI", "we", "us") in connection with our Services, unless a specific Promotion expressly states otherwise in writing. These Terms supplement the [Terms of Service](/legal/terms-of-service) and, where applicable, any Order Form. In the event of a conflict between these Terms and a specific Promotion's stated terms, the specific Promotion's terms prevail.

## 2. Eligibility

a) Unless explicitly stated otherwise on the Pricing Page or in the applicable Promotion materials, all Promotions are available exclusively to **new customers** who have not previously held a paid subscription to any Molin AI service.

b) A customer who has previously held a paid subscription and subsequently cancelled, downgraded to a free plan, or otherwise ceased paying is **not** eligible for new-customer Promotions upon resubscribing.

c) Eligibility is determined at the **team level**. If any member of a team (as defined in the Terms of Service) has previously held a paid subscription, no member of that team qualifies as a new customer for the purposes of these Terms.

## 3. Scope of Promotional Pricing

a) Unless explicitly stated otherwise on the Pricing Page or in the applicable Promotion materials, any promotional or introductory pricing applies to **one (1) chatbot or subscription per team only** — not to all chatbots, widgets, or subscriptions within a team's account.

b) Any additional chatbots, widgets, or subscriptions created by the same team during the promotional period are billed at the standard rates published on the Pricing Page.

c) Promotional pricing does not carry over to additional products, services, or plan upgrades unless expressly stated.

## 4. Duration and Renewal

a) Promotional pricing applies for the period stated in the Promotion materials. If no period is stated, the Promotion applies to the **first billing cycle only**.

b) Upon expiration of the promotional period, the subscription automatically renews at the then-current standard pricing published on the Pricing Page, unless the customer cancels before the end of the promotional period.

## 5. Abuse and Correction

a) If promotional pricing is applied in error due to a system issue, billing defect, or any other technical or administrative mistake, Molin AI reserves the right to correct the billing to reflect the standard pricing that should have applied, effective from the date the error occurred.

b) Molin AI reserves the right to revoke, suspend, or claw back any Promotion where the customer does not meet the eligibility criteria set out in these Terms, whether or not the Promotion was applied automatically by our systems.

c) Molin AI may, in its sole discretion, take any action it considers appropriate in response to abuse or exploitation of a Promotion, including but not limited to: reversing discounts, billing the difference at standard rates, suspending Services, or terminating the customer's account.

## 6. Non-Transferable and Non-Combinable

a) Promotions are non-transferable and may not be resold, shared, or assigned to another party.

b) Promotions cannot be combined with other offers, discounts, or credits unless expressly stated.

## 7. Modifications

Molin AI reserves the right to modify, suspend, or discontinue any Promotion at any time without prior notice. Changes will not affect Promotions already applied to an active subscription during its current promotional period.

## 8. Governing Law

These Terms and any dispute arising out of or in connection with them shall be governed by and construed in accordance with the laws of England and Wales.

## 9. Contact

If you have questions about a Promotion or believe a Promotion has been applied incorrectly, please contact us at: Molin AI Ltd, 124 City Road, London, England, EC1V 2NX, United Kingdom, or via your Molin AI dashboard.


# Referral Terms
Source: https://docs.molin.ai/legal/referral-terms

The terms of the Molin AI referral promotion, including who can take part, how rewards are earned, and when they're paid out.

*Last updated: 11.07.2024*

## What is the Promotion about?

Molin AI is offering its existing customers on any Molin AI plan the opportunity to earn a referral reward in the form of cash credited to their Molin AI subscription of their premium subscription (the “**Reward**”), by referring someone (the “**Invitee**”) to sign up for a Molin AI Premium account (the “**Promotion**”). All the Invitee will need to do is complete the steps set out in these terms and conditions (the “**Terms**”). Anyone who has received an invitation to the Promotion directly from us in the Molin AI dashboard (an “**In-app Referral Invite**”) is eligible to refer someone. We’ll also send you an email to the email registered with your Molin AI account setting out everything you need to know (unless you’ve asked us not to send you Molin AI marketing emails).

The Promotion will be available for a specific time frame, determined in the In-app Referral Invite. We call this the “**Promotion Period**”. Any Reward will only be paid if all the criteria in these Terms are met by both the selected Molin AI customer and their Invitee during the Promotion Period. Sometimes an Invitee may have longer than the Promotion Period to complete the relevant steps - if this applies, the specific date will be confirmed in the In-app Referral Invite.

The terms and conditions that apply to the Promotion are made up of these Terms and the information included in the In-App Referral Invite (the “**Promotion Terms**”).

You must comply with these Promotion Terms and the terms that apply to your Molin AI account at all times when participating in the Promotion.

## What do you need to do to earn a Reward?

Once you receive an In-app Referral Invite, the following steps must be completed:

* Invite someone to join Molin AI, by either tapping on the “Refer” button displayed in the referral tile in the top of the screen of your Molin AI dashboard, or in the follow up email from us.

* Once you do this, a draft email containing your unique referral link will appear. You can customise the message and send it to your Invitee/s.

* Each Invitee must click on your unique link for you to be eligible for the Promotion.

We’ll confirm the maximum number of people you can refer as part of the Promotion in the In-app Referral Invite. If you refer more people than this, you will not be paid any Rewards for these additional Invitees even if they complete the relevant steps successfully.

The amount of the Reward will be paid to either in the form of Molin AI credits or cash via Wise or PayPal. All details regarding the amount of the Reward for each referral will be set out in the In-app Referral Invite.

## Reward amounts

### **Referee rewards**

The reward amount is contingent upon the specific Molin AI premium plan selected by the Invitee. The Referee shall receive a fixed payment corresponding to the plan purchased by the Invitee, as detailed in the table below.

### **Invitee discount**

The Invitee will receive a 10% discount on their first purchase of any paid Molin AI plan.

Earned rewards will be sent to the Referee's bank account after 31 days from the completion of the required steps. These steps include the successful purchase and confirmation of the selected Molin AI plan by the Invitee.

### **Reward Payment**

Earned rewards will be disbursed to the Referee's designated bank account after a period of thirty-one (31) days from the completion of the requisite steps. These steps include the successful purchase and subsequent confirmation of the selected Molin AI plan by the Invitee. While the Referee is entitled to invite an unlimited number of individuals, they shall only be eligible to receive rewards for the first ten (10) referrals during the Promotional Period. Consequently, in the event that the Referee invites twenty (20) individuals, rewards will only be allocated for the initial ten (10) referrals.

## What does your Invitee need to do for you to earn the Reward?

For you to be eligible for your Reward, your Invitee must satisfy the below steps before the date set out in the In-app Referral Invite:

* **Successfully open a Molin AI account for a shop**, for the first time, using your unique referral link. (Someone who has previously signed up for a Molin AI account will not earn you a Reward).

* **Create an AI chatbot for their online shop.** The Invitee must create an AI chatbot for the online shop they own with at least 1 successful product downloaded by Molin AI. Their online shop must have been created before the start of the Promotion Period.

* **Embed the AI chatbot on their online shop's website.** The invitee must embed the AI chatbot in their website and have at least 1 AI conversation with the embedded chatbot. The chatbot must be embedded into the same website as it was created for.

* **Upgrade to any of the premium Molin AI plans.** The invitee must upgrade to any of the paid Molin AI plans and pay for the plan after the free trial period.

You will not be paid a Reward (or may have a Reward that has been previously paid reversed) if your Invitee reverses one of these steps after taking it. For example, if they close their Molin AI account within 30 days of opening it, delete or remove their chatbot from their shop’s website, cancel their subscription, or refund their purchase.

## What other legal information should I know?

1. The Promotion is a two-sided campaign, where the Molin AI customer who was invited to refer a friend (not the Invitee) can be awarded Reward/s and the Invitee will be awarded a flat discount on their first purchase.

2. We reserve the right to change these Terms at any time without prior notice.

3. We reserve the right to reverse any Reward/s credited to your Molin AI  account if we become aware that you have breached these Promotion Terms.

4. If we believe that you have engaged in any fraud or material abuse of the Promotion we may also in our sole discretion take any actions we see fit in the circumstances. For example, it would be a material abuse of the Promotion to orchestrate a campaign to profiteer from the Promotion in a way that does not result in genuine and unique new sign-ups to Molin AI, and so in addition to reversing any Reward/s we may also close your Molin AI account.

5. We may change, suspend or end the Promotion earlier than the end of the Promotion Period if, in our reasonable opinion, the Promotion is being abused or may negatively affect Molin AI’s goodwill or reputation, or due to unforeseen circumstances which may make it impossible for us to continue running the Promotion. We may suspend or end the Promotion on an individual or promotion-wide basis.

6. If we need to change, suspend or end the Promotion before the end of the Promotion Period, we will try to give you notice through the dashboard and/or email. Molin AI will not be liable for any loss, whether directly or indirectly suffered where we are unable to continue running the Promotion as planned. Please contact Support if you believe you qualify for a particular benefit in relation to the Promotion that has not been awarded to you as a result of early suspension or termination.

7. By participating in this Promotion, you confirm that you understand that any Reward may be subject to local income tax in the country of your residence and/or in the local territory where you are tax resident. It is entirely your responsibility to pay any tax which may arise from receiving any Reward. Molin AI will bear no liability for any tax obligations which may arise from receiving any Reward as part of this Promotion.

8. The terms contained in this specific document are published in English. If they are translated into another language, unless otherwise specified, the translation is for reference only and the English language version applies and can be used in legal proceedings.

9. Any personal data processed or controlled during the Promotion will be dealt with in line with the Molin AI Privacy Policy that applies to your Molin AI account.

10. These Terms and any dispute or claim arising out of, or in connection with it, its subject matter or formation shall be governed by, and construed in accordance with, the laws of England and Wales.

11. The Promotion is organised and offered by Molin AI LTD (company number: 15076115). If you have a complaint about the Promotion, please raise it directly with us at the following address: Molin AI LTD, 124 City Road, London, England, EC1V 2NX, United Kingdom.


# Sample Wording for Your Privacy Policy
Source: https://docs.molin.ai/legal/sample-wording-for-pp

Sample privacy policy wording you can adapt to describe how your shop uses Molin AI to handle customer conversations.

We’ve developed the following message to support customers seeking sample language for what they might want to put into their Privacy Policy about the use of Molin's Shop AI widget integration on their website.

<Note>
  **Disclaimer**: This is our standard template to be used in your website privacy policy and designed to aid compliance with data protection legislation. As many local and jurisdictional regulations
  are emerging on a regular basis, the information contained in the template may not reflect the most current legal developments in your jurisdictions. Only qualified and dedicated legal expertise can
  guarantee that your privacy policy is compliant with the laws applicable. If you are not sure about any legal questions or have any questions or doubts about our template, you should consult with a
  lawyer or law firm specialized in digital communications law.
</Note>

## English version:

*"We have integrated Molin, our advanced AI customer service assistant, to better understand and cater to our users' needs, ensuring an optimized service experience. Molin leverages cutting-edge technology to gain insights into user interactions, preferences, and feedback. This enables us to continuously improve and tailor our service to meet your expectations. As part of Molin's functionality, it may utilize cookies and other technologies to collect data on user behavior and device information. This includes de-identified data such as device IP address, screen size, device type, browser information, geographic location (limited to country), and preferred language settings. Rest assured, all this information is securely stored in a pseudonymized user profile, and Molin AI strictly adheres to contractual obligations that prohibit the sale of any collected data. Our primary focus is to provide you with exceptional customer service while safeguarding your privacy and ensuring a seamless user experience.*

*For further details, please contact us via email* [*here*](mailto:hey@molin.ai)*.”*

## German version:

*"Wir haben Molin, unseren fortschrittlichen KI-Kundenservice-Assistenten, integriert, um die Bedürfnisse unserer Nutzer besser zu verstehen und auf sie einzugehen und ein optimiertes Serviceerlebnis zu gewährleisten. Molin nutzt modernste Technologie, um Einblicke in die Interaktionen, Vorlieben und das Feedback der Nutzer zu gewinnen. So können wir unseren Service kontinuierlich verbessern und an Ihre Erwartungen anpassen. Als Teil der Funktionalität von Molin können Cookies und andere Technologien verwendet werden, um Daten über das Nutzerverhalten und Geräteinformationen zu sammeln. Dazu gehören anonymisierte Daten wie IP-Adresse des Geräts, Bildschirmgröße, Gerätetyp, Browserinformationen, geografischer Standort (beschränkt auf das Land) und bevorzugte Spracheinstellungen. Seien Sie versichert, dass all diese Informationen sicher in einem pseudonymisierten Benutzerprofil gespeichert werden und Molin AI sich strikt an die vertraglichen Verpflichtungen hält, die den Verkauf der gesammelten Daten untersagen. Unser Hauptaugenmerk liegt darauf, Ihnen einen außergewöhnlichen Kundenservice zu bieten und gleichzeitig Ihre Privatsphäre zu schützen und ein nahtloses Nutzererlebnis zu gewährleisten.*

*Für weitere Informationen kontaktieren Sie uns bitte per E-Mail* [*hier*](mailto:hey@molin.ai)*.”*

## Hungarian version:

*"Integráltuk Molin-t, a fejlett AI ügyfélszolgálati asszisztensünket, hogy jobban megértsük és kielégítsük felhasználóink igényeit, és optimális szolgáltatási élményt biztosítsunk. A Molin fejlett technológiát használ, hogy betekintést nyerjen a felhasználói interakciókba, preferenciákba és visszajelzésekbe. Ez lehetővé teszi számunkra, hogy folyamatosan javítsuk és az Ön elvárásainak megfelelően alakítsuk szolgáltatásunkat. A Molin funkcióinak részeként cookie-kat és más technológiákat használhat a felhasználói viselkedésre és eszközinformációkra vonatkozó adatok gyűjtésére. Ezek közé tartoznak az olyan azonosítatlan adatok, mint az eszköz IP-címe, képernyőméret, eszköztípus, böngészőinformációk, földrajzi elhelyezkedés (országra korlátozva) és a preferált nyelvi beállítások. Biztos lehet benne, hogy ezeket az információkat biztonságosan, álnevesített felhasználói profilban tároljuk, és a Molin AI szigorúan betartja azokat a szerződéses kötelezettségeket, amelyek tiltják az összegyűjtött adatok értékesítését. Elsődleges célunk, hogy kivételes ügyfélszolgálatot nyújtsunk Önnek, miközben megvédjük az Ön adatait és zökkenőmentes felhasználói élményt biztosítunk."*

*További részletekért kérjük lépjen kapcsolatba velünk emailben* [*itt*](mailto:hey@molin.ai)*.”*

## *Polish version:*

*"Zintegrowaliśmy Molin, naszego zaawansowanego asystenta obsługi klienta AI, aby lepiej zrozumieć i zaspokoić potrzeby naszych użytkowników, zapewniając zoptymalizowaną obsługę. Molin wykorzystuje najnowocześniejszą technologię, aby uzyskać wgląd w interakcje, preferencje i opinie użytkowników. Umożliwia nam to ciągłe doskonalenie i dostosowywanie naszych usług do oczekiwań użytkowników. W ramach funkcjonalności Molin może wykorzystywać pliki cookie i inne technologie do gromadzenia danych o zachowaniu użytkownika i informacji o urządzeniu. Obejmuje to dane niezidentyfikowane, takie jak adres IP urządzenia, rozmiar ekranu, typ urządzenia, informacje o przeglądarce, położenie geograficzne (ograniczone do kraju) i preferowane ustawienia językowe. Zapewniamy, że wszystkie te informacje są bezpiecznie przechowywane w pseudonimizowanym profilu użytkownika, a Molin AI ściśle przestrzega zobowiązań umownych, które zabraniają sprzedaży jakichkolwiek zebranych danych. Naszym głównym celem jest zapewnienie wyjątkowej obsługi klienta przy jednoczesnej ochronie prywatności i zapewnieniu płynnego doświadczenia użytkownika.*

*Aby uzyskać więcej informacji, skontaktuj się z nami za pośrednictwem poczty elektronicznej* [*tutaj*](mailto:hey@molin.ai)*.”*

## *Romanian version:*

*"Am integrat Molin, asistentul nostru avansat de servicii pentru clienți cu inteligență artificială, pentru a înțelege și a răspunde mai bine nevoilor utilizatorilor noștri, asigurând o experiență de servicii optimizată. Molin valorifică tehnologia de ultimă oră pentru a obține informații despre interacțiunile, preferințele și feedback-ul utilizatorilor. Acest lucru ne permite să îmbunătățim continuu și să ne adaptăm serviciul pentru a răspunde așteptărilor dumneavoastră. Ca parte a funcționalității Molin, aceasta poate utiliza module cookie și alte tehnologii pentru a colecta date privind comportamentul utilizatorului și informații despre dispozitiv. Acestea includ date neidentificate, cum ar fi adresa IP a dispozitivului, dimensiunea ecranului, tipul dispozitivului, informații despre browser, locația geografică (limitată la țară) și setările limbii preferate. Fiți siguri că toate aceste informații sunt stocate în siguranță într-un profil de utilizator pseudonimizat, iar Molin AI aderă strict la obligațiile contractuale care interzic vânzarea oricăror date colectate. Obiectivul nostru principal este să vă oferim servicii excepționale pentru clienți, protejându-vă în același timp confidențialitatea și asigurând o experiență de utilizare fără probleme.*

*Pentru detalii suplimentare, vă rugăm să ne contactați prin e-mail* [*aici*](mailto:hey@molin.ai)*.”*


# Visibility into Molin’s security practices
Source: https://docs.molin.ai/legal/security-practices

Learn about Molin AI security measures, including data protection, access controls, compliance, and security best practices.

This document highlights Molin’s security practices to provide insight into how we ensure security by design.

## Safeguarding Customer Data

Molin AI's Security team is responsible for implementing and managing our security program. The primary focus of Molin AI’s security program is to prevent unauthorized access, use, and disclosure of customer data. Our security program continuously evolves in accordance with industry best practices.

## Security Compliance

Molin AI constantly monitors and enhances the design and effectiveness of our security controls. We collaborate with a reputable third party for their independent assessment of our efforts. All internal and external audit findings are shared with executive management.

# Molin AI's Responsibility

## Access Control

In provisioning access, IT adheres to the principles of least privilege and role-based access control, meaning employees are only authorized the access and permissions necessary to fulfill their job responsibilities. User access reviews, including production access, are performed semi-annually. Access to the production infrastructure and supporting systems requires Multi-Factor Authentication (MFA).

Employee access is revoked instantly upon an employee's termination. In cases of involuntary termination, access is revoked immediately.

## Cloud Hosting

Molin AI uses Cloudflare as its cloud hosting provider. Molin AI’s corporate offices do not host any data closets or servers; all data is stored in the US and Western Europe region. Molin AI employs serverless instances across Cloudflare to ensure high availability of all services.

## Data Retention

Molin AI retains data for the duration of the customer's use of the application. Customer data is removed upon request for user account deletion or upon customer contract termination. Molin AI's hosting provider, Cloudflare is responsible for ensuring proper sanitization of disks and physical media.

## Encryption

Molin AI encrypts all customer data at rest and in transit using robust encryption methods. All data is transmitted via HTTPS using TLS1.2+ with AES256 encryption and SHA2 signatures, defaulting to TLS1.3 based on client capability. All values are encrypted at rest with 256-bit AES-GCM, and only decrypted by the process executing our Worker scripts or responding to our API requests.

Encryption keys are managed by and stored securely within Cloudflare. Access to encryption keys is restricted to limited, authorized personnel and requires MFA. All key usage is logged and monitored for anomalous activity.

## Endpoints

Employees are provided with company-managed workstations. These workstations are configured with disk encryption, anti-malware, and idle lockout. IT monitors employee workstations to ensure compliance with corporate policy and up-to-date patches.

## Logging

Centralized logging is enabled for all production systems. Logs are reviewed for indications of compromise and alerted upon. The Security team is responsible for monitoring alert thresholds, tracking security events to resolution following the incident response plan.

## Network

Molin AI's firewalls are configured to deny all incoming traffic by default. Firewall rules are reviewed at least annually. Alerts generated by the Intrusion Detection System (IDS) are sent to on-call personnel for investigation and triage. Molin AI also utilizes a WebApplication Firewall (WAF) and Content Delivery Network (CDN) to protect against common web application vulnerabilities, such as Distributed Denial of Service (DDoS) attacks, and provide faster access to the application.

## Personnel

The security of the Molin AI environment is the responsibility of all Molin AI employees, contractors, and temporary workers who have access to Molin AI's information systems. All employees must have a completed background check on file before starting, in addition to signing confidentiality agreements.

All employees are required to complete security awareness training upon hire and annually thereafter. The training curriculum includes phishing awareness, remote work best practices, device security, and incident reporting. In addition to completing training, employees are required to review the employee handbook and code of conduct policy. Violations of any corporate policies may result in disciplinary measures up to and including termination.

## Secure Development

Molin AI has built a secure software development lifecycle (SDLC) that includes requirements like peer code review. All code is managed in a version control repository, with branch protections in place. Access to source code requires MFA. Security at Molin AI LTD. Non-standard code changes go through a change management process covering emergency changes and hot fixes. The agile process allows engineers to follow their own release cycles, deploying continuous improvements to the Molin AI application.

## Third Parties

Molin AI partners with limited third parties to provide key services. These third parties, are continuously monitored to ensure their security programs continue to meet Molin AI's standards. Molin AI reassesses its third parties annually, including a review of their independent audit reports and penetration test reports. The full list of our third parties are available at [https://help.molin.ai/en/articles/6909497-privacy-policy](https://help.molin.ai/en/articles/6909497-privacy-policy).

## Vulnerability Management

Vulnerability scans are performed daily for in-scope systems. Identified vulnerabilities are remediated in accordance with severity.

## Your Responsibility

Although Molin AI is responsible for most security controls, our customers are responsible for securing their user accounts. This includes creating strong passwords if using Google for authentication, provisioning user accounts and permissions, and disabling accounts as needed.

Additionally, customers are responsible for determining the appropriateness of the data entered into the application. By default, Molin AI handles limited customer Personally Identifiable Information (PII) (name and email). The sensitivity of the data that customers input to generate content is ultimately their responsibility. Customers should be aware that Molin AI is not PCI or HIPAA compliant and should refrain from providing cardholder information and protected health information.

## Conclusion

Securing and maintaining the privacy of customer information is essential to our company's mission. The success of our customers lies at the core of what we do. We hope this insight into our security program helps build and maintain your trust in Molin AI.


# Subprocessors
Source: https://docs.molin.ai/legal/subprocessors

The third-party service providers that process customer data on behalf of Molin AI, what each one does, and where it's located.

*Last updated: 1 Aug 2026*

Molin AI LTD. ("Molin AI", "we", or "our") engages certain third-party service providers ("Subprocessors") to support the delivery of our services. These Subprocessors may process, store, or otherwise access customer information or personal data as necessary to operate and improve the Molin AI platform.

This information is provided in compliance with the UK General Data Protection Regulation (UK GDPR) and the EU General Data Protection Regulation (GDPR), as applicable. Unless otherwise defined here, capitalised terms have the meaning set out in our Terms of Service or in a superseding written agreement between Molin AI and the customer.

Before engaging any Subprocessor, Molin AI performs due diligence to assess their privacy, information security, and data protection practices. We enter into written agreements with all Subprocessors requiring compliance with applicable data protection laws, confidentiality obligations, security controls, and international data transfer safeguards.

Subprocessors are granted access to customer data only to the extent strictly necessary for them to perform their services for Molin AI. They are expressly prohibited from using customer data for any other purpose.

## Current sub-processors

### AI and Machine Learning Services

| Sub-processor                        | Service Type                         | Processing Region | Privacy Policy                                         |
| ------------------------------------ | ------------------------------------ | ----------------- | ------------------------------------------------------ |
| Microsoft Corporation (Azure OpenAI) | AI model hosting and processing      | EU (Europe)       | [link](https://privacy.microsoft.com/privacystatement) |
| Anthropic, Inc.                      | Claude AI language model services    | US                | [link](https://www.anthropic.com/privacy)              |
| OpenAI, L.L.C.                       | GPT model services and AI processing | US                | [link](https://openai.com/privacy/)                    |
| Jina AI GmbH                         | AI-powered web searches              | EU (Europe)       | [link](https://jina.ai/legal/#privacy-policy)          |
| Exa Labs, Inc.                       | AI-powered web searches              | US                | [link](https://exa.ai/privacy-policy)                  |
| Perplexity AI, Inc.                  | AI-powered web searches              | US                | [link](https://www.perplexity.ai/privacy)              |

### Cloud Infrastructure and Hosting

| Sub-processor               | Service Type                      | Processing Region    | Privacy Policy                                                            |
| --------------------------- | --------------------------------- | -------------------- | ------------------------------------------------------------------------- |
| Cloudflare, Inc.            | Cloud infrastructure and services | US/EU (multi-region) | [link](https://www.cloudflare.com/trust-hub/privacy-and-data-protection/) |
| Amazon Web Services (AWS)   | Cloud infrastructure and services | EU (Europe)          | [link](https://aws.amazon.com/privacy/)                                   |
| Google Cloud Platform (GCP) | Cloud infrastructure and services | EU (Europe)          | [link](https://policies.google.com/privacy)                               |
| DigitalOcean, LLC           | Cloud infrastructure and hosting  | US/EU (multi-region) | [link](https://www.digitalocean.com/legal/privacy-policy)                 |
| Neon, Inc.                  | PostgreSQL database hosting       | US                   | [link](https://neon.tech/privacy-policy)                                  |
| S2 Labs Inc.                | Cloud browser infrastructure      | US                   | [link](https://www.hyperbrowser.ai/privacy-policy)                        |
| FOUNDRYLABS, INC.           | Cloud computing infrastructure    | US                   | [link](https://e2b.dev/privacy)                                           |

### Analytics and Monitoring

| Sub-processor                 | Service Type                       | Processing Region    | Privacy Policy                                      |
| ----------------------------- | ---------------------------------- | -------------------- | --------------------------------------------------- |
| ClickHouse, Inc.              | Analytics database and processing  | US/EU (multi-region) | [link](https://clickhouse.com/legal/privacy-policy) |
| Google LLC (Google Analytics) | Website analytics                  | US/EU (multi-region) | [link](https://policies.google.com/privacy)         |
| PostHog, Inc.                 | Product analytics                  | US                   | [link](https://posthog.com/privacy)                 |
| Grafana Labs                  | Logging, monitoring, observability | US/EU (multi-region) | [link](https://grafana.com/legal/privacy-policy/)   |

### Payment Processing

| Sub-processor | Service Type                   | Processing Region    | Privacy Policy                     |
| ------------- | ------------------------------ | -------------------- | ---------------------------------- |
| Stripe, Inc.  | Payment processing and billing | US/EU (multi-region) | [link](https://stripe.com/privacy) |

### Communication and Support

| Sub-processor                        | Service Type                               | Processing Region | Privacy Policy                                         |
| ------------------------------------ | ------------------------------------------ | ----------------- | ------------------------------------------------------ |
| Stytch, Inc.                         | Authentication and user management         | US                | [link](https://stytch.com/legal/privacy-policy)        |
| Slack Technologies, Inc.             | Internal team communication                | US                | [link](https://slack.com/trust/privacy/privacy-policy) |
| Rewardful, Inc.                      | Referral program management                | US                | [link](https://www.rewardful.com/privacy)              |
| Customer.io (Peaberry Software Inc.) | Customer communication and email marketing | US                | [link](https://customer.io/legal/privacy-policy)       |

### Developer Tools

| Sub-processor | Service Type                       | Processing Region    | Privacy Policy                                                                                   |
| ------------- | ---------------------------------- | -------------------- | ------------------------------------------------------------------------------------------------ |
| GitHub, Inc.  | Source code hosting and CI/CD      | US/EU (multi-region) | [link](https://docs.github.com/en/site-policy/privacy-policies/github-general-privacy-statement) |
| Retool, Inc.  | Internal operations and dashboards | US                   | [link](https://retool.com/privacy)                                                               |

### Productivity & Security

| Sub-processor              | Service Type                    | Processing Region    | Privacy Policy                               |
| -------------------------- | ------------------------------- | -------------------- | -------------------------------------------- |
| Google LLC (Workspace)     | Email and productivity suite    | US/EU (multi-region) | [link](https://policies.google.com/privacy)  |
| 1Password (AgileBits Inc.) | Password and secrets management | US/CA (multi-region) | [link](https://1password.com/legal/privacy/) |

## Updates to Subprocessors

As our business and technical requirements evolve, Molin AI may add or remove Subprocessors, or engage existing Subprocessors to provide additional services.

We will update this page to reflect any such changes. Customers can always view the most current list of Subprocessors here.

If you would like to be notified when this page is updated, please contact us at **[dataprotection@molin.ai](mailto:dataprotection@molin.ai)**.


# Template for your Terms of Service
Source: https://docs.molin.ai/legal/template-terms-wording

A template you can add to your Terms of Service to clarify the limits of AI-generated responses and reduce your liability for AI errors.

<Note>
  **Disclaimer:** This document is provided as a general template. Molin AI LTD. assumes no legal responsibility for its content or use. You should consult with a qualified legal professional to
  ensure it meets your specific business and legal requirements.
</Note>

Template:

# AI Assistant Terms of Use

**\[Insert Your Shop Name]** provides an AI-powered assistant (the “Assistant”) on this website, powered by **Molin AI**. By using the Assistant, you agree to the terms set out below.

These Terms of Use are intended to ensure transparency, outline acceptable use, and inform you of your rights while interacting with the Assistant. Please read them carefully.

***

### 1. Who Provides This Service?

The Assistant is operated by us, **\[Insert Shop Name]**, and powered by **Molin AI**, a service developed by a third-party provider.

You are interacting with an AI tool designed to answer frequently asked questions, assist with product discovery, help with order-related queries, and support your shopping experience on our site.

***

### 2. Nature of Responses

The Assistant generates responses using artificial intelligence and automated systems. While we strive to provide accurate and helpful information, its answers:

* May not always be up-to-date, complete, or correct.
* Should not be considered professional, legal, or medical advice.
* Do **not** replace official customer service or human support.

For critical or unresolved questions, please contact our support team directly at **\[Insert Email or Contact Page Link]**.

***

### 3. Acceptable Use

You agree to use the Assistant responsibly. You may **not**:

* Use offensive, harmful, or illegal language when interacting with the Assistant.
* Attempt to manipulate, reverse engineer, or disrupt the Assistant’s functionality.
* Use the Assistant in any way that violates applicable EU or national laws.

We reserve the right to disable the Assistant for users who misuse it.

***

### 4. Data Protection & Privacy

We take your privacy seriously. When you use the Assistant:

* We do **not** collect or store personal data unless you voluntarily share it (e.g., name, email, order number).
* Any collected data is processed in line with the **EU General Data Protection Regulation (GDPR)**.
* Usage data (like questions asked) may be stored temporarily to improve service quality, but it is not used to identify you personally.

For more details, please review our **\[Privacy Policy link]**.

***

### 5. Age Requirements

The Assistant is not intended for children under **16 years of age**, in accordance with EU data protection rules. If you are under 16, please do not use the Assistant without consent from a parent or guardian.

***

### 6. Disclaimer of Liability

While we aim to provide helpful and accurate information, **\[Insert Shop Name]** is not liable for:

* Any damages or losses arising from reliance on AI-generated content.
* Errors, omissions, or delays in the Assistant’s responses.
* Any consequences resulting from using the Assistant in ways that were not intended.

Use of the Assistant is at your own risk.

***

### 7. Changes to These Terms

We may update these Terms of Use from time to time. The current version will always be available on this page, and continued use of the Assistant constitutes your acceptance of any changes.

***

### 8. Dispute Resolution

If you have a complaint or concern related to the Assistant, please contact us first at **\[Insert Email Address]**. We will do our best to resolve it.

If a dispute arises that we cannot resolve, EU-based consumers may also use the **European Online Dispute Resolution (ODR) platform**, available at:\
[https://ec.europa.eu/consumers/odr](https://ec.europa.eu/consumers/odr)


# Terms of Service
Source: https://docs.molin.ai/legal/terms-of-service

The Molin AI terms of service governing your use of our software-as-a-service products, including billing, acceptable use, and liability.

*Last updated: 22.07.2026*

**Thank you for using Molin AI!**

These Molin AI Terms of Service (this “Agreement”) are entered into by and between **Molin AI Ltd**, a company incorporated in England with company number 15076115 and registered office at 124 City Road, London, EC1V 2NX, England (“Molin”, “Molin AI”, “we”, “us”), and the entity or person accessing or using the Services (“you”). If you access or use the Services on behalf of an organization, you represent and warrant that you have authority to bind that organization to this Agreement; in such case “Customer” refers to that organization.\
This Agreement governs Customer’s access to and use of Molin AI’s software-as-a-service platform, AI Agent functionality, APIs, integrations, and related services (collectively, the “Services”). Customer may purchase subscriptions or additional services under separate ordering documents, online checkouts, or other mutually agreed terms (“Order Forms”). This Agreement, together with any applicable Order Form, forms the complete contract governing the Services.\
The “Effective Date” is the earlier of (a) the date Customer first accesses any part of the Services (including via online trial, provisioning, or registration), or (b) the effective date of the first Order Form referencing this Agreement.

**AI-Specific Terms and Important Disclosures**\
Customer acknowledges that Molin AI’s Services include artificial intelligence and machine-learning functionality, including integrations with third-party large language model (“LLM”) providers. Use of these features is subject to this Agreement, the Documentation, the Privacy Policy, and, where Customer Personal Data is processed, the Data Processing Addendum (“DPA”).\
Certain AI features may involve the transmission of Customer inputs to LLM providers to generate Outputs. These providers act as Sub-processors under the DPA, and are contractually prohibited from using Customer Personal Data to train their models. Customer remains responsible for reviewing and validating AI-generated Outputs before relying on them.

**End-User Molin Account**\
End Users may optionally create a Molin Account, enabling them to store preferences, maintain persistent interaction history, and be recognized across Customer websites or applications that use Molin AI. Customer acknowledges that Molin Account data is distinct from Customer Data and cannot be accessed by Customer except as enabled by the Services.

**Modifications to this Agreement**\
Molin AI may update these Terms from time to time. Unless a different effective date is stated, updates become effective as soon as they are posted or communicated to Customer. Molin AI will provide reasonable notice of any material updates through the Service, by email to Customer administrators, or by other appropriate means.\
If an update materially and adversely affects the Customer, the Customer may terminate the affected Order Form by providing written notice before the effective date. Continued use of the Service after the effective date constitutes acceptance of the updated Terms.

**Acceptance of Terms**\
BY ACCESSING OR USING THE SERVICES, OR BY INDICATING ACCEPTANCE, YOU AGREE TO BE BOUND BY THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT ACCESS OR USE THE SERVICES. THIS AGREEMENT IS LEGALLY BINDING.

# 1. Definitions

For purposes of this Agreement, the following terms have the meanings set forth below. Additional terms may be defined elsewhere in this Agreement. In the event of conflict between this Agreement and the DPA with respect to Customer Personal Data, the DPA prevails.

“Affiliate” - means any entity under the control of Customer where “control” means ownership of or the right to control greater than 50% of the voting securities of such entity.

“AI Agent” - a conversational, automated, or workflow-driven agent created or configured by Customer using the Services, which may use machine learning, natural language processing, or large language models to generate responses or perform actions based on Customer-provided instructions, configurations, and data.

“Applicable Law” - all laws, regulations, and rules applicable to a party’s performance or use of the Services, including privacy, data protection, consumer protection laws, and, where applicable, AI-specific regulations.

“Beta Offerings” - services or features identified as alpha, beta, early access, preview, pilot, experimental, or by a similar designation. Beta Offerings may be provided for evaluation purposes only, may be subject to additional terms, and are provided “as is”, without warranty or support.

“Channel Provider” - a third-party messaging, telecom, or communication service provider used to route or deliver messages or calls (e.g., WhatsApp/Meta, SMS and telephony carriers, email providers, or similar platforms).

“Confidential Information” - non-public information disclosed by one party to the other that is designated as confidential or should reasonably be considered confidential under the circumstances.

“Contractor” - any independent contractor, consultant, or similar individual engaged by a party who is authorized to access the Services or a party’s Confidential Information in connection with this Agreement.

“Customer Data” - all data, content, or materials submitted, stored, transmitted, or otherwise processed by or on behalf of Customer through the Services, including End User messages and interactions with Customer’s AI Agents. Customer Data includes Customer Personal Data as defined in the DPA.

“Customer Personal Data” - personal data contained within Customer Data that is processed by Molin AI as a Processor on behalf of Customer in accordance with the DPA.

“Customer Properties” - websites, applications, systems, CRMs, or other properties owned or controlled by Customer and integrated with or connected to the Services.

“Dashboard” - means Molin AI's user interface for accessing and administering the Services that Customer may access via the web or the Molin Apps.

“Documentation” - the technical and functional documentation made available by Molin AI at [https://docs.molin.ai](https://docs.molin.ai) or otherwise provided to Customer.

“DPA” or „Data Processing Addendum” - the Molin AI Data Processing Addendum governing Molin AI’s processing of Customer Personal Data, available at [https://docs.molin.ai/legal/data-processing-addendum](https://docs.molin.ai/legal/data-processing-addendum), which forms part of this Agreement where applicable.

“Effective Date” - the date determined in the introductory section of this Agreement.

“End User” - an individual who interacts with Customer’s AI Agent, engages with Customer Properties where the Services are embedded, or otherwise uses communication channels connected to the Services.

“Feedback” - any suggestions, ideas, improvements, or recommendations provided by Customer or its users relating to the Services.

“Input” - prompts, queries, messages, context, documents, instructions, data, or other information submitted into or processed by the Services by Customer or End Users.

“Intellectual Property Rights” include all valid patents, trademarks, copyrights, trade secrets, moral rights, and other intellectual property rights, as may exist now or hereafter come into existence, and all renewals and extensions thereof, and all improvements to any of the foregoing, regardless of whether any of such rights arise under the laws of any state, country or other jurisdiction.

“LLM Provider” or “AI Model Provider” - a third-party provider of machine learning models, large language models, or generative AI capabilities that Molin AI may use as a Sub-processor to generate Outputs.

“Molin Account” - an optional end-user account offered by Molin AI that allows an End User to store preferences, maintain persistent interaction history, and to be recognized across Customer Properties using the Services.

“Molin Code” - means certain JavaScript code, software development kits (SDKs), application programming interfaces (APIs), other code or libraries provided by Molin for deployment on Customer Properties.

“Molin Integrations” means any integrations and applications created or developed by Molin AI that enable interoperability between the Services and Third-Party Platforms, Customer systems, communication channels, CRMs, or other tools..

“Order Form” - means a written or electronic form referencing this Agreement that is used to order the Services, including, without limitation, an online registration or payment process completed through Molin AI's website. The Order Form may contain details about your order, the applicable service plan, contracted usage quantity (e.g., seats or other usage quantity metric identified in the Order Form) and Subscription Term. Upon execution by the parties (or, in the case of electronic orders, confirmation and placement of the order), each Order Form will be subject to the terms and conditions of this Agreement.

“Output” - any content, responses, messages, summaries, classifications, or other results generated by the Services, including those generated using AI or LLM providers, based on Customer Data, Customer instructions, or End User interactions.

“People” (in the singular, “Person") means Customer's end user customers, potential end user customers, and other users of and visitors to the Customer Properties.

“Permitted User” - means an employee or Contractor of Customer or its Affiliate who is authorized to access the Services under Customer’s account in accordance with this Agreement.

“Sensitive Personal Information” - personal data that is considered sensitive or requires heightened protection under Applicable Law (e.g., patient, medical or other protected health information, biometric identifiers, genetic data, financial account numbers, credit, debit or other payment card data, information about children, or special categories under GDPR).

“Service(s)” - the Molin AI platform and all associated products, features, AI Agent functionalities, APIs, integrations, code, automations, analytics tools, and any additional services provided or made available by Molin AI under this Agreement, including the Dashboard, Molin Code and Molin Integrations.

“Sub-processor” - any third party authorized by Molin AI to process Customer Personal Data on its behalf in accordance with the DPA. The current list is available at [https://docs.molin.ai/legal/subprocessors](https://docs.molin.ai/legal/subprocessors).

“Taxes” - any duties, customs fees, levies, or taxes associated with Customer’s purchase or use of the Services, excluding taxes based on Molin AI’s income.

“Subscription Term” - the period during which Customer is authorized to use the Services, as specified in the applicable Order Form.

"Third Party Messaging App(s)” - means a separate, stand-alone over-the-top (“OTT”) or social messaging platforms (including WhatsApp, Facebook Messenger or similar apps) that enable communication between Customer and End Users through the Services, accessible apart from the generally available Services to which Customer subscribes. A Third Party Messaging App allows Customer to integrate Customer's Molin Integration account(s) with Customer's Third Party Messaging App services account(s). These are a subset of Channel Providers.

"Third-Party Platform(s)” means any software, software-as-a-service, data sources or other products or services not provided by Molin AI that are integrated with or otherwise accessible through the Services.

# 2. Who we are

Molin AI is an AI product development company. Our mission is to turn businesses into 1 person operations and to empower individuals from all backgrounds to create and manage businesses. For more information about Molin AI, please visit [https://molin.ai/about](https://molin.ai/about).

# 3. Molin AI Services

3.1. Services Overview. Molin AI’s Services are a suite of artificial intelligence enabled customer service and sales oriented software-as-a-service solutions offered through an online platform. The Services are designed to enable Customer to manage interactions with People through the entire lifecycle of their relationship.

3.2. Provision of Services. Each Service is provided on a subscription basis for a set term designated on the Order Form (each, a “Subscription Term"). Customer will purchase and Molin AI will provide the specific Services as specified in the applicable Order Form.

3.3. Access to Services. Customer may access and use the Services solely for its own benefit (and for the benefit of People) and in accordance with the terms and conditions of this Agreement, the Documentation and any scope of use restrictions designated in the applicable Order Form (including, without limitation, the usage quantity tracked). Use of and access to the Services is permitted only by Permitted Users. If Customer is given API keys or passwords to access the Services on Molin AI's systems, Customer will require that all Permitted Users keep API keys, user ID and password information strictly confidential and not share such information with any unauthorized person. User IDs and related credentials are granted to individual, named persons and may not be shared. If Customer is accessing the Services using credentials provided by a third party (e.g., Google), then Customer will comply with all applicable terms and conditions of such third party regarding provisioning and use of such credentials. Customer will be responsible for any and all actions taken using Customer's accounts and passwords. If any Permitted User who has access to a user ID is no longer an employee (or Contractor, as set forth below) of Customer, then Customer will promptly delete such user ID and otherwise terminate such Permitted User's access to the Service. Molin AI reserves the right to suspend access to any Services or features (including, without limitation, in-app messaging and integrations with Third Party Platforms and Third Party Messaging Apps) if Customer has exceeded applicable usage limits (if any) or if Molin AI otherwise determines, in its sole discretion, that Customer is using the applicable Service in a manner that has become excessive (e.g., substantially exceeds typical use projections or exceeds usage by similar-sized customers (where customer size is defined by number of AI replies), including, but not limited to, storage and bandwidth consumption) and/or negatively impacts the operability, integrity, or security of the Service until usage is reduced to reasonable levels, as determined by Molin AI and/or such impact is resolved to Molin AI's satisfaction. We may change usage limits at any time, in our sole discretion, without notice.

3.4. Molin Integrations. To the extent Molin AI provides Molin Integrations for use with the Services, subject to all of the terms and conditions of this Agreement (unless otherwise indicated in the specific Molin Integration), Molin AI grants to Customer a limited, non-transferable, non-sublicensable, non-exclusive license during any applicable Subscription Term to use the object code form of the Molin Integrations internally, but only in connection with Customer's use of the Service and otherwise in accordance with the Documentation and this Agreement.

3.5. Molin Code. The right to use the Services includes the right to deploy Molin Code on Customer Properties in order to enable messaging, calling, chat and other functionality and to collect Customer Data for use with the Services as further described herein. Subject to all of the terms and conditions of this Agreement, Molin AI grants to Customer a limited, non-transferable, non-sublicensable, non-exclusive license during any applicable Subscription Term to copy and implement the Molin Code in the form provided by Molin AI on Customer Properties solely to support Customer's use of the Service and otherwise in accordance with the Documentation and this Agreement. Customer must implement Molin Code on the Customer Properties in order to enable the relevant features of the Services. Customer will implement all necessary Molin Code in strict accordance with the Documentation and other instructions provided by Molin AI. Customer acknowledges that any changes made to the Customer Properties after initial implementation of Molin Code may cause the Services to cease working or to function improperly and that Molin AI will have no responsibility for the impact of any such Customer changes.

3.6. Contractors and Affiliates. Customer may permit its employees and Contractors and its Affiliates' employees and Contractors to serve as Permitted Users, provided Customer remains responsible for compliance by such individuals with all of the terms and conditions of this Agreement and any use of the Services by such Permitted Users is for the sole benefit of Customer.

3.7. General Restrictions. Customer will not (and will not permit any third party to): (a) rent, lease, provide access to or sublicense the Services to a third party; (b) use the Services to provide, or incorporate the Services into, any product or service provided to a third party other than the Customer Properties; (c) reverse engineer, decompile, disassemble, or otherwise seek to obtain the source code or non-public APIs to the Services, except to the extent expressly permitted by applicable law (and then only upon advance notice to Molin AI); (d) copy or modify the Services or any Documentation, or create any derivative work from any of the foregoing; (e) remove or obscure any proprietary or other notices contained in the Services and/or on any reports or data printed from the Services (unless otherwise expressly permitted by Molin AI in advance); (f) publicly disseminate information regarding the performance of the Services; (g) or use the Services for competitive analysis purposes.

3.8. Molin APIs. If Molin AI makes access to any APIs available as part of the Services, Molin AI reserves the right to place limits on access to such APIs (e.g., limits on numbers of calls or requests). Further, Molin AI may monitor Customer's usage of such APIs and limit the number of calls or requests Customer may make if Molin AI believes that Customer's usage is in breach of this Agreement or may negatively affect the security, operability, or integrity of the Services (or otherwise impose liability on Molin AI).

3.9. Trial Subscriptions. If Customer receives free access or a trial or evaluation subscription to the Service (a “Trial Subscription"), then Customer may use the Services in accordance with the terms and conditions of this Section (and any other supplemental trial terms agreed by Customer) for a period of fourteen (14) days or such other period granted by Molin AI (the “Trial Period"). Trial Subscriptions are permitted solely for Customer's evaluation to determine whether to purchase a paid subscription to the Services or an upgrade to a service plan. Trial Subscriptions may not include all functionality and features accessible as part of a paid Subscription Term and may be subject to usage limits. If Customer does not enter into a paid Subscription Term prior to the expiration of the Trial Period, this Agreement and Customer's right to access and use the Services will terminate at the end of the Trial Period, except as otherwise set forth herein. If stated in the Order Form for a specific Service or otherwise communicated in advance by Molin AI to Customer, a paid Subscription Term will commence automatically once the Trial Period expires, and Customer will be charged for any continued use of the Services. Molin AI has the right to terminate a Trial Subscription at any time for any reason. NOTWITHSTANDING ANYTHING TO THE CONTRARY IN THIS AGREEMENT, MOLIN AI WILL HAVE NO WARRANTY, INDEMNITY, SUPPORT, SERVICE LEVEL AGREEMENT ("SLA"), OR OTHER OBLIGATIONS WITH RESPECT TO TRIAL SUBSCRIPTIONS.

3.10. Beta Offerings. Customer may choose to use Beta Offerings in its sole discretion. Use of Beta Offerings may be subject to additional terms. Molin AI, in its discretion, may offer a Beta Offering with or without charge. Molin AI reserves the right to start charging and/or modify the pricing for a Beta Offering upon prior written notice to Customer. Beta Offerings may be changed at any time without notice and may not be maintained and/or become generally available. Beta Offerings are to be used for Customer's internal testing and evaluation purposes only. Molin AI will have no liability arising out of or in connection with Beta Offerings and disclaims any warranty, indemnity, support, SLA, or other obligations with respect to its Beta Offerings. CUSTOMER USES BETA OFFERINGS “AS IS” AND AT ITS OWN RISK.

3.11. Molin Account Features. Certain features of the Services may allow End Users to create an optional Molin Account with Molin AI in order to store preferences, maintain persistent interaction histories, or be recognized across Customer Properties where such functionality is enabled. Molin Accounts are provided by Molin AI directly to End Users and are governed by Molin AI’s then-current end-user terms and Privacy Policy.\
As between the parties, Molin AI is an independent Controller for data processed in connection with Molin Accounts. Customer acknowledges that: (a) Molin Accounts are not Customer’s user accounts; (b) Customer has no right to access, export, or delete Molin Account data except as expressly enabled by the Services; and (c) Customer must not require End Users to create a Molin Account in a manner that would violate applicable law or the End User’s agreement with Molin AI.

3.12 Omnichannel AI Agent and Communications Features. a) Omnichannel Functionality. Certain Services include an AI Agent capable of generating automated or assisted responses across supported communication channels, including chat, email, SMS, messaging apps, and voice calls (“Omnichannel AI Agent”). The specific channels enabled for Customer depend on Customer configuration and integrations with Third-Party Messaging Apps or telecom providers. b) Automated Communications. Customer acknowledges that the Omnichannel AI Agent may generate, send, or decline to send communications automatically based on Customer’s workflows, instructions, templates, training data, and business logic. Customer is solely responsible for (i) the configuration of such workflows, (ii) reviewing the appropriateness and legality of automated outputs, and (iii) ensuring that automated communications comply with applicable law, platform rules, and industry standards. c) Delivery and Channel Limitations. Molin AI does not guarantee the delivery, timing, or receipt of any message, call, or email sent through the Services. Delivery may depend on third-party carriers, messaging platforms, telecom networks, spam filters, rate limits, or other systems outside Molin AI’s control. Customer acknowledges that communications may be blocked, throttled, filtered, delayed, or rejected by external platforms or carriers for reasons beyond Molin AI’s control. d) Customer Responsibility for Compliance. Customer is solely responsible for ensuring that its use of the Omnichannel AI Agent complies with all applicable laws, including those governing (i) marketing and consent, (ii) automated calling and messaging, (iii) required disclosures, and (iv) telecom and messaging regulations. Customer must not use the Services to send unsolicited or unlawful communications. e) Platform Rules. Use of Third-Party Messaging Apps and telecom services is subject to the applicable provider’s terms, policies, and approval processes (including template message approvals where required). Customer is responsible for compliance with such rules. f) Voice and Call Features. Where voice call features are enabled, Customer understands that: (i) call quality and availability depend on external telecom networks; (ii) call recordings and transcripts (if enabled) are processed according to the DPA and Privacy Policy; (iii) Customer is responsible for obtaining all legally required notices and consents for recording or transcribing calls. g) Email Channel: The Service may ingest incoming emails and generate AI-assisted draft replies. Drafts are not sent automatically; Customer personnel must review and approve any outbound message. f) Live Agent Takeover: Customers may take over conversations from an AI Agent at any time. Customer is solely responsible for all human-agent communications.

# 4. AI

4.1 Processing by Third Party LLM Providers. When using AI Products, the Third Party LLM Provider acts as a sub-processor of personal data submitted to the AI Product, including personal data that may be contained in Inputs (defined below) or other Customer Data. All personal data processing activities will be governed by the DPA in place between Molin AI and Customer. Third Party LLM Providers process Inputs solely for the purpose of generating Outputs and are contractually prohibited from using Customer Personal Data to train their general-purpose models.

4.2 Location of Processing. If Customer elects to use an AI Product, personal data will be sent to such Third Party LLM Providers in accordance with the DPA, the Privacy Policy, and all applicable transfer mechanisms.

4.3 The Services are not intended for high-risk or safety-critical uses (e.g., medical diagnosis, clinical decision-making, credit or employment decisions, legal determinations). Customers must not configure AI Agents for such purposes unless expressly agreed in writing with Molin AI and compliant with all applicable regulations.

4.4 Inputs and Outputs. Any data, content and information (in any format) submitted to Molin AI by Customer, its Permitted Users and/or People, including, but not limited to, conversation data and queries (including any personal data contained therein) (“Inputs”) and results generated by Molin AI based on such Inputs (“Outputs”) are deemed Customer Data under the Agreement and subject to the rights, restrictions and obligations applicable thereto. Customer will only provide Input (and instruct Molin AI to generate Output) where Customer has the legal right to do so. Third parties may submit information that results in identical or similar outputs to Customer’s Outputs (“Third-Party Results”), and Customer acknowledges that it has no rights in or to any Third-Party Results.\
Subject to Customer’s ownership of Inputs, Customer owns the Output, and Molin AI hereby assigns to Customer any rights, title, and interest it may have in such Output, to the extent permitted by applicable law.

4.5 Accuracy. Artificial intelligence and machine learning models are probabilistic and may generate Output that is incorrect, inaccurate, incomplete, or not reflective of current events, real persons, or real facts. Molin AI continuously improves its Services, but no assurances or guarantees are made regarding the accuracy or appropriateness of any Output.

4.6 Transparency. You will ensure that: (i) People are informed that they are interacting with an AI system, (ii) Output is clearly marked as artificially generated or manipulated where required by applicable law; and (iii) Output is not falsely represented as being human-generated. Customer is solely responsible for ensuring that End Users interacting with Customer’s AI Agents are provided with all legally required notices, including disclosures that interactions may be AI-generated, as required under applicable AI regulations and the Privacy Policy.

4.7 Rights to Use. Customer permits Third Party LLM Provider to use Input and Output or other Customer Data submitted to Molin AI as necessary to provide the AI Product, comply with applicable Laws, and enforce its respective policies (as specified in section 4.8.2). Molin AI contractually restricts Third Party LLM Providers from using Customer Data for training or otherwise improving Third Party LLM Provider's services.

4.8 Restrictions on Use. In addition to any general obligations and restrictions pertaining to Customer's use of Services under the Agreement, Customer represents and warrants that:

4.8.1 Customer will not, nor permit others to, use the Services or any Outputs in violation of these Terms, applicable law, or any third-party terms, policies, or agreements.

4.8.2 Customer will not, nor permit others, to: (i) use Molin AI to develop any models that compete with Molin AI or Third Party LLM Provider; (ii) use any method to extract data, infer model parameters, replicate functionality, or otherwise attempt to discover underlying components of the Services or LLMs (such as model weights, architectures, algorithms), except to the extent such restrictions are contrary to applicable law; or(iii) modify or misuse the Services in a manner inconsistent with the intended use.

4.8.3 Customer is fully responsible for all use of the Services by Permitted Users and People as if such actions were performed by Customer.

4.8.4 Customer will not modify the intended purpose of the Services in a way that may cause them to be considered high-risk or prohibited systems under Applicable AI Legislation, unless expressly permitted in writing by Molin AI.

4.9 Usage Limits. Molin AI may monitor and limit or suspend Customer's usage if Molin AI believes Customer's usage may bypass or circumvent any rate limits (if applicable); negatively affect the security, performance, integrity or commercial viability of any Services; violate this Agreement or third party terms and policies, or otherwise imposes liability on Molin AI.

4.10 Data hosting. Customer will not use the Services to generate Output for the purpose of creating synthetic training data intended to develop or train a substantially similar or competing model or system.

4.11 Ownership of content. As between you and Molin AI, and to the extent permitted by applicable law, you (a) retain your ownership rights in Input and (b) own the Output. We hereby assign to you all our right, title, and interest, if any, in and to Output.

4.12 When you use our Services you understand and agree:

a) Outputs may be incorrect, incomplete, or inappropriate. They should not be relied upon as a sole source of truth or for decisions producing legal or significant effects. Customers are solely responsible for reviewing Outputs for accuracy and appropriateness before use.

b) You must evaluate Output for accuracy and appropriateness for your use case, including using human review as appropriate, before using or sharing Output from the Services.

c) You must not use any Output relating to a person for any purpose that could have a legal or material impact on that person, such as making credit, educational, employment, housing, insurance, legal, medical, or other important decisions about them.

d) Outputs may be incomplete, incorrect, offensive, or otherwise inappropriate, and do not represent Molin AI’s views. References to third-party products or services do not imply endorsement or affiliation.

4.13 Human Access in Customer Workflows. Certain features of the Services (such as reviewing AI-generated email drafts or live chat takeover) are designed to enable Customer personnel to manually view or handle communications. Such manual review is performed solely by Customer and its authorized users.\
Molin AI may permit limited human access to Customer Personal Data solely where necessary to: (i) provide support requested by Customer, (ii) maintain, secure, or improve the Services, (iii) detect or address service errors, incidents, misuse, or abuse, or (iv) comply with legal obligations. All such access is restricted to authorized personnel, logged, and subject to confidentiality and security controls.

4.14. AI Act Compliance. Customer is solely responsible for determining the classification of its use of the Services under the EU Artificial Intelligence Act (e.g., prohibited, high-risk, limited-risk or minimal-risk). Where Customer deploys AI systems built using the Services, Customer acts as the “deployer” under the AI Act and is responsible for meeting deployer obligations (including human oversight, accuracy monitoring, risk controls and user transparency).

Molin AI will provide, upon reasonable request, documentation describing the architecture, intended purpose and relevant safety features of Molin AI-provided AI models and components, to the extent necessary for Customer to meet its obligations.\
Nothing in this Agreement requires Molin AI to support or enable prohibited AI uses or high-risk deployments unless separately agreed in writing.

# 5. Customer Data and Customer Obligations

5.1. Data Processing by Molin AI. All data processing activities carried out as part of the Services will be governed by the Data Processing Addendum (“DPA”), which is incorporated by reference into this Agreement. When Molin AI processes Customer Personal Data as a Processor, Molin AI will comply with the DPA. When Molin AI processes data as a Controller (including in relation to optional Molin Accounts), such processing will be governed by the Privacy Policy.

5.2. Rights in Customer Data. As between the parties, Customer will retain all of Customer's Intellectual Property Rights in and to the Customer Data provided to Molin AI. Subject to the terms of this Agreement, Customer hereby grants to Molin AI a non-exclusive, worldwide, royalty-free right to access, use, transmit, and display Customer Data in order to provide, maintain, support, secure, and operate the Services for Customer. This right also includes the use of Customer Data as necessary for: generating Outputs, providing AI functionality,\
performing safety, security, and abuse prevention activities, and complying with Applicable Law.

5.3. Storage of Customer Data. Molin AI does not provide an archiving service. Retention and deletion of Customer Personal Data are governed exclusively by the DPA. Molin AI may delete Customer Data in accordance with the DPA’s retention schedule and does not guarantee storage beyond the applicable Subscription Term.

5.4. Anonymized Data. Notwithstanding anything to the contrary herein, Customer agrees that Molin AI may use: certain technical, usage, and performance data about Customers and People's use of the Services; and/or Customer Data that has been anonymized so that it no longer contains personal data of People (“Anonymized Data”) to analyze, improve, support and operate the Services during and after the term of this Agreement, and Customer agrees that Molin AI is permitted to anonymize Customer Data for these purposes, provided such anonymization complies with the DPA and Applicable Law\..

5.5. Customer Obligations\
a) In General. Customer is solely responsible for the accuracy, content and legality of all Customer Data. Customer represents and warrants to Molin AI that Customer has all necessary rights, consents and permissions to collect, share and use all Customer Data as contemplated in this Agreement (including granting Molin AI the rights under Section 5.2) and that no Customer Data will violate or infringe: (i) any third party Intellectual Property Rights or, publicity, privacy, or other rights, (ii) any Applicable Law, or (iii) any terms of service, privacy or other policies and/or any other agreements governing the Customer Properties or Customer's accounts with any Third-Party Platforms or Third-Party Messaging Apps. Customer is fully responsible for any Customer Data submitted to the Services by any Person or Permitted User as if submitted by Customer.

b) No Sensitive Personal Information. Except as otherwise expressly agreed between the Parties in writing, Customer specifically agrees not to use the Services to collect, store, process or transmit any Sensitive Personal Information. Customer acknowledges that Molin AI is not a payment card processor and that the Services are not PCI DSS compliant, and Molin AI has no obligations with respect to any Sensitive Personal Information submitted to the Services outside the scope of an applicable written agreement. Customer remains solely responsible for any Sensitive Personal Information submitted to the Services.

c) Compliance with Laws. Customer agrees to comply with all Applicable Laws in its use of the Services. Without limiting the foregoing, Customer will not use the Services to engage in unsolicited advertising, marketing, or other activities that violate anti-spam, telecom, or privacy laws.

d) Disclosures on Customer Properties. Customer acknowledges that the Molin Code causes a unique cookie ID to be associated with each Person who accesses the Customer Properties, which cookie ID enables Molin AI to provide the Services. Customer will include on each Customer Property a link to a privacy policy that discloses the use of Molin Code and any third-party tracking technology, explains - as required by applicable Laws – what data is collected and for what purposes, and describes how such data may be shared with third parties, including Molin AI and Channel Providers. Customer is responsible for obtaining all legally required consents for storing or accessing information on People’s devices (e.g., cookies or similar technologies), for collecting Customer Data, and for enabling AI Agent interactions. As between the parties, Customer bears sole responsibility for compliance with consent and notice requirements.

5.6. Indemnification by Customer. Customer will indemnify, defend and hold harmless Molin AI from and against any and all third party (including, without limitation, People) claims, costs, damages, losses, liabilities and expenses (including reasonable attorneys' fees and costs) arising from or relating to any Customer Data, Customer's use of a Third Party Messaging App, Third-Party Platform or breach or alleged breach by Customer of Section 5.5 (Customer Obligations). This indemnification obligation is subject to Customer receiving (i) prompt written notice of such claim (in sufficient time to avoid prejudice); (ii) the exclusive right to control and direct the investigation, defense, or settlement of such claim; and (iii) all necessary cooperation of Molin AI at Customer's expense. Molin AI may participate in the defense using its own counsel at its own expense. Customer may not settle any claim without Molin AI’s prior written consent unless the settlement fully releases Molin AI and imposes no financial or legal obligations on Molin AI.

# 6. Security

Molin AI agrees to use commercially reasonable technical and organizational measures designed to prevent unauthorized access to or use of the Services. Such measures are further described in the DPA and Privacy Policy and may include encryption, access controls, monitoring, and other industry-standard protections.\
However, Molin AI will have no responsibility for errors in transmission, unauthorized third-party access, or other causes beyond Molin AI’s reasonable control, and Customer is responsible for maintaining the security of its own systems, credentials, Customer Properties, and accounts used to access the Services. Customer must promptly notify Molin AI of any suspected unauthorized access or security incident relating to the Services.

# 7. Third-Party Platforms and Third Party Messaging Apps

7.1. Integration with Third Party Platforms. The Services may support integrations with certain Third-Party Platforms. Customer may import and export Customer Data between the Services and certain Third-Party Platforms through supported integrations. In order for the Services to communicate with such Third-Party Platforms, Customer may be required to input credentials in order for the Services to access and receive relevant information from such Third-Party Platforms. By enabling use of the Services with any Third-Party Platform, Customer authorizes Molin AI to access Customer's accounts with such Third-Party Platform for the purposes described in this Agreement. Customer is solely responsible for complying with any relevant terms and conditions of the Third-Party Platforms and maintaining appropriate accounts in good standing with the providers of the Third-Party Platforms. Customer acknowledges and agrees that Molin AI has no responsibility or liability for any Third-Party Platform, including, without limitation, any beta releases or pre-release features of a Third-Party Platform, or how a Third-Party Platform uses or processes Customer Data after it is exported to such Third-Party Platform. Molin AI does not guarantee that the Services will maintain integrations with any Third-Party Platform, and Molin AI may disable integrations of the Services with any Third-Party Platform at any time with or without notice to Customer. For clarity, this Agreement governs Customer's use of and access to the Services, even if accessed through an integration with a Third-Party Platform.

7.2. Third Party Messaging Apps. Customer represents and warrants that Customer has agreed to the terms of service associated with any Third Party Messaging App(s) and has created, or has authorized Molin AI to create on Customer's behalf, a Third Party Messaging App account in accordance with such terms and conditions, which govern Customer's use of such Third Party Messaging App account. The Third-Party Messaging App provider is solely responsible for its own network, functionality, clients, and APIs, and Molin AI will have no liability arising from any act or omission of a Third-Party Messaging App provider.\
Customer is responsible for ensuring that its use of Third-Party Messaging Apps complies with applicable laws, user notice requirements, telecom/messaging rules, and the policies of such messaging providers.

# 8. Ownership

8.1. Molin Technology. This is a subscription agreement for access to and use of the Services. Customer acknowledges that it is obtaining only a limited right to the Services and that irrespective of any use of the words “purchase", “sale” or like terms in this Agreement, no ownership rights are being conveyed to Customer under this Agreement. Molin AI and its suppliers retain all right, title, and interest (including all Intellectual Property Rights) in and to the Services, Documentation, Molin Code, Molin Integrations, and all related and underlying technology, software, tools, algorithms, models, data structures, user interfaces, and any modifications, derivative works, improvements, or enhancements of any of the foregoing, including any Feedback (“Molin Technology”). Except as expressly provided in this Agreement, no rights in Molin Technology are granted to Customer.

8.2. Feedback. Customer, from time to time, may submit Feedback to Molin AI. Molin AI may freely use or exploit Feedback in connection with the Services and Molin Technology. Customer hereby grants to Molin AI a perpetual, non-exclusive, transferable, irrevocable, worldwide, royalty-free license (with rights to sublicense) to make, use, sell, offer to sell, reproduce, modify, distribute, make available, publicly display and perform, disclose and otherwise commercially exploit the Feedback. Customer waives any claim based on Molin AI’s use of Feedback.

# 9. Subscription Term, Fees & Payment

9.1. Subscription Term and Renewals.

a) Monthly or Annual Subscription Term. For a month-to-month or year-to-year subscription, the Subscription Term will automatically renew on a monthly or annual basis. Each successive contract month or year will be considered a “renewal term.” Customer may cancel a subscription at any time by going to the “Settings” page in the Dashboard, and the effective termination date will be the last day of the then-current renewal term. Customer remains responsible for all fees incurred up to such date.

b) Multi-Year Subscription Term. For a multi-year subscription, the initial Subscription Term is set forth in the Order Form. The Subscription Term will automatically renew for additional, successive twelve month periods (each, a “renewal term"), unless either party gives the other written notice of intent not to renew at least thirty (30) days prior to expiration of the initial Subscription Term or then-current renewal term. Customer will send written notice of intent not to renew to [sales@molin.ai](mailto:sales@molin.ai). Molin AI may update pricing for any renewal term. Updated pricing will apply at the start of the renewal term unless otherwise specified in the Order Form.

9.2. Fees and Payment. All fees are as set forth in the applicable Order Form and/or on the Pricing Page available at [**https://molin.ai/pricing**](https://molin.ai/pricing), each of which is incorporated into this Agreement by reference. Customer agrees to pay all fees when due and in accordance with the payment terms set forth herein or in the applicable Order Form. Unless otherwise specified in an Order Form, all invoices are payable within thirty (30) days of issuance.

Depending on the Service plan selected by Customer and as stated on the Pricing Page or in the applicable Order Form, the Services may be billed: (a) on a subscription basis, (b) on a credit-based model (“Credits”), or (c) a combination of both. Where a specific pricing model applies, the applicable Order Form and Pricing Page will control.

Molin AI may update pricing, Credit consumption rates, package details, or subscription fees at any time, provided that such changes will not apply during Customer’s then-current Subscription Term unless: (i) Customer elects to modify its Services, or (ii) required due to legal or regulatory changes. If a pricing modification materially and adversely affects Customer, Customer may terminate the Agreement by providing notice prior to the effective date of the change.

a) Subscription-Based Fees. If Customer is on a subscription model, recurring subscription fees, add-ons, seat fees, usage-based channel fees, and any other contracted recurring components will be billed in advance of each billing period. Adjustments to contracted usage quantities will be prorated as specified in the applicable Order Form.

b) Credit Purchases. If Customer is on a Credit-based plan, Customer may purchase Credits as described on the Pricing Page or in the applicable Order Form. Credits may be redeemed for the designated Services at the consumption rates published on the Pricing Page. Credits activate upon purchase and are non-refundable except as required by law or explicitly stated in the Order Form.

c) Credit Consumption. When Customer is on a credit-based plan, each Service or feature consumes Credits based on the consumption rates listed on the Pricing Page. Consumption is calculated based on actual usage.

d) Insufficient Credits and Overage. If Customer’s Credit balance becomes insufficient, Customer may purchase additional Credits. Molin AI may suspend certain features until sufficient Credits are available. If expressly authorized in the Order Form, overage usage may be billed automatically at the then-current rates.

e) Changes to Contracted Packages. When Customer changes its subscription plan or committed Credit quantity, the change becomes effective immediately, and any applicable fees or Credits are prorated.

f) Add-Ons and One-Time Services. Customer may purchase add-ons or one-time services at the pricing set forth on the Pricing Page or in the applicable Order Form. Add-ons may be subject to recurring subscription fees, Credit consumption, or both.

g) Renewal Pricing. Upon renewal of a Subscription Term, updated subscription fees, Credit pricing, consumption rates, or package details on the Pricing Page will apply unless otherwise stated in the Order Form.

h) Invoicing for Additional Usage. Any usage, Credit overage, add-on consumption, or non-Credit-based charges not covered by Customer’s existing balance or plan will be invoiced after the month in which they occur or immediately upon depletion of Credits.

i) Promotions. Any promotional offers, introductory pricing, discounts, or similar incentives are subject to the [Promotional Terms](/legal/promotional-terms). Unless a specific Promotion expressly states otherwise, Promotions are available only to new customers and apply to one (1) subscription per team. If promotional pricing is applied in error, Molin AI reserves the right to correct billing to reflect standard rates.

j) Taxes. Except as expressly set forth in this Agreement, all fees are non-refundable. Customer is responsible for paying all Taxes, and all Taxes are excluded from any fees set forth in the applicable Order Form. Molin AI will invoice Customer for Taxes as well as any legally required fees arising from Customer's use of Services if Molin AI believes it has a legal obligation to do so, and Customer will pay such Taxes and fees if invoiced. If Customer is required by Law to withhold any Taxes from Customer's payment, the fees payable by Customer will be increased as necessary so that after making any required withholdings, Molin AI receives and retains (free from any liability for payment of Taxes) an amount equal to the amount it would have received had no such withholdings been made. Any late payments will be subject to a service charge equal to 1.5% per month of the amount due or the maximum amount allowed by law, whichever is less.

9.3. Payment Via Recurring Payment Method. If you are purchasing the Services via credit card, debit card or any other recurring payment method accepted by Molin AI (“Recurring Payment Method"), the following terms apply:

a. Recurring Billing Authorization. By providing Recurring Payment Method information and agreeing to purchase any Services, Customer hereby authorizes Molin AI (or its designee) to automatically charge Customer's Recurring Payment Method on the same date of each calendar month (or the closest prior date, if there are fewer days in a particular month) during the Subscription Term for all fees accrued as of that date (if any) in accordance with the applicable Order Form. Customer acknowledges and agrees that the amount billed and charged each month may vary depending on Customer's usage of the Services and may include adjustments to monthly subscription fee, upgrade fees, one-time service fees, additional usage charges, taxes and other fees as described above.

b. Foreign Transaction Fees. Customer acknowledges that for certain Recurring Payment Methods, the provider/issuer may charge a foreign transaction fee or other charges. Customer is responsible for such fees.

c. Invalid Payment. If a payment is not successfully settled due to expiration of a Recurring Payment Method, insufficient funds, or otherwise, Customer remains responsible for any amounts not remitted to Molin AI and Molin AI may, in its sole discretion, either (i) invoice Customer directly for the deficient amount, (ii) retry the Recurring Payment Method after Customer updates the information or (iii) terminate this Agreement or suspend access to the Services.

d. Changing Recurring Payment Method Information. At any time, Customer may change its Recurring Payment Method information by entering updated information via the “Settings” page on the Dashboard.

e. Payment of Outstanding Fees. Upon any termination or expiration of the subscription, Molin AI will charge Customer's Recurring Payment Method (or invoice Customer directly) for any outstanding fees for Customer's use of the Services during the Subscription Term, after which payment, Molin AI will not charge Customer's Recurring Payment Method for any additional fees.

9.4. Suspension of Service. If Customer’s account is overdue, Molin AI may, without liability and in addition to its other rights or remedies, suspend Customer’s access to the applicable Service until all overdue amounts are paid in full.\
Molin AI may also suspend access to the Services without liability if Customer’s use of the Services violates this Agreement, poses a security or operational risk, or results in excessive or abnormal usage affecting the Services’ stability or performance.

# 10. Term and Termination

10.1. Term. This Agreement is effective as of the Effective Date and expires on the date of the last to expire Subscription Term under any Order Form, unless earlier terminated as set forth herein.

10.2. Termination for Cause. Either party may terminate this Agreement (including all related Order Forms) if the other party (a) fails to cure any material breach of this Agreement (including a failure to pay fees) within thirty (30) days after written notice; (b) ceases operation without a successor; or (c) seeks protection under any bankruptcy, receivership, trust deed, creditors' arrangement, composition, or comparable proceeding, or if any such proceeding is instituted against that party and remains undismissed for sixty (60) days.

10.3. Effect of Termination. Upon any expiration or termination of this Agreement, Customer will immediately cease all use of, and access to, the Services (including any related Molin Technology). Customer will delete or, at Molin AI’s request, return all copies of the Documentation, Molin AI passwords or access credentials, and any other Molin AI Confidential Information in its possession. Customer acknowledges that it will have no further access to any Customer Data after termination and that Molin AI may delete Customer Data stored in the Services at any time thereafter, subject to obligations in the DPA and Applicable Law.\
Except where an exclusive remedy is specified, the exercise of any remedy under this Agreement (including termination) will be without prejudice to any other remedies available to the parties.

10.4. Survival. The following Sections will survive any expiration or termination of this Agreement: 3.7 (General Restrictions), 3.9 (Trial Subscriptions), 3.10 (Beta Offerings), 5.3 (Storage of Customer Data), 5.4 (Anonymized Data), 5.6 (Indemnification by Customer), 8 (Ownership), 9.2 (Fees and Payment), 9.3 (Payment Via Recurring Payment Method), 10.3 (Effect of Termination), 10.4 (Survival), 11.2 (Warranty Disclaimer), 14 (Limitation of Liability), 15 (Indemnification), 16 (Confidential Information) and 18 (General Terms). Sections in the Privacy Policy and DPA that by their nature should survive termination will also continue in full force.

# 11. Limited Warranty

11.1. Limited Warranty. Molin AI warrants, for Customer's benefit only, that each Service will operate in substantial conformity with the applicable Documentation. Molin AI's sole liability (and Customer's sole and exclusive remedy) for any breach of this warranty will be, at no charge to Customer, for Molin AI to use commercially reasonable efforts to correct the reported non-conformity, or if Molin AI determines such remedy to be impracticable, either party may terminate the applicable Subscription Term and Customer will receive as its sole remedy a refund of any fees Customer has pre-paid for use of such Service for the terminated portion of the applicable Subscription Term. The limited warranty set forth in this Section 11.1 will not apply: (i) unless Customer makes a claim within thirty (30) days of the date on which Customer first noticed the non-conformity, (ii) if the error was caused by misuse, unauthorized modifications or third-party hardware, software or services, or (iii) if Services are provided to Customer to use on a no-charge, trial, beta or evaluation basis.

11.2. Warranty Disclaimer. EXCEPT FOR THE LIMITED WARRANTY IN SECTION 11.1, ALL SERVICES ARE PROVIDED “AS IS". NEITHER MOLIN AI NOR ITS SUPPLIERS MAKES ANY OTHER WARRANTIES, EXPRESS OR IMPLIED, STATUTORY OR OTHERWISE, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, TITLE, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. MOLIN AI DOES NOT WARRANT THAT CUSTOMER'S USE OF THE SERVICES WILL BE UNINTERRUPTED OR ERROR-FREE, NOR DOES MOLIN AI WARRANT THAT IT WILL REVIEW THE CUSTOMER DATA FOR ACCURACY. MOLIN AI SHALL NOT BE LIABLE FOR THE RESULTS OF ANY AI OR HUMAN COMMUNICATIONS SENT OR ANY COMMUNICATIONS THAT WERE FAILED TO BE SENT USING THE SERVICES. MOLIN AI SHALL NOT BE LIABLE FOR DELAYS, INTERRUPTIONS, SERVICE FAILURES OR OTHER PROBLEMS INHERENT IN USE OF THE INTERNET AND ELECTRONIC COMMUNICATIONS, THIRD-PARTY PLATFORMS, THIRD PARTY APPS, OR OTHER SYSTEMS OUTSIDE THE REASONABLE CONTROL OF MOLIN AI. CUSTOMER MAY HAVE OTHER STATUTORY RIGHTS, BUT THE DURATION OF STATUTORILY REQUIRED WARRANTIES, IF ANY, SHALL BE LIMITED TO THE SHORTEST PERIOD PERMITTED BY LAW.

# 12. Support

During the Subscription Term of each Service, Molin AI will provide support in accordance with the support level included in the Customer’s subscription plan, as described in the Documentation or applicable Order Form. Support may vary by plan and may be updated from time to time.

Molin AI may send Service announcements, administrative messages, or product notifications to Customer administrators. Marketing communications will be sent in accordance with the Privacy Policy. The emails Molin AI sends may include tracking pixels that measure email opens; open tracking is enabled by default (opt-out), and Customer may withdraw at any time using the “Manage tracking” link in those emails, as described in the Privacy Policy.

# 13. Limitation of Liability

13.1. Consequential Damages Waiver. EXCEPT FOR EXCLUDED CLAIMS (DEFINED BELOW), NEITHER PARTY (NOR ITS SUPPLIERS) SHALL HAVE ANY LIABILITY ARISING OUT OF OR RELATED TO THIS AGREEMENT FOR ANY LOSS OF USE, LOST DATA, LOST PROFITS, FAILURE OF SECURITY MECHANISMS, INTERRUPTION OF BUSINESS, OR ANY INDIRECT, SPECIAL, INCIDENTAL, RELIANCE, EXEMPLARY, OR CONSEQUENTIAL DAMAGES OF ANY KIND, EVEN IF INFORMED OF THE POSSIBILITY OF SUCH DAMAGES IN ADVANCE.

13.2. Liability Cap. EXCEPT FOR EXCLUDED CLAIMS (DEFINED BELOW), EACH PARTY'S ENTIRE LIABILITY TO THE OTHER ARISING OUT OF OR RELATED TO THIS AGREEMENT SHALL NOT EXCEED THE AMOUNT ACTUALLY PAID OR PAYABLE BY CUSTOMER TO MOLIN AI UNDER THE AGREEMENT GIVING RISE TO THE LIABILITY IN THE TWELVE (12) MONTHS IMMEDIATELY PRECEDING THE CLAIM.

13.3. Excluded Claims.” Excluded Claims” means any claim arising (a) from Customer's breach of Section 4.7 (General Restrictions); (b) under Section 5.5 (Customer Obligations) or 5.6 (Indemnification by Customer); or (c) from a party's breach of its obligations in Section 15 (Confidential Information) (but excluding claims arising from operation or non-operation of any Service or relating to Customer Data).

13.4. Nature of Claims and Failure of Essential Purpose. The parties agree that the waivers and limitations specified in this Section 13 apply regardless of the form of action, whether in contact, tort (including negligence), strict liability or otherwise and will survive and apply even if any limited remedy specified in this Agreement is found to have failed of its essential purpose.

13.5. Applicable Law. The limitations on liability under this Section 13 will not apply to the extent such liability cannot be limited under applicable law.

# 14. Indemnification

Molin AI will defend Customer from and against any claim by a third party alleging that a Service when used as authorized under this Agreement infringes any Intellectual Property Rights and will indemnify and hold harmless Customer from and against any damages and costs finally awarded against Customer or agreed in settlement by Molin AI (including reasonable attorneys' fees) resulting from such claim, provided that Molin AI will have received from Customer: (i) prompt written notice of such claim (but in any event notice in sufficient time for Molin AI to respond without prejudice); (ii) the exclusive right to control and direct the investigation, defense and settlement of such claim; and (iii) all reasonable necessary cooperation of Customer. If Customer's use of a Service is (or in Molin AI's opinion is likely to be) enjoined, required to be discontinued by settlement, or if Molin AI determines that such steps are reasonably necessary to avoid material liability, then Molin AI may, in its sole discretion: (a) substitute substantially functionally similar products or services; (b) procure for Customer the right to continue using such Service; or if (a) and (b) are not commercially reasonable, (c) terminate this Agreement and refund to Customer the fees paid by Customer for the portion of the Subscription Term that was paid by Customer but not rendered by Molin AI. The foregoing indemnification obligation of Molin AI will not apply: (1) if such Service is modified by any party other than Molin AI, but solely to the extent the alleged infringement is caused by such modification; (2) if such Service is combined with products or processes not provided by Molin AI, but solely to the extent the alleged infringement is caused by such combination; (3) to any unauthorized use of such Service; (4) to any action arising as a result of Customer Data or any third-party deliverables or components contained within such Service; (5) to the extent the alleged infringement is not caused by the particular technology or implementation of the Service but instead by features common to any similar product or service, or industry-standard functionality common to similar products; (6) to any action arising from Customer's use of Third Party Messaging Apps; or (7) if Customer settles or makes any admissions with respect to a claim without Molin AI's prior written consent. THIS SECTION 14 SETS FORTH MOLIN AI’S AND ITS SUPPLIERS' SOLE LIABILITY AND CUSTOMER'S SOLE AND EXCLUSIVE REMEDY WITH RESPECT TO ANY CLAIM OF INTELLECTUAL PROPERTY INFRINGEMENT.

# 15. Confidential Information

Each party (as “Receiving Party") agrees that all code, inventions, know-how, business, technical and financial information it obtains from the disclosing party (“Disclosing Party") constitute the confidential property of the Disclosing Party (“Confidential Information"), provided that it is identified as confidential at the time of disclosure or should be reasonably known by the Receiving Party to be confidential or proprietary due to the nature of the information disclosed and the circumstances surrounding the disclosure. Any Molin Technology, performance information relating to any Service, and the terms and conditions of this Agreement will be deemed Confidential Information of Molin AI without any marking or further designation. Except as expressly authorized herein, the Receiving Party will (1) hold in confidence and not disclose any Confidential Information to third parties and (2) not use Confidential Information for any purpose other than fulfilling its obligations and exercising its rights under this Agreement. The Receiving Party may disclose Confidential Information to its employees, agents, contractors and other representatives having a legitimate need to know (including, for Molin AI, the subcontractors referenced in Section 17.8 (Subcontractors)), provided that such representatives are bound to confidentiality obligations no less protective than those set forth herein and that the Receiving Party remains responsible for compliance by any such representative with the terms of this Section 15. The Receiving Party's confidentiality obligations will not apply to information that the Receiving Party can document: (i) was rightfully in its possession or known to it prior to receipt of the Confidential Information; (ii) is or has become public knowledge through no fault of the Receiving Party; (iii) is lawfully obtained by the Receiving Party from a third party without breach of any confidentiality obligation; or (iv) is independently developed without use of Confidential Information. The Receiving Party may make disclosures to the extent required by law or court order, provided the Receiving Party notifies the Disclosing Party in advance and cooperates in any effort to obtain confidential treatment. The Receiving Party acknowledges that unauthorized disclosure of Confidential Information may cause substantial harm for which monetary damages alone may be insufficient. The Disclosing Party may seek equitable relief, including injunctions, in addition to any other remedies available at law.

# 16. Publicity

Molin AI may, upon Customer's prior written consent, use Customer’s name, logo, and brand to identify Customer as a Molin AI customer of the Services, including on Molin AI’s public website and in marketing materials. Any such use will comply with Customer’s then-current written branding or publicity guidelines provided to Molin AI.For clarity, such use will not be deemed an endorsement of the Services by Customer.

# 17. General Terms

17.1. Assignment. This Agreement will bind and inure to the benefit of each party's permitted successors and assigns. Neither party may assign this Agreement without the advance written consent of the other party, except that either party may assign this Agreement in connection with a merger, reorganization, acquisition or other transfer of all or substantially all of such party's assets or voting securities. Any attempt to transfer or assign this Agreement except as expressly authorized under this Section 17.1 will be null and void.

17.2. Severability. If any provision of this Agreement will be adjudged by any court of competent jurisdiction to be unenforceable or invalid, that provision will be limited to the minimum extent necessary so that this Agreement will otherwise remain in effect.

17.3. Governing Law; Dispute Resolution.

a) Direct Dispute Resolution. In the event of any dispute, claim, question, or disagreement arising from or relating to this Agreement, whether arising in contract, tort or otherwise, (“Dispute"), the parties shall first use their best efforts to resolve the Dispute. If a Dispute arises, the complaining party shall provide written notice to the other party in a document specifically entitled “Initial Notice of Dispute,” specifically setting forth the precise nature of the dispute (“Initial Notice of Dispute"). If an Initial Notice of Dispute is being sent to Molin AI it must be emailed to [legal@molin.ai](mailto:legal@molin.ai) and sent via mail to:

124 City Road, London, EC1V 2NX, United Kingdom

Following receipt of the Initial Notice of Dispute, the parties shall consult and negotiate with each other in good faith and, recognizing their mutual interest, attempt to reach a just and equitable solution of the Dispute that is satisfactory to both parties (“Direct Dispute Resolution"). If the parties are unable to reach a resolution of the Dispute through Direct Dispute Resolution within thirty (30) days of the receipt of the Initial Notice of Dispute, then the Dispute may subsequently be resolved in a court of law as set forth below.

b) FOR ANY CLAIM WHICH IS NOT SUBJECT TO THIS DISPUTE RESOLUTION PROVISION, CUSTOMER AGREES TO SUBMIT AND CONSENT TO THE PERSONAL AND EXCLUSIVE JURISDICTION IN, AND THE EXCLUSIVE VENUE OF, THE COURTS OF ENGLAND & WALES SHALL HAVE EXCLUSIVE JURISDICTION OVER ALL DISPUTES ARISING UNDER THIS AGREEMENT. IN ANY DISPUTE, ENGLISH LAW SHALL APPLY without regard to conflict-of-laws principles.

c) Construction and Joinder. BOTH CUSTOMER AND MOLIN AI AGREE THAT EACH MAY BRING OR PARTICIPATE IN CLAIMS AGAINST THE OTHER ONLY IN THEIR RESPECTIVE INDIVIDUAL CAPACITIES, AND NOT AS A PLAINTIFF OR CLASS MEMBER IN ANY PURPORTED CLASS. NO ARBITRATION OR CLAIM UNDER THIS AGREEMENT SHALL BE JOINED TO ANY OTHER ARBITRATION OR CLAIM, INCLUDING ANY ARBITRATION OR CLAIM INVOLVING ANY OTHER CURRENT OR FORMER USER OF THE SERVICES, AND NO CLASS ARBITRATION PROCEEDINGS SHALL BE PERMITTED. IN THE EVENT OF ANY DISPUTE CONCERNING THE VALIDITY OR ENFORCEABILITY OF THIS PROVISION, SUCH CLAIM MUST BE ADJUDICATED BY A COURT AND NOT BY AN ARBITRATOR.

d) Injunctive Relief. Notwithstanding the foregoing, Molin AI may seek injunctive or equitable relief (including urgent legal remedies) in any jurisdiction to enforce its rights or prevent irreparable harm.

17.4. Notice. Any notice or communication required or permitted under this Agreement will be in writing to the parties at the addresses set forth on the Order Form or at such other address as may be given in writing by either party to the other in accordance with this Section and will be deemed to have been received by the addressee (i) if given by hand, immediately upon receipt; (ii) if given by overnight courier service, the first business day following dispatch (iii) if given by registered or certified mail, postage prepaid and return receipt requested, the second business day after such notice is deposited in the mail; or (iv) if given by email on the first business day after sending. You agree that any electronic communication satisfies any applicable legal communication requirements, including that such communications be in writing.

17.5. Amendments; Waivers. Except as provided under “Modifications to this Agreement” and otherwise provided herein, no supplement, modification, or amendment of this Agreement will be binding, unless executed in writing by a duly authorized representative of each party to this Agreement. No waiver will be implied from conduct or failure to enforce or exercise rights under this Agreement, nor will any waiver be effective unless in a writing signed by a duly authorized representative on behalf of the party claimed to have waived. No provision of any purchase order or other business form employed by Customer that may be referenced in the Order Form or otherwise issued by Customer will supersede or modify the terms and conditions of this Agreement (regardless of any statement to the contrary in such document), and any such document relating to this Agreement will be for Customer's convenience and administrative purposes only and will have no legal effect.

17.6. Entire Agreement. This Agreement is the complete and exclusive statement of the mutual understanding of the parties and supersedes and cancels all previous written and oral agreements and communications relating to the subject matter of this Agreement. Customer acknowledges that the Services are on-line, subscription-based products, and that in order to provide improved customer experience Molin AI may make changes to the Services, and Molin AI will update the applicable Documentation accordingly.

17.7. Force Majeure. Neither party will be liable to the other for any delay or failure to perform any obligation under this Agreement (except for a failure to pay fees) if the delay or failure is due to unforeseen events that occur after the signing of this Agreement and that are beyond the reasonable control of such party, such as a strike, blockade, war, act of terrorism, riot, natural disaster, failure or diminishment of power or telecommunications or data networks or services, or refusal of a license by a government agency.

17.8. Subcontractors. Molin AI may use the services of subcontractors and permit them to exercise the rights granted to Molin AI in order to provide the Services under this Agreement, provided that Molin AI remains responsible for (i) compliance of any such subcontractor with the terms of this Agreement,(ii) for the overall performance of the Services as required under this Agreement, and (iii) compliance with the terms of the DPA, including Sub-processor requirements.

17.9. Subpoenas. Nothing in this Agreement prevents Molin AI from disclosing Customer Data to the extent required by law, subpoenas, or court orders, but Molin AI will use commercially reasonable efforts to notify Customer, unless prohibited by law.

17.10. Independent Contractors. The parties to this Agreement are independent contractors. There is no relationship of partnership, joint venture, employment, franchise or agency created hereby between the parties. Neither party will have the power to bind the other or incur obligations on the other party's behalf without the other party's prior written consent

17.11. Counterparts. This Agreement may be executed in counterparts, each of which will be deemed an original and all of which together will be considered one and the same agreement.


# Create a task
Source: https://docs.molin.ai/ninja/create-task

POST /v0/api/task
Submit a prompt to Ninja and start execution in the background. Returns immediately with a task ID and a pending status you can poll.

Creates a new task and starts execution in the background. Returns immediately with a `taskId` and `pending` status.

## Request parameters

<ParamField type="string">
  The task prompt. Must be between 1 and 16,000 characters.
</ParamField>

<ParamField type="string">
  The LLM model to use.

  | Value         | Description                                  |
  | ------------- | -------------------------------------------- |
  | `fast`        | Fastest and cheapest. Best for simple tasks. |
  | `smart`       | Balanced speed and quality. **(default)**    |
  | `super-smart` | Most capable. Best for complex reasoning.    |
</ParamField>

<ParamField type="object">
  Optional JSON Schema for structured output. When provided, the `result` field in the response will be a JSON object conforming to this schema. Must follow the [supported schema
  format](#result-schema-format). Maximum 5 KB when serialized.
</ParamField>

<ParamField type="integer">
  Hard credit ceiling for the task. If the task spends this many credits in a run without producing a result, it stops and the [result](/ninja/get-task-result) returns `status: "failed"` with an
  `error` explaining the budget was exceeded. Use it to cap the cost of open-ended prompts. Must be a positive integer. When omitted, it defaults to 1000 credits, so an API task is never unbounded.
</ParamField>

## Response fields

<ResponseField name="taskId" type="string">
  UUID of the created task. Use this to poll for results via the [get task result](/ninja/get-task-result) endpoint.
</ResponseField>

<ResponseField name="status" type="string">
  Always `pending` for newly created tasks.
</ResponseField>

<RequestExample>
  ```bash Simple task theme={null}
  curl -X POST https://ninja.new/v0/api/task \
    -H "Authorization: Bearer nsk_your_api_key" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "Find the top 3 competitors of Shopify",
      "model": "smart"
    }'
  ```

  ```bash Capped budget theme={null}
  curl -X POST https://ninja.new/v0/api/task \
    -H "Authorization: Bearer nsk_your_api_key" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "Research the EU market for standing desks",
      "model": "smart",
      "maxCredits": 500
    }'
  ```

  ```bash Structured output theme={null}
  curl -X POST https://ninja.new/v0/api/task \
    -H "Authorization: Bearer nsk_your_api_key" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "Find the top 3 competitors of Shopify and their estimated annual revenue",
      "model": "smart",
      "resultSchema": {
        "type": "object",
        "properties": {
          "competitors": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": { "type": "string" },
                "estimatedAnnualRevenue": { "type": "string" }
              },
              "required": ["name", "estimatedAnnualRevenue"]
            }
          }
        },
        "required": ["competitors"]
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "taskId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "pending"
  }
  ```
</ResponseExample>

***

## Result schema format

The `resultSchema` field must be a valid JSON Schema. The following features are **not** supported:

* `oneOf`, `anyOf`, `not`, `if`/`then`/`else`
* Numerical constraints (`minimum`, `maximum`, `multipleOf`)
* String length constraints (`minLength`, `maxLength`)
* Array length constraints (`minItems`, `maxItems`)
* Type arrays (e.g. `"type": ["string", "null"]`)

**Supported types:** `object`, `array`, `string`, `number`, `integer`, `boolean`

<Warning>The schema is validated at request time. An invalid schema returns `400 Bad Request`.</Warning>

**Example:**

```json theme={null}
{
  "type": "object",
  "properties": {
    "summary": { "type": "string" },
    "score": { "type": "number" }
  },
  "required": ["summary", "score"]
}
```


# How credits work
Source: https://docs.molin.ai/ninja/credits

Understand the different types of Ninja credits, the order they are used in, and how your balance is calculated.

Every task you run on [Ninja](https://ninja.new) costs credits. This page explains where credits come from, the order in which they are spent, and how the total you see in your dashboard is calculated.

## Types of credits

You can hold up to four different types of credits at the same time. Each one has its own rules about when it refills and whether unused credits roll over.

| Type                     | Refills when                    | Rolls over?                  | Where it comes from                                                                    |
| ------------------------ | ------------------------------- | ---------------------------- | -------------------------------------------------------------------------------------- |
| **Purchased credits**    | Never automatically             | Yes, kept until used         | Your signup bonus, paid top-ups, referral rewards                                      |
| **Free daily credits**   | Every day at 00:00 UTC          | No, unused credits are lost  | Every account, including paid plans, gets 100 free credits per day                     |
| **Plan monthly credits** | When a new billing cycle starts | No, reset at the cycle start | Your paid plan's monthly allowance (Plus = 2,000/month, Pro = 15,000/month, and so on) |
| **Promo credits**        | Defined per promo               | No, expire at promo end      | Time-limited promotions (e.g. a launch event that grants every shop extra credits)     |

The most important distinction is between **purchased credits** (which accumulate over time) and **free daily / plan monthly / promo credits** (which are usage caps that reset and do not carry over).

## Free daily credits do not stack

Free daily credits are a budget that refills, not a deposit. If you don't use Ninja today, you still start tomorrow with 100, not 200. Unused credits are lost at midnight UTC.

Plan monthly and promo credits work the same way. Only purchased credits roll over indefinitely.

## In what order are credits spent?

When you run a task, Ninja drains your credit buckets in this exact order:

1. **Promo credits** first
2. **Free daily credits** next
3. **Plan monthly credits** next (if you are on a paid plan, oldest active billing cycle first)
4. **Purchased credits** last

The system moves to the next bucket only when the current one is empty. A single task can be paid for from multiple buckets at once. For example, a 50-credit task could be covered by 30 promo credits + 20 free daily credits.

This order is designed to drain the credits that expire soonest before touching the ones you have paid for.

## How your "credits remaining" total is calculated

The single number you see in your dashboard is the sum of all four buckets:

```
Credits remaining = Purchased + Promo remaining + Free daily remaining + Plan monthly remaining
```

So a Free-plan user with no purchased credits and a full daily bucket will see **100**. A Plus user at the start of their billing cycle with 500 purchased credits and a full daily bucket will see **500 + 100 + 2,000 = 2,600**.

## Worked example 1: a Free-plan user, two tasks in one day

Anna signs up and receives a 500-credit signup bonus.

| Day           | What she does                   | Buckets after                                                                                                      |
| ------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| 0             | Signs up                        | Purchased: 500, Free daily: 100/100 → **total 600**                                                                |
| 1             | Runs a task that costs 30       | Free daily covers all 30. Free daily: 70/100 → **total 570**                                                       |
| 1             | Runs another task that costs 80 | Free daily covers the first 70, the last 10 come from purchased. Purchased: 490, Free daily: 0/100 → **total 490** |
| 2 (00:00 UTC) | Free daily resets               | Purchased: 490, Free daily: 100/100 → **total 590**                                                                |
| 2             | No usage                        | Same → **total 590**                                                                                               |
| 3             | No usage                        | Same → **total 590**                                                                                               |

Notice that the total stays at 590 from day 2 onwards. The 100 free daily credits refill her bucket, they do not add to her purchased balance.

## Worked example 2: a paid-plan user

Bela is on the Plus plan. He gets 2,000 monthly credits + 100 free credits per day, and he also has 500 purchased credits from a previous top-up. His billing cycle just renewed.

He runs a single task that costs 250 credits.

| Bucket                       | Before | Spent on this task | After |
| ---------------------------- | ------ | ------------------ | ----- |
| Promo                        | 0      | 0                  | 0     |
| Free daily                   | 100    | 100                | 0     |
| Plan monthly (current cycle) | 2,000  | 150                | 1,850 |
| Purchased                    | 500    | 0                  | 500   |

The task drained all 100 of today's free credits and 150 from his monthly allowance. His purchased credits were not touched — they are kept for when his monthly allowance runs out later in the cycle.

## Worked example 3: a promo period

The "Nano Banana Launch" promo grants every shop on Shopify, UNAS, Shoprenter, Shoper, and Scraper feeds an extra 10,000 credits for 5 days.

Csilla starts the promo with 200 purchased credits and a fresh 100 daily bucket. She runs a single task that costs 3,000 credits.

| Bucket     | Before | Spent | After |
| ---------- | ------ | ----- | ----- |
| Promo      | 10,000 | 3,000 | 7,000 |
| Free daily | 100    | 0     | 100   |
| Purchased  | 200    | 0     | 200   |

The promo bucket is drained first because it is the highest priority, so her purchased and free daily credits are untouched. The remaining 7,000 promo credits stay available until the promo ends, after which any unused promo credits disappear.

## Frequently asked questions

<AccordionGroup>
  <Accordion title="My balance has not changed in days, even though I'm on the Free plan. Where are my 100 credits per day?">
    The Free plan gives you 100 credits **of usage per day**, not 100 credits added to your balance each day. Unused free credits do not carry over. If you do not use Ninja today, tomorrow you will
    still start with 100, not 200.
  </Accordion>

  <Accordion title="What is the maximum balance I can reach on the Free plan?">
    The Free plan does not grow your balance over time. It gives you a 100-credit daily usage budget that resets every day at 00:00 UTC. To accumulate credits, you need to buy a top-up, earn referral
    rewards, or subscribe to a paid plan.
  </Accordion>

  <Accordion title="I see a negative number in my balance. Did I get charged?">
    No, we never bill you money for credit overruns. A negative number means a past task cost more than the credits available in your daily, monthly, and promo buckets, so the difference was taken
    from your purchased balance and pushed it below zero. You will not be able to run new tasks until your balance returns to zero or positive, which happens when you upgrade to a paid plan, buy a
    top-up, or a promo period covers your usage. If you think your balance is wrong, contact [support](mailto:hey@molin.ai).
  </Accordion>

  <Accordion title="I received credits during a promo. Where did they go?">
    Promo credits live in a separate bucket from your purchased balance. They are spent first (before your free daily, monthly, or purchased credits) and they expire when the promo ends. Any unused
    promo credits at the end of the promo period are forfeited.
  </Accordion>

  <Accordion title="Do my paid monthly credits roll over to next month?">
    No. Your monthly plan allowance resets at the start of each billing cycle, so unused credits from the previous month are lost. If you regularly have a lot of credits left over, consider
    downgrading to a smaller plan and topping up purchased credits as needed.
  </Accordion>
</AccordionGroup>


# Features
Source: https://docs.molin.ai/ninja/features

Explore how Ninja connects commerce platforms and handles autonomous media work with secure tools for daily shop operations.

[Ninja](https://ninja.new) is an autonomous agent that can use the browser and run tools to accomplish tasks for you. It can browse the web, read and write files, connect to your shop, generate images and text, and much more.

## Connect your shop

Ask in plain English to fetch orders, update products, list customers, or run any other platform action without leaving the chat.

| Platform   |
| ---------- |
| Shopify    |
| Shoper     |
| Shoprenter |
| UNAS       |
| Shoptet    |

To connect a shop, just ask Ninja: "Connect my Shopify store" or "Add my UNAS shop." Ninja walks you through the auth flow and stores credentials in the [vault](#vault-for-secrets) so subsequent tasks reuse them.

## Generate images

Ninja can generate images from a text prompt or edit one reference image. Grok Imagine accepts PNG and JPEG; Nano Banana also accepts WebP.

| Model                        | Resolutions | Plan access  | Credits per image |
| ---------------------------- | ----------- | ------------ | ----------------- |
| `nano-banana-2-lite`         | 1K          | All plans    | 6                 |
| `nano-banana-2`              | 0.5K–4K     | All plans    | 7–23              |
| `nano-banana-pro`            | 1K–4K       | Plus and Pro | 21–37             |
| `grok-imagine-image`         | 1K–2K       | All plans    | 3–4               |
| `grok-imagine-image-quality` | 1K–2K       | Plus and Pro | 8–12              |

The Grok Imagine models support custom aspect ratios for text-to-image generation. Editing preserves the reference image's aspect ratio.

Just ask: "Generate a watercolor image of a cat riding a unicycle" or "Use this product photo as a reference and generate a holiday-themed banner."

## Generate and edit videos

Ninja uses Gemini Omni 1.1 Flash to create 3-10 second videos at 360p, 720p, 1080p, or 4K. It supports all six Omni workflows:

| Workflow                    | Input                                     |
| --------------------------- | ----------------------------------------- |
| `text_to_video`             | A text prompt                             |
| `image_to_video`            | One image                                 |
| `first_last_frame_to_video` | An opening frame and a closing frame      |
| `reference_to_video`        | Two to six subject or style images        |
| `edit`                      | One source video                          |
| `extend`                    | One source video, continued by a new part |

Drafting at 360p costs a third of 720p and renders faster, so it's the cheapest way to try a prompt before committing to a final resolution.

Extending a clip returns the original plus the new part, and you're charged only for the new part, up to 40 seconds of total length.

The longest clips at the highest resolutions can come back as too large to return. That's a limit of how Ninja delivers the file, not of the model, so drop the resolution or shorten the clip.

Ninja selects the workflow from the files you provide, but you can also name it explicitly. For another edit, Ninja passes the current output video back as the next source and repeats the important constraints in the prompt.

Media sent to Omni can total up to 20 MiB. A source video can be up to 10 seconds. Each output costs 15 credits per second, and all plans can use the model.

Google blocks uploaded-video editing from the EEA or the UK. The same limit applies in Switzerland. The other video workflows remain available there.

Just ask: "Animate this product photo," "Use these two images to make a consistent product video," or "Change the background in this clip but keep the product unchanged."

## Generate text with Claude or ChatGPT

For any text-generation job — product descriptions, translations, summaries, SEO copy, classification — Ninja calls Claude or ChatGPT and bills you in credits.

You do **not** need your own `ANTHROPIC_API_KEY` or `OPENAI_API_KEY`.

### Claude models

| Model              |
| ------------------ |
| `claude-haiku-4-5` |
| `claude-sonnet-5`  |
| `claude-opus-5`    |

### ChatGPT models

| Model           |
| --------------- |
| `gpt-5.6-luna`  |
| `gpt-5.6-sol`   |
| `gpt-5.6-terra` |

Ninja picks the cheapest model that satisfies your quality bar.

Just ask: "Translate these 200 product descriptions to French" or "Summarise this 5-page article in one paragraph."

## Find and verify business contacts

Ninja can search Hunter.io's business contact data without requiring your own Hunter.io account or API key.

| Action                          | Ninja credits |
| ------------------------------- | ------------- |
| Find an email address           | 3             |
| Verify an email address         | 2             |
| Search a domain for contacts    | 3             |
| Enrich a person or company      | 1             |
| Count available domain contacts | Free          |

You are charged only when Hunter returns a billable result. A search with no contacts, an email finder with no result, or an email verification with an unknown status is free. Domain searches return at most 10 contacts per request.

Just ask: "Find Ada Lovelace's work email at example.com" or "Verify whether [ada@example.com](mailto:ada@example.com) can receive email."

## Research SEO and search rankings

Ninja can look up Ahrefs SEO data for any website or keyword without requiring your own Ahrefs account or API key.

| Action                                    | Ninja credits |
| ----------------------------------------- | ------------- |
| Domain Rating of a website                | 20            |
| Organic and paid search traffic           | 20            |
| Referring domains linking to a website    | 24            |
| Backlinks pointing at a website           | 32            |
| Competitors ranking for the same keywords | 63            |
| Top pages of a website                    | 129           |
| Keyword ideas from a seed keyword         | 129           |
| Keywords a website ranks for              | 133           |
| Search volume and difficulty, per keyword | 22            |
| Pages ranking for a keyword               | around 261    |
| Comparing websites side by side, per site | 21            |

Prices are for the default of 10 results and scale with the rows returned, so asking for 100 costs roughly ten times as much. Results Ahrefs serves from its cache are free, and you are charged for what a lookup actually returned rather than what it asked for.

Just ask: "How strong is competitor.com's backlink profile?" or "What keywords does competitor.com rank for that we don't?"

## Upload files

Attach files to any task by dragging them into the chat, pasting from the clipboard, or using the file picker. Each file can be up to **100 MB**.

Supported file types:

| Category  | Types                                                                         |
| --------- | ----------------------------------------------------------------------------- |
| Images    | PNG, JPEG, GIF, WebP                                                          |
| Videos    | MP4, MOV, MPEG, WebM, WMV, FLV, 3GP                                           |
| Audio     | MP3, WAV, M4A                                                                 |
| Documents | PDF (any page count), Word (`.doc`/`.docx`), PowerPoint (`.ppt`/`.pptx`), RTF |
| Data      | CSV, JSON, XML, YAML, Excel (`.xls`/`.xlsx`), Parquet, HDF5, TXT, Markdown    |
| Archives  | ZIP                                                                           |
| Code      | Python, JavaScript, TypeScript, Java, SQL, HTML, CSS, TOML                    |

Small images and PDFs are shown to Ninja instantly. Larger files are written to Ninja's workspace, where it reads and processes them with tools, so a 100 MB spreadsheet or a 1,000-page PDF works fine, it just takes a moment longer. Uploaded mp4 and audio files play right in the chat, and Ninja can cut, convert, transcribe, or analyze uploaded media in its workspace.

## Vault for secrets

Ninja has a persistent, encrypted vault that stores secrets across your tasks.

Any API key, password, token, or sensitive value Ninja needs is saved in the vault so you only have to enter it once.

Common uses:

* platform credentials (Shopify access tokens, UNAS API keys, etc)
* third-party API keys (Customer.io, PostHog, etc)
* shop-specific identifiers (shop IDs, store URLs)

When a task needs a secret you have not provided yet, Ninja shows a secure input form in chat.

## Skills

Skills are domain-specific knowledge packs that teach Ninja how to handle a particular tool, workflow, or API.

Ninja comes with built-in skills for common workflows (e.g. managing Google Ads, image/video generation, writing Python code, and more).

You can also install skills from any GitHub repository. Just give Ninja the URL.

## Generate Google Ads content

Ninja can authenticate to your Google Ads account and pull data for you.

Useful for analysing campaign performance, generating ad copy variations, or exporting reports.


# Get task result
Source: https://docs.molin.ai/ninja/get-task-result

GET /v0/api/task/result
Retrieve the current status and result of a Ninja task, with long-polling support while the task is still in progress.

Retrieves the current status and result of a task. Supports long-polling when the task is `in_progress`.

## Request parameters

<ParamField type="string">
  UUID of the task returned from the [create endpoint](/ninja/create-task).
</ParamField>

<ParamField type="string">
  Set to `1` to enable long-polling. When the task is `in_progress`, the request blocks until the task completes or the request times out. For tasks in any other status (`pending`, `completed`,
  `failed`, etc), this parameter has no effect and the request returns immediately.

  | Value | Description                                                   |
  | ----- | ------------------------------------------------------------- |
  | `0`   | Return immediately with the current status. **(default)**     |
  | `1`   | Long-poll until the task completes (only when `in_progress`). |
</ParamField>

## Response fields

<ResponseField name="taskId" type="string">
  UUID of the task.
</ResponseField>

<ResponseField name="status" type="string">
  Current task status. One of: `pending`, `in_progress`, `completed`, `failed`, `cancelled`, `paused`, `stopped`, `impossible`, `out_of_credits`. See [task statuses](/ninja/ninja-api#task-statuses).
</ResponseField>

<ResponseField name="result" type="object | string | null">
  The task result. Present when `status` is `completed`. If a `resultSchema` was provided at creation, this is a JSON object conforming to that schema; otherwise it is a plain text string. `null` for
  all other statuses.
</ResponseField>

<ResponseField name="error" type="string | null">
  Error message when `status` is `failed`. `null` for all other statuses.
</ResponseField>

<RequestExample>
  ```bash Poll immediately theme={null}
  curl "https://ninja.new/v0/api/task/result?taskId=550e8400-e29b-41d4-a716-446655440000" \
    -H "Authorization: Bearer nsk_your_api_key"
  ```

  ```bash Long-poll (waits when in_progress) theme={null}
  curl "https://ninja.new/v0/api/task/result?taskId=550e8400-e29b-41d4-a716-446655440000&wait=1" \
    -H "Authorization: Bearer nsk_your_api_key"
  ```
</RequestExample>

<ResponseExample>
  ```json Completed (plain text) theme={null}
  {
    "taskId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "completed",
    "result": "Shopify's top 3 competitors are BigCommerce, WooCommerce, and Wix.",
    "error": null
  }
  ```

  ```json Completed (structured output) theme={null}
  {
    "taskId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "completed",
    "result": {
      "competitors": [
        { "name": "BigCommerce", "estimatedAnnualRevenue": "$300M" },
        { "name": "WooCommerce", "estimatedAnnualRevenue": "$500M" },
        { "name": "Wix", "estimatedAnnualRevenue": "$1.6B" }
      ]
    },
    "error": null
  }
  ```

  ```json Pending theme={null}
  {
    "taskId": "550e8400-e29b-41d4-a716-446655440000",
    "status": "pending",
    "result": null,
    "error": null
  }
  ```
</ResponseExample>


# Ninja API
Source: https://docs.molin.ai/ninja/ninja-api

The HTTP API for creating and executing Ninja tasks programmatically, defining structured output schemas, and retrieving results.

<Info>The Ninja API is currently in **beta**. Email [hey@molin.ai](mailto:hey@molin.ai) to request access and receive your API key.</Info>

The Ninja API lets you submit prompts to [Ninja](https://ninja.new), optionally define a structured output schema, and retrieve results — all over HTTP.

## Base URL

```
https://ninja.new
```

## Authentication

All requests require a Bearer token in the `Authorization` header. API keys are prefixed with `nsk_`.

```http theme={null}
Authorization: Bearer nsk_your_api_key_here
```

## Endpoints

<CardGroup>
  <Card title="Create a task" icon="plus" href="/ninja/create-task">
    `POST /v0/api/task` — submit a prompt and start execution.
  </Card>

  <Card title="Get task result" icon="magnifying-glass" href="/ninja/get-task-result">
    `GET /v0/api/task/result` — retrieve status and result.
  </Card>
</CardGroup>

## Typical usage pattern

1. **Create a task** — `POST /v0/api/task` — save the returned `taskId`.
2. **Poll for result** — `GET /v0/api/task/result?taskId=...&wait=1`.
3. **If status is `pending`** — the task hasn't started yet. `wait=1` has no effect for `pending` tasks. Wait a short moment and poll again.
4. **If status is `in_progress`** — the long-poll is active and the request will block until the task completes. Poll again if the request times out.
5. **When status is `completed` or `failed`** — read the `result` or `error` field and stop polling.

***

## Task statuses

| Status           | Description                                              |
| ---------------- | -------------------------------------------------------- |
| `pending`        | Task created, hasn't started yet.                        |
| `in_progress`    | Task is currently executing.                             |
| `completed`      | Task finished successfully. `result` is available.       |
| `failed`         | Task encountered an error. `error` contains the message. |
| `cancelled`      | Task was cancelled.                                      |
| `paused`         | Task is paused, waiting for user input.                  |
| `stopped`        | Task was stopped.                                        |
| `impossible`     | Task cannot be completed.                                |
| `out_of_credits` | User ran out of credits during execution.                |

***

## Execution limits

Each task has a maximum execution time of **30 minutes**. If the task does not complete within this window, it is automatically marked as `failed` with the error `Task timed out`.

## Rate limits

Both endpoints share a limit of **10 requests per minute** per user. Exceeding the rate limit returns `429 Too Many Requests`.

***

## Error responses

| Status code | Description                                                                                                  |
| ----------- | ------------------------------------------------------------------------------------------------------------ |
| `400`       | Invalid request body or query parameters (e.g. prompt too long, invalid `resultSchema`, malformed `taskId`). |
| `401`       | Missing or invalid API key.                                                                                  |
| `404`       | Task not found or not owned by the authenticated user.                                                       |
| `429`       | Rate limit exceeded (10 req/min) or free-plan task quota exhausted.                                          |


# Prefilled message links
Source: https://docs.molin.ai/ninja/prefilled-message-links

Create shareable Ninja links that open with a message already typed into the text input, so people can start from your exact prompt.

## Overview

You can create links to [Ninja](https://ninja.new) that automatically prefill a message in the text input. This is useful for:

* Sharing a task prompt with a colleague
* Embedding contextual links in emails, docs, or internal tools
* Creating quick-action buttons that start a specific workflow

The format is identical to [ChatGPT's `?q=` parameter](https://chatgpt.com/?q=Hello):

```
https://ninja.new/?q=Your+message+here
```

## How it works

When a user opens a Ninja link with a `?q=` query parameter, the message is automatically placed in the text input so they can review it before submitting.

### URL format

```
https://ninja.new/?q={URL-encoded message}
```

The message must be [percent-encoded](https://developer.mozilla.org/en-US/docs/Glossary/Percent-encoding). Spaces can be encoded as `%20` or `+`.

### Examples

| Link                                                                   | Message                                         |
| ---------------------------------------------------------------------- | ----------------------------------------------- |
| `https://ninja.new/?q=Connect%20my%20Shopify%20store`                  | Connect my Shopify store                        |
| `https://ninja.new/?q=Write+a+product+description+for+my+new+sneakers` | Write a product description for my new sneakers |
| `https://ninja.new/?q=Analyze%20my%20top%2010%20selling%20products`    | Analyze my top 10 selling products              |

### Building links in JavaScript

```javascript theme={null}
const message = 'Help me set up Google Ads for my store';
const url = `https://ninja.new/?q=${encodeURIComponent(message)}`;
```

## Link builder

Use this tool to generate a prefilled Ninja link:

<NinjaLinkBuilder />

<Note>The user must be logged in to Ninja to submit the message. If they are not logged in, they will be redirected to the login page first.</Note>


# System status
Source: https://docs.molin.ai/system-status/introduction

Check the current status of Molin AI services, see any ongoing incidents, and find out how to reach us if something isn't working.

You can check the status of our services here: [https://molin.statuspage.io/.](https://molin.statuspage.io/.)

If you experience any issues or have any questions, please contact us at [hey@molin.ai](mailto:hey@molin.ai) or join [our Facebook group](https://www.facebook.com/groups/molinaiofficialen/).