# Public API
Source: https://docs.totebot.ai/api/public-api

Access your agent's data programmatically with the Totebot Public API

The Public API lets you access your agent's conversations, analytics, customers, and more programmatically. All endpoints are authenticated with an API key and return JSON responses.

<Note>The Public API is available on **Basic**, **Pro**, and **Scale** plans.</Note>

<Card title="API Reference (Swagger)" icon="code" href="https://api.totebot.ai/api-docs">
  Browse the full API reference with request/response schemas and try endpoints directly.
</Card>

## Authentication

All API requests require a **Bearer token** in the `Authorization` header. The token is your agent's API key.

```bash theme={null}
curl -H "Authorization: Bearer tb_pk_your_api_key_here" \
  https://api.totebot.ai/v1/agent
```

### Generate an API Key

<Steps>
  <Step title="Open Settings">
    Navigate to **Settings** → **Security** for your agent.
  </Step>

  <Step title="Generate Key">
    Click **Generate API Key**. Your key will be displayed once. Copy it immediately and store it securely.
  </Step>

  <Step title="Use the Key">
    Include the key as a Bearer token in the `Authorization` header of every API request.
  </Step>
</Steps>

<Warning>
  Treat your API key like a password. It provides full read access to your agent's data. If compromised, revoke it immediately from **Settings** → **Security** and generate a new one.
</Warning>

### Rate Limits

The API allows **60 requests per 60 seconds** per agent per IP address. If you exceed this limit, you'll receive a `429 Too Many Requests` response.

## Endpoints

### Agent

| Method | Endpoint    | Description                                   |
| ------ | ----------- | --------------------------------------------- |
| GET    | `/v1/agent` | Get agent info (name, model, training status) |

### Chat

| Method | Endpoint   | Description                                          |
| ------ | ---------- | ---------------------------------------------------- |
| POST   | `/v1/chat` | Send a message to the agent (streaming SSE response) |

The chat endpoint accepts a `message`, optional `conversationId` to continue an existing conversation, and optional `identity` object for user tracking. Responses are streamed as Server-Sent Events with types: `chunk`, `completed`, `tool_call`, `action_started`, `action_completed`, `error`.

### Conversations

| Method | Endpoint                                                         | Description                                  |
| ------ | ---------------------------------------------------------------- | -------------------------------------------- |
| GET    | `/v1/conversations`                                              | List conversations (paginated, with filters) |
| GET    | `/v1/conversations/:conversationId`                              | Get a single conversation with full data     |
| GET    | `/v1/conversations/:conversationId/messages`                     | List messages only (lighter payload)         |
| PATCH  | `/v1/conversations/:conversationId/messages/:messageId/feedback` | Submit feedback (POSITIVE or NEGATIVE)       |

**Filters for listing conversations:** `page`, `limit` (max 250), `startDate`, `endDate`, `source` (PREVIEW, EMBED, TELEGRAM, WHATSAPP, EMAIL), `sentiment` (POSITIVE, NEGATIVE, NEUTRAL), `product`, `purchased` (yes/no), `customerId`.

### Analytics

| Method | Endpoint                | Description                                                         |
| ------ | ----------------------- | ------------------------------------------------------------------- |
| GET    | `/v1/analytics`         | Chat opens, messages, unique users, cart adds, checkout initiations |
| GET    | `/v1/analytics/revenue` | Total revenue, order count, currency, daily breakdown               |

Both endpoints accept optional `from` and `to` query parameters (ISO 8601 dates) to filter by date range.

### Insights

| Method | Endpoint                 | Description                                                          |
| ------ | ------------------------ | -------------------------------------------------------------------- |
| GET    | `/v1/insights/sentiment` | Sentiment distribution (positive/negative/neutral counts and scores) |
| GET    | `/v1/insights/intents`   | Top 3 conversation intents sorted by score                           |
| GET    | `/v1/insights/products`  | Product mentions with sentiment and frequency                        |
| GET    | `/v1/insights/questions` | Top questions grouped by semantic similarity                         |

### Customers

| Method | Endpoint        | Description                                      |
| ------ | --------------- | ------------------------------------------------ |
| GET    | `/v1/customers` | List all customers who interacted with the agent |

Supports `sortBy` parameter: `a-z`, `z-a`, `oldest`, `newest`.

### Knowledge

| Method | Endpoint        | Description                                                       |
| ------ | --------------- | ----------------------------------------------------------------- |
| GET    | `/v1/knowledge` | List knowledge sources (documents, Q\&A, links, text) with status |

### Orders

| Method | Endpoint     | Description                              |
| ------ | ------------ | ---------------------------------------- |
| GET    | `/v1/orders` | Paginated orders attributed to the agent |

Supports `skip` (default 0) and `take` (1-250, default 20) query parameters.

### Leads

| Method | Endpoint    | Description                          |
| ------ | ----------- | ------------------------------------ |
| GET    | `/v1/leads` | List all leads captured by the agent |

### Emails

| Method | Endpoint     | Description                                   |
| ------ | ------------ | --------------------------------------------- |
| GET    | `/v1/emails` | List emails collected through the chat widget |

### Integrations

| Method | Endpoint           | Description                                            |
| ------ | ------------------ | ------------------------------------------------------ |
| GET    | `/v1/integrations` | List all active integrations (channels and e-commerce) |


# Web SDK
Source: https://docs.totebot.ai/api/web-sdk

Embed the chat widget and control it from your site with JavaScript

The Web SDK lets you embed the Totebot chat widget on your site and control it from JavaScript: identify signed-in users, show or hide the widget, and react to chat events.

## Embed the widget

### Chat bubble

Add the snippet from **Channels → Web** before the closing `</body>` tag. It loads the widget and shows a floating chat bubble:

```html theme={null}
<script>
  (function () {
    const onLoad = function () {
      const script = document.createElement('script');
      script.src = 'https://totebot.ai/embed.min.js';
      script.id = 'YOUR_AGENT_ID';
      script.domain = 'totebot.ai';
      document.body.appendChild(script);
    };
    if (document.readyState === 'complete') onLoad();
    else window.addEventListener('load', onLoad);
  })();
</script>
```

The `id` attribute is your agent ID. Copy the ready-made snippet from the dashboard so it's filled in for you.

### Inline iframe

To place the full chat inside a page instead of a floating bubble:

```html theme={null}
<iframe
  src="https://totebot.ai/embed-agent/YOUR_AGENT_ID"
  width="100%"
  style="height: 100%; min-height: 700px"
  allow="microphone"
  frameborder="0">
</iframe>
```

## JavaScript API

Once the script loads, it exposes a global `window.totebot` object.

| Method                                 | Description                                                                           |
| -------------------------------------- | ------------------------------------------------------------------------------------- |
| `window.totebot.identifyUser(payload)` | Attach a verified identity to the conversation (see below).                           |
| `window.totebot.show()`                | Show the chat bubble.                                                                 |
| `window.totebot.hide()`                | Hide the chat bubble, window, and initial messages.                                   |
| `window.totebot.refresh()`             | Re-send the current page context (URL, title) and re-evaluate page-specific messages. |

Calls made before the widget finishes loading are queued and replayed once it's ready, so you can call them at any time.

## Identify a user

For signed-in users, pass a `userId` together with a `userHash` so the agent can trust the identity and recognize the person across sessions and channels. Generate the hash on your **server** (never expose your agent secret in the browser): it's an HMAC-SHA256 of the `userId`, keyed with your agent secret.

Find your agent secret in **Channels → Web** under the identity section.

<CodeGroup>
  ```javascript Node.js theme={null}
  const crypto = require('crypto');

  const userId = 'user_123';
  const agentSecret = 'your_agent_secret';

  const userHash = crypto
    .createHmac('sha256', agentSecret)
    .update(userId)
    .digest('hex');
  ```

  ```python Python theme={null}
  import hmac
  import hashlib

  user_id = 'user_123'
  agent_secret = 'your_agent_secret'

  user_hash = hmac.new(
      agent_secret.encode('utf-8'),
      user_id.encode('utf-8'),
      hashlib.sha256,
  ).hexdigest()
  ```
</CodeGroup>

Then pass the id, hash, and any metadata to the widget in the browser:

```javascript theme={null}
window.totebot.identifyUser({
  userId: 'user_123',
  userHash: userHash, // generated on your server
  metadata: {
    name: 'John Doe',
    email: 'john@example.com',
    // any additional fields
  },
});
```

<Note>Identity verification requires the Personalization feature, available on the **Basic**, **Pro**, and **Scale** plans.</Note>

## Listen for events

The widget posts messages to the host page so you can react to what happens in the chat:

```javascript theme={null}
window.addEventListener('message', (event) => {
  switch (event.data?.type) {
    case 'close':
      // the chat window was closed
      break;
    case 'conversation_id_changed':
      console.log('Conversation:', event.data.conversationId);
      break;
    case 'anon_user_id_changed':
      console.log('Anonymous user:', event.data.anonUserId);
      break;
  }
});
```

| Event                     | Payload              | When                                 |
| ------------------------- | -------------------- | ------------------------------------ |
| `close`                   | (none)               | The customer closes the chat window. |
| `conversation_id_changed` | `{ conversationId }` | A conversation starts or switches.   |
| `anon_user_id_changed`    | `{ anonUserId }`     | An anonymous ID is assigned.         |

## E-commerce and voice

On Shopify and WooCommerce, the widget syncs the live cart automatically, so the agent can read and update it. Voice input (the iframe's `allow="microphone"`) and attachments are controlled from **Settings → Chat Interface**. For server-to-server access to conversations, analytics, and more, use the [Public API](/api/public-api).


# Best Practices
Source: https://docs.totebot.ai/best-practices

Get the most accurate, on-brand answers from your agent

Setting up an agent takes minutes, but a few habits make a large difference in answer quality and customer experience. Use these as you build and refine.

## Build a strong knowledge base

Your agent answers from the knowledge you give it, so the quality of that content sets the ceiling on answer quality.

<AccordionGroup>
  <Accordion title="Prepare documents carefully" icon="file-check">
    Upload files that are clear, structured, and complete: product details, FAQs, policies, and guides. Well-organized source material produces more precise answers.
  </Accordion>

  <Accordion title="Add relevant links" icon="link">
    Add links to your website, blog, and policy pages. Make sure they point to accurate, up-to-date content, and remove outdated or broken links so the agent doesn't serve old information.
  </Accordion>

  <Accordion title="Use Q&A for gaps" icon="question">
    When customers ask things your documents don't cover well, add them as specific Q\&A pairs. This gives the agent an exact, brand-approved answer for those questions.
  </Accordion>

  <Accordion title="Retrain after changes" icon="rotate">
    After adding or editing knowledge, click **Train agent** so the changes take effect. On the Scale plan you can enable automatic daily retraining.
  </Accordion>
</AccordionGroup>

## Shape behavior with instructions and skills

* Write clear **instructions** in **Settings → AI**: the agent's role, tone, and what it should and shouldn't do.
* Use **[Skills](/dashboard/agent-skills)** for situation-specific behavior (returns, upsell, troubleshooting) instead of overloading one big instruction block.
* Keep the **temperature** low for support and factual answers so responses stay consistent.

## Test before and after you ship

* Use the **[Overview](/dashboard/overview)** live preview to try questions exactly as a customer would.
* Use **Compare** to run the same prompt against different models, temperatures, or instructions side by side, and keep the setup that performs best.

## Monitor and improve

* Check **[Analytics](/dashboard/analytics)** for engagement, resolution, sentiment, and the questions customers ask most.
* Review **[Conversations](/dashboard/conversations)** regularly. When an answer isn't ideal, use **Revise Answer** so the agent uses your improved version for similar questions.
* Turn recurring **knowledge gaps** (questions the agent couldn't answer well) into new knowledge or Q\&A.

## Track business impact

If you run a store, watch add-to-cart events, checkout starts, and attributed revenue in **Analytics → Revenue & Commerce**, and watch captured leads from your **[AI Actions](/dashboard/ai-actions)**. This shows the real impact your agent has, not just message volume.


# Agent Skills
Source: https://docs.totebot.ai/dashboard/agent-skills

Teach your agent how to behave in specific situations with reusable skills

## What are skills?

Skills are reusable instructions that tell your agent **how to behave in a specific situation**. Each skill has:

* **Name**: a short label (e.g. "Returns & Exchanges").
* **When to use**: the trigger that tells the agent when this skill applies (e.g. "When a customer wants to return or exchange a product").
* **Instructions**: what the agent should do when the situation occurs.

When a conversation matches a skill's *when to use*, the agent follows that skill's instructions. This lets you shape behavior precisely (handling returns, upselling, troubleshooting) without rewriting your whole system prompt.

## Skill categories

Skills are organized into categories so they're easy to manage:

* **Sales**: consultative selling, upsell & cross-sell, objection handling, product comparison.
* **Customer support**: troubleshooting, complaint handling.
* **Returns**: returns, exchanges, order modifications.
* **Catalog**: product/catalog assistance.
* **Custom**: anything specific to your business.

## The skill library

Totebot ships a library of prebuilt skills you can add to your agent in one click. Each library skill comes with a sensible *when to use* and *instructions* that you can keep as-is or edit.

To add a library skill:

1. Open **Settings** → **AI** and scroll to the **Skills** section.
2. Click **Browse** to open the skill library.
3. Browse by category and click **Add** on any skill. Skills already on your agent are marked as added.

## Adding a custom skill

If the library doesn't cover your need, create your own:

1. In the **Skills** section, click **Add skill**.
2. Fill in:
   * **Name**: what the skill is called.
   * **When to use**: describe the situation that should trigger it. Be specific ("When a customer asks about delivery times" rather than "shipping").
   * **Instructions**: exactly what the agent should do or say.
   * **Category**: pick the closest fit (or **Custom**).
3. Save. The skill takes effect immediately on the next message.

## Editing, enabling, and removing

* **Edit**: update a skill's name, when-to-use, instructions, or category at any time.
* **Enable / disable**: toggle a skill off to pause it without deleting. A disabled skill is kept but no longer applied.
* **Delete**: permanently remove a skill you no longer need.

## Writing effective skills

<Tip>
  The **when to use** field is what makes a skill trigger at the right moment, and the **instructions** are what it actually does. Keep them tightly matched.
</Tip>

* Make **when to use** describe a clear, recognizable situation.
* Keep **instructions** actionable and concrete: steps, rules, or phrasing the agent should follow.
* Prefer several focused skills over one giant skill; the agent applies whichever matches the conversation.
* Skills work alongside your agent's knowledge base and instructions: use skills for *behavior*, the knowledge base for *facts*.

## Example

**Name:** Returns & Exchanges

**When to use:** When a customer wants to return or exchange a product, or asks about the return policy.

**Instructions:** Confirm the order and item, check it's within the 30-day window, and explain the steps to start a return. If the item is outside the window or final sale, apologize and offer alternatives. Never promise a refund amount you can't confirm; defer to the return policy.


# AI Actions
Source: https://docs.totebot.ai/dashboard/ai-actions

Extend your agent's capabilities with AI Actions

Totebot allows you to create and use AI Actions to extend your agent's capabilities and automate tasks.

To manage actions, open **AI Actions** in your agent's sidebar. The number of actions per agent depends on your plan: 5 on Basic, 10 on Pro, 15 on Scale.

Available AI Actions:

* Email
* Lead
* API Call
* Web Search
* Custom Button

## Email

<img alt="ToteBot AI Actions" />

You can instruct the agent to send an email to a recipient when certain conditions are met. This is ideal for forwarding inquiries, collecting leads, or notifying your team.

To activate this AI Action:

1. Click the **Add Action** button.
2. Choose the Email option and click Continue.
3. Fill in each field based on your use case.

<img alt="Create New Action" />

<img alt="Create Email Action" />

What to define:

* **Action name**: Choose a clear and recognizable name. This is especially useful if you plan to create multiple email actions.
* **Instructions for the agent**: Include details such as when should the agent send an email, what trigger phrases or questions from users activate this action, what should the agent reply or ask in response. Make sure the agent collects a valid email address (and name) from the user and instructs the agent to send the email.
* **Body content** (based on collected user info)
* **Recipient email address** (where collected data will be sent)
* **Email subject line**

After clicking the Create Action button, your first AI Action will be created.

<img alt="Email Action Created" />

To see how this feature works and identify any issues, enter the chat and ask a relevant question. Observe how the agent responds.

<img alt="Testing Email Action" />

Then, check your inbox for a notification about the request. Also, check the customer email you provided to confirm that the automated message was sent successfully. If needed adjust how the agent replies, or give clearer instructions to the agent.

<img alt="Email Notification" />

## Lead

<img alt="Lead Generation Action" />

The agent can generate leads based on certain criteria. Be sure to provide clear instructions on what it should do, as well as what it shouldn't. This feature can be used to automatically collect contact information from interested customers based on specific intent or trigger phrases during a conversation.

When a user expresses interest in your services, custom orders, or newsletters, the agent can:

* Ask for their name
* Ask for their email or phone number
* Optionally ask for company name, budget, or other relevant info

Once the user replies, the agent:

* Saves the lead (name + email)
* Saves this conversation on the Dashboard
* Confirms to the user: "Thanks! Our team will reach out to you shortly."

### Testing Lead Action

You should test the Lead Action in your chat by writing sentences similar to the trigger phrases defined in your instructions. This will help you check if any adjustments are needed.

<img alt="Lead Action in the chat" />

To access this data, expand AI Actions on the left side to view all relevant information: name, email address, interest, and the date the customer made the request.

<img alt="Collected Leads" />

<img alt="Lead Conversations" />

You can review the conversation and revise any of the agent's replies to ensure better responses in future interactions with your customers.

## API Call

<img alt="API Action" />

With this AI Action, you can call a specific API (Application Programming Interface) to connect Totebot with other systems or services. For example, you could integrate your CRM with a marketing platform to automatically send an email when a new lead is added, and many other automations are possible.

Make sure you fill in all required fields, including an accurate link.

<img alt="API Action in the chat" />

Test your action in the chat. If needed, go to Conversations and revise answers to get the most refined version.

## Web Search

The Web Search action lets your agent search the web to answer questions that go beyond your knowledge base, such as current events or third-party information.

You can restrict searches with **Include Domains**: when set, the agent only searches the domains you list (for example, your own site or trusted sources). Leave it empty to search the whole web.

## Custom Button

The Custom Button action shows a clickable button in the chat when the conversation matches your instructions. Define:

* **Button Label**: the text on the button (e.g., "Book a demo").
* **Button URL**: where the button takes the customer.

Use it to route customers to booking pages, signup forms, or any other destination at the right moment in the conversation.


# AI Copilot
Source: https://docs.totebot.ai/dashboard/ai-copilot

Set up, configure, and improve your agent by chatting with a copilot

The **AI Copilot** is an assistant that helps you set up, configure, and improve your agent through conversation. Instead of hunting through settings, you tell the copilot what you want and it makes the change or answers the question.

Open it with the **AI Copilot** button in the dashboard. It opens as a side panel and knows which agent and page you're on, so you can refer to "this conversation" or "this page" and it understands the context.

## What it can do

### Answer questions about your agent

* "What's my knowledge base size?"
* "How are my conversations going this week?"
* "Is my agent trained?"
* "Which integrations are connected?"
* "What does my current plan include?"

### Configure settings

* Switch the **AI model**, and see which models your plan includes.
* Adjust the **temperature** (how focused or creative replies are).
* Set the **response language**, or leave it on auto-detect.
* **Rename** the agent.
* Read and rewrite the agent's **instructions** (system prompt).

### Manage knowledge

* See knowledge-base **stats** and **list your sources**.
* Add knowledge as **text**, a **link**, a full **sitemap**, or **Q\&A pairs**.
* **Delete** sources and **retrain** the agent.
* **Test a query** to see exactly what your agent would retrieve for a given question.
* Review **knowledge gaps**: frequent questions your agent couldn't answer, with suggested fixes.

See [Knowledge](/dashboard/knowledge) for how the knowledge base works.

### Manage skills

* **List** your agent's skills and browse the **skill library** of prebuilt templates.
* **Add** a skill from a template or create a custom one.
* **Enable, disable, edit, or delete** skills.

See [Agent Skills](/dashboard/agent-skills) for more on skills.

### Review insights

* Pull **analytics**: conversations, messages, unique users, how many conversations were handled without a human and how many were handed over, sentiment, cart adds, and checkouts.
* See the **top questions** customers ask, grouped by meaning.
* Check **conversation sentiment** over a time window.
* **Browse conversations** and open the **details** of a specific one.
* **Analyze a conversation** on demand for sentiment and intent.

### Set up integrations

* See your **connected integrations** and their status.
* See **what's available** on your plan, with links to the right setup screen.
* **Sync your product catalog** from a connected store.

The copilot never asks for secrets or API keys in chat. It points you to the right setup screen instead.

### Answer questions about Totebot

Ask how a feature works, what a setting does, or what a plan includes. The copilot searches Totebot's own documentation to answer.

## Who can use it

Anyone with access to the agent can chat with the copilot. Only **agent owners** (and team managers or admins) can make changes. For everyone else the copilot is **read-only**: it answers questions and pulls insights, but it won't change settings, knowledge, or skills.

## Safety

* The copilot **asks you to confirm** before high-impact actions: deleting knowledge, retraining, switching the AI model, syncing the product catalog, and adding Q\&A in bulk.
* When the copilot performs an action, it tells you what it changed and the dashboard updates to reflect it.
* A footer reminds you that AI can make mistakes, so review important changes.

## History and feedback

* **Suggested prompts** help you get started, and the copilot offers **follow-up questions** as you chat.
* **New chat** starts a fresh thread; **History** lists your past copilot conversations for this agent so you can resume one.
* Rate any answer with **thumbs up or down** to help improve responses.

The copilot is available on desktop.


# Analytics
Source: https://docs.totebot.ai/dashboard/analytics

Track performance and optimize results

The Analytics section becomes essential once your Totebot is live. It gives you a single read on volume, quality, revenue, and insights on one scrolling page. A sticky header at the top lets you jump between sections and set the date range.

<img alt="Totebot Analytics Dashboard" />

## Engagement

Volume metrics for the selected period:

* **Conversations**: total conversations.
* **Unique users**: number of individual users who interacted with the agent.
* **Messages**: total messages exchanged.
* **Messages per conversation**: average conversation length.

## Quality

How well the agent handles conversations on its own:

* **Quick resolution rate**: share of conversations resolved in a few messages.
* **Friction rate**: share of conversations where users showed signs of frustration.
* **Negative sentiment rate**: share of conversations with negative sentiment.
* **Containment rate**: share of conversations the agent handled without human help.

## Revenue & Commerce

If a Shopify or WooCommerce store is connected, this section shows the agent's business impact:

* **Products added to cart**: products added after an AI-assisted interaction.
* **Checkout starts**: checkouts initiated through the agent. (This does not equal completed purchases.)
* **Revenue generated**: total revenue attributed to purchases initiated through Totebot conversations, with a daily breakdown.

## Insights

<img alt="Conversation insights" />

* **Sentiment analysis**: the emotional tone behind user messages.
* **Intent analysis**: the core purpose behind each conversation (product inquiry, pricing, support), with a confidence score.
* **Top questions**: common customer questions grouped by similarity.
* **Product insights**: the products mentioned most frequently in conversations, with sentiment and context.

This section also shows **Suggested messages**, so you can see how often your quick-start suggestions were used.

<Note>Insights are available on the **Pro** and **Scale** plans.</Note>

## Knowledge gaps

On the **Pro** and **Scale** plans, the Analytics header shows a knowledge-gap count that links to a dedicated **Gaps** page. It lists questions your agent couldn't answer well, so you can turn recurring ones into knowledge sources or Q\&A pairs.


# Atlas
Source: https://docs.totebot.ai/dashboard/atlas

A visual map of everything connected to your agent

**Atlas** is a visual map of your agent's setup. It shows the model, knowledge, channels, integrations, and actions in one view, so you can see how your agent is configured at a glance and jump straight to any part of it.

Open it from **Atlas** in your agent's sidebar.

<img alt="Agent Atlas" />

## The map

At the center is your agent, with its **Trained / Not trained** and **Live / Draft** status. Around it, nodes are grouped into zones:

* **Core**: the **Model** (with temperature) and the **Knowledge** base (with training status and size).
* **Channels**: each connected channel: Web, WhatsApp, Telegram, Email.
* **Integrations**: each enabled integration: Shopify, WooCommerce, Custom Webshop, MyRent, Meta, Google.
* **Capabilities**: enabled AI actions (Leads, Email, Web search, API call, Button) and the Help Desk, which appears here when the agent's Support Handover action is enabled.

Each node shows its current status. Click any node to open its settings, and click the center card to open **Settings → AI**.

On desktop, Atlas draws connecting lines from your agent to each node. On mobile, it becomes a grouped list by zone.

## Add a capability

Use **Add capability** in the top right to connect something new. The menu links you to:

* **Connect a channel**
* **Connect an integration**
* **Add an AI action**
* **Enable Help Desk**

It only offers what you haven't set up yet, so it doubles as a checklist for getting more out of your agent.


# Audit Log
Source: https://docs.totebot.ai/dashboard/audit-log

A record of every change made to your agent

The **Audit Log** records changes made to your agent, so you can see who changed what and when. It's useful for teams that need accountability and a history of configuration changes.

Open it from **Audit Log** in your agent's sidebar.

<Note>The Audit Log is available on the **Scale** plan.</Note>

## What's recorded

The log captures changes across your agent, grouped into categories:

* **Agent**: settings, AI configuration, security, email capture, chat interface, notifications, API key generated or revoked, and auto-retrain changes.
* **Integration**: integrations and channels connected, updated, or removed.
* **Knowledge**: knowledge sources added or removed, and retraining triggered.
* **Product / Order / Cart**: store events synced from Shopify and WooCommerce (products created, updated, or deleted; orders created; cart updates) and custom webshop product syncs.

## Reading the log

Each row shows the **Event** (a plain description of what happened), its **Category**, the **User** who did it, and the **Date**. The actor can be a team member, a connected system (for example Shopify or WooCommerce), or the system itself.

Open a row to see full details, including a before-and-after for each changed field, the exact timestamp, and who made the change.

## Filtering

Filter by **Category** (Agent, Integration, Knowledge, Product, Order, Cart) or **search** the event descriptions to find a specific change.


# Compare
Source: https://docs.totebot.ai/dashboard/compare

A/B test models, temperature, and instructions side by side

**Compare** runs the same prompt against up to three versions of your agent at once, so you can see how different models, temperatures, or instructions respond before you commit to a setup.

Open it from the **Compare** button on the [Overview](/dashboard/overview) page, or from your agent's sidebar.

<img alt="Compare instances side by side" />

## How it works

* You start with two instances side by side and can **Add an instance** for a third.
* With **Sync** on (the default), one input box sends the same message to every instance at once, so you can compare answers head to head.
* Turn **Sync** off to message each instance independently.
* **Clear all chats** resets the conversations; **Reset** restores the instances to your agent's current settings.

## Tune each instance

Click the gear on any instance to change, just for that column:

* **Model**: pick any model available on your plan.
* **Temperature**: from focused (low) to creative (high). Some models use a fixed temperature.
* **Instructions**: try a different system prompt.
* **Skills**: toggle individual skills on or off.

Changing a setting clears that instance's chat so the next prompt reflects the new configuration.

## What it's for

Use Compare to choose the model with the best balance of quality and cost, to tune tone by testing stricter versus looser instructions, and to confirm a change improves answers before you apply it to your live agent in **Settings → AI**.


# Conversations
Source: https://docs.totebot.ai/dashboard/conversations

Review and improve AI agent interactions

This section is closely connected to Analytics. In **Conversations**, you can review every response your AI agent has given to users. It's the best way to understand how your agent communicates and to improve its performance over time.

<img alt="Conversations Dashboard" />

You can read each conversation; those you haven't read yet will be marked with a blue dot. If you click on the three dots, you have an option to mark all as read or delete them.

## Message Feedback

Users can now rate and provide feedback on AI responses directly in the chat. This feedback is visible in the conversation view, helping you identify which responses are working well and which need improvement. You can also copy message content for easier sharing or analysis.

## Conversation Filtering

Conversations can be sorted by:

* **Source**: Web (Preview), Web (Embed), Telegram, WhatsApp, Email
* **Status**: Unread, Read
* **Sentiment**: Positive, Neutral, Negative
* **Product**: All listed products
* **Purchased**: Yes, No

For each message, you can view:

* When it was sent
* The sentiment detected
* The platform it came from

By clicking on a specific message, you'll see details at the top such as the sender (if they have an account), the platform, and the sentiment.

## Revise answers for better future replies

If a response isn't ideal, click **Revise Answer** to provide a better version. The AI agent will remember your revision and use it for similar questions in the future.

The original message history will stay the same, but future responses will reflect your updated version, helping the agent get smarter with every correction.

<img alt="totebot ai improving answer" />

## Purchase Indicator

In addition to reviewing customer questions and AI agent replies, you'll also see a **purchase indicator** that highlights which conversations directly led to a sale.

* These chats are differentiated from regular conversations, making it easy to spot the ones that ended in revenue.
* The indicator helps you quickly identify which customer interactions were most effective in driving purchases.
* By analyzing these conversations, you can learn what answers, product recommendations, or guidance contributed to a sale, and apply those insights to improve future interactions.

<img alt="totebot purchase ndicator " />


# Customers
Source: https://docs.totebot.ai/dashboard/customers

See everyone who has talked to your agent, with their history and value

The **Customers** page lists everyone who has interacted with your agent, across every channel, with their conversation history and (for stores) the revenue they generated.

To open it, click **Customers** in your agent's sidebar.

<Note>Customers is available to team **owners**.</Note>

## Customer list

Each row shows the customer's **Name**, **Chats count**, and **Latest chat**. You can:

* **Search** by name or message.
* **Sort** by A-Z, Z-A, Latest chat (default), or Chats count.
* **Filter** by whether they have chats: All, Any, or None.

Customers who never identified themselves appear as **Anonymous (#XXXX)**, using the last four characters of their anonymous ID. Identified customers show their name, email, or phone.

## Customer detail

Open a customer to see their full profile:

* **Header**: name, email or phone, the channels they used (Web, Email, Telegram, WhatsApp), when they became a customer, and when they were last active.
* **Stats**: Chats, Messages, and (with a Shopify store) Revenue.
* **Info tab**: analytics for this customer (agent opens, chats, messages, and store metrics like cart adds, checkout starts, and revenue), conversation **Insights** (sentiment and top intents), and a **Purchases** table (Shopify) with order ID, amount, date, and links to the conversation and the order.
* **Conversations tab**: every conversation with this customer, with source, date, sentiment, and a preview.

## How customers are identified

Anyone who messages your agent becomes a customer. Anonymous visitors are tracked by an anonymous ID. To recognize signed-in users across sessions and channels, pass a verified identity from your site using the [Web SDK](/api/web-sdk#identify-a-user); the customer's name and email then show on their profile.


# Help Desk
Source: https://docs.totebot.ai/dashboard/help-desk

One team inbox for support tickets escalated from every agent

The Help Desk is your team's shared inbox for support tickets. When an agent can't resolve something on its own, it escalates the conversation into a ticket. Every agent on your team feeds the same inbox, so your operators work from one place no matter which agent or channel the request came from.

The Help Desk lives at the **team level**, in the workspace sidebar next to **Agents**, **Usage**, **Billing**, and **Members**. Open it from **Help Desk** in the sidebar.

<Note>The Help Desk is available on **Pro** and **Scale** plans.</Note>

## How it works

<Steps>
  <Step title="A conversation becomes a ticket">
    A ticket is created when an agent escalates a conversation. This happens when the customer asks for a human, or when the agent has tried and can't resolve the issue. You enable escalation per agent with the **Support Handover** action (see [Per-agent handover](#per-agent-handover) below).

    The conversation keeps running as normal while the ticket waits in the inbox, so the customer is never left in silence. The ticket records which agent escalated it, the original channel, and the requester's details.
  </Step>

  <Step title="The ticket lands in the team inbox">
    Tickets appear in the Help Desk inbox grouped by status. Each row shows the status, ticket number, requester, assignee, subject, the source agent, priority, channel, and the last activity time.

    Depending on your team's assignment method, a ticket either stays unassigned until someone picks it up, or is routed to an available teammate automatically.
  </Step>

  <Step title="An operator replies">
    Open a ticket to see one unified timeline: the full conversation history (the AI messages and any earlier human replies), internal team notes, and a record of what happened to the ticket (assignments, takeovers, status changes, resolutions), all in the order they occurred. Each message shows the channel it came in on.

    Reply from the composer at the bottom, which has two modes:

    * **Reply**: goes to the customer. The composer picks the right channel for you and shows it in a selector you can change. If the customer is live on the web widget, Telegram, or WhatsApp, click **Take over the chat** to pause the AI and reply live there; otherwise the reply is emailed to the customer when an address is on file.
    * **Note**: an internal note only your team can see. Notes appear inline in the timeline, so the next operator has the full context.
  </Step>

  <Step title="Resolve or hand back to the agent">
    When you're done, click **Resolve** to close the ticket. If you took the conversation over live, you can click **Hand back to AI** to return control to the agent so it continues the conversation as normal.
  </Step>
</Steps>

## The inbox

The inbox organizes tickets into views so operators can focus on what's theirs:

* **Assigned to me**: tickets currently assigned to you
* **All**: every ticket in the team inbox
* **Unassigned**: tickets waiting for someone to pick them up
* **Resolved**: tickets that have been closed

Each ticket moves through statuses as it's handled: **Submitted**, **In progress**, **Waiting on customer**, and **Resolved**.

## Operators

Operators are the team members who handle tickets. Each operator has a display name that customers see on live replies, a sending email address for email replies, an optional email signature, and an availability status (online, away, busy, or offline) that the Help Desk uses when routing new tickets.

## Across all channels

The Help Desk works across every connected channel. A request from Telegram, WhatsApp, email, or the web widget appears in the same inbox. When you reply, the composer sends on the right channel for the conversation: the live web, Telegram, or WhatsApp chat once you take it over, or email when an address is on file. You can switch the channel from the selector in the composer.

Customers can also follow their own tickets from the web widget. The widget's menu has a **View tickets** option that lists their open and closed tickets with the current status, so they can check progress without contacting you again.

## Ask the AI copilot

The [AI copilot](/dashboard/ai-copilot) can read your Help Desk tickets, so you can check the inbox from a chat instead of switching pages. Ask it things like "what tickets are open?" or "show me ticket 10042" and it lists or opens tickets for you.

What it shows follows your role. Team owners and managers see the whole team inbox. Operators see the tickets assigned to them.

<Note>The copilot reads tickets only. It cannot reply to, assign, or resolve them, so use the inbox for those actions. Reading tickets needs the Help Desk, so it works on **Pro** and **Scale** plans.</Note>

## Settings

Open **Help Desk** → **Settings** to configure the inbox. Settings are split into three tabs.

### General

* **Business hours**: only show the human button during working hours (Monday to Friday). When enabled, set your start and end time and your team's timezone.
* **Email notifications**: email all team owners when a customer requests a human agent, so no ticket is missed.

### Assignment

Choose how new tickets are assigned to your team:

* **Manual**: tickets stay unassigned until a teammate picks them up or you assign them.
* **Balanced**: new tickets go to the available teammate with the fewest open tickets. This is the default.
* **Round robin**: new tickets are handed out one by one to available teammates in rotation.

### Email

* **Support inbox**: turn inbound email into tickets, handled by your team with no AI. When enabled, emails sent to your support address open a ticket in the inbox.

## Per-agent handover

Escalation to the Help Desk is set up per agent through the **Support Handover** action in the agent's **AI Actions**. Add it to any agent you want to be able to create tickets. Its options control how and when a conversation is handed to your team:

* **When to use**: guidance that tells the agent when to escalate.
* **Default priority**: the priority new tickets from this agent start at.
* **Human button**: show a button in the chat widget that lets customers ask for a human directly.
* **Message threshold**: how many messages are exchanged before the human button appears, so the agent can try to resolve the issue first.
* **Waiting and connected labels**: the messages shown to the customer while they wait for, and once they're connected to, a person.
* **Auto-reply message**: shown when no one is available, inviting the customer to leave a message for the team to follow up on.


# Insights
Source: https://docs.totebot.ai/dashboard/insights

Understand user interactions through sentiment and intent analysis

When you open individual conversations, you'll see detailed insights that help you better understand how users interact with your AI agent through sentiment and intent analysis. These insights appear within each conversation view.

<Note>AI Insights and Knowledge gaps are available on the **Pro** and **Scale** plans. Basic analytics are available from the **Basic** plan.</Note>

## Sentiment Analysis

Sentiment scores reflect the emotional tone of the conversation:

* Scores between -1 and 0 are considered negative
* A score of 0 is neutral
* Scores between 0 and 1 are positive

This reflects the AI agent's interpretation of user satisfaction, based on the emotional tone and sentiment expressed in their messages.

<img alt="totebot ai conversations sentiment" />

## Intent & Interest Tracking

You'll also see:

* **Intent Score**: how confident the AI is about what the user is trying to achieve (e.g., asking about pricing, looking for support, etc.)
* **Primary and Secondary Interest**: the main topics or products users are interested in during the conversation

## Product Insights

If a Shopify or WooCommerce store is connected, you'll see **Product Insights** within conversation details, highlighting which products your customers are interested in during conversations and which products the AI agent suggested.

You can also find aggregate **Top Product Insights** in the Analytics dashboard, showing which products customers ask about most frequently across all conversations.


# Knowledge
Source: https://docs.totebot.ai/dashboard/knowledge

Train your AI agent with relevant content

As mentioned earlier, filling your AI agent with the right knowledge should be one of the first steps in setting it up. This section explains how to do it in detail.

<img alt="Knowledge Interface" />

Navigate to the left-hand menu and click on **Knowledge**. The Overview page summarizes all your sources and training status, with dedicated sub-pages for each of the four ways to add information your AI agent uses to answer customer questions accurately:

## Files

Upload comprehensive documents or structured content to your AI's knowledge base. This includes .pdf, .doc, .docx, or .txt files containing valuable information about your products, policies, company, or anything else relevant to your customers.

**Why it's useful:** Perfect for adding bulk information like product catalogs, policy documents, user manuals, and other comprehensive resources that provide detailed context to your agent.

## Text

Add information quickly by typing or pasting text directly. Perfect for short-form content and quick updates.

**Why it's useful:** Ideal when you need to add specific information without creating a document, or when you want to paste content from other sources. Great for quick knowledge base updates and adding brand-specific messaging.

## Website

Automatically import content from your website pages by adding a URL. Your AI will learn from the page content.

**Why it's useful:** Saves time by pulling information directly from your existing web pages. Ensures your agent has access to your latest blog posts, product pages, policies, and other web content without manual copying.

## Questions & Answers

Update your AI's knowledge base with specific question-answer pairs to ensure accurate responses to particular queries.

**Why it's useful:** Provides exact, controlled answers to frequently asked questions. This is especially helpful when your existing documents don't cover certain topics well, or when you need to ensure specific brand-approved responses to common customer questions.

<Note>
  You don't need to fill in all four sections. Often, just one or two will be enough depending on how well your information is structured and presented. Choose the method that best fits your content and workflow.
</Note>

After adding new content, click **Train agent** to update your AI agent with the new knowledge.

## Knowledge Gaps

On the **Pro** and **Scale** plans, Totebot also tracks questions your agent couldn't answer well. Open the **Gaps** page from the knowledge-gap count in the Analytics header, and turn recurring ones into new knowledge sources or Q\&A pairs.

## Failed Knowledge Sources

If any knowledge sources fail to process (due to format issues, connectivity problems, or other errors), they will be tracked separately with clear error messages. You can access these through an interactive modal that allows you to:

* View detailed error information
* Retry processing failed sources
* Remove sources that are no longer needed

This feature ensures you always have visibility into your knowledge base status and can quickly resolve any issues that prevent content from being added to your AI agent.


# Overview
Source: https://docs.totebot.ai/dashboard/overview

Your agent at a glance, with a live preview to test it

**Overview** is the first page in your agent's sidebar. It gives you an at-a-glance summary of your agent and a live preview to test it in real time.

<img alt="Agent Overview" />

## At a glance

The top of the page shows your agent's name and status:

* **Training status**: whether the agent is **Trained** or still needs training.
* **Live / Draft**: whether the agent is publicly accessible.
* **Compare**: opens the Compare view to test different models, temperatures, or instructions side by side.

Below that, four key metrics for the last 30 days:

* **Conversations**: total conversations.
* **Resolution rate**: share of conversations the agent resolved quickly.
* **Containment**: share handled without human help.
* **Messages (30d)**: messages exchanged.

## Summary cards

* **Agent configuration**: the current model, temperature, and language. Click **Edit** to jump to **Settings → AI**.
* **Knowledge base**: how many files, Q\&A, links, and text entries the agent is trained on, with its training status. Click through to the [Knowledge](/dashboard/knowledge) section.
* **Connected**: the channels and integrations currently enabled. Use **Add capability** to connect more.

## Live preview

The panel on the right is a live, working copy of your agent. Use it to test how the agent responds before and after changes, exactly as a customer would see it.

If the agent isn't answering the way you'd like, add the question and a clear, brand-specific answer in the [Knowledge](/dashboard/knowledge) section, then retrain.

### Example: make answers specific

If you ask "What materials do you use for your products?" and the agent replies with something vague like "We use high-quality materials," add a Q\&A with the exact answer, for example: "We use certified Canadian maple wood, processed in Quebec and shipped worldwide."

### Example: match your brand voice

If the agent opens with a generic "Hi. How can I help you?", set a greeting that fits your brand in **Settings → Chat Interface**, for example: "Hi there. Looking for the perfect snowboard? I've got you covered."


# Settings
Source: https://docs.totebot.ai/dashboard/settings

Configure your Totebot agent settings

## General

<img alt="General Settings" />

In the General tab, you can manage your agent's basic settings:

**AI Agent name**
A default name will be assigned to your AI Agent, but you can change it at any time to better match your brand.

**Automatic Retraining**
On the **Scale** plan, you can enable automatic retraining every 24 hours. If this option is not enabled, your agent only retrains when you add new information and click **Train agent** in the Knowledge section.

**Delete Agent**
If the agent is no longer useful, you can delete it. However, we recommend saving its data first in case you want to reuse it later.

## AI

### Model

Choose which AI model powers your agent. Totebot supports models from **OpenAI** (GPT-5 family and GPT-4o), **Anthropic** (Claude Opus, Sonnet, and Haiku), **Google** (Gemini 2.0, 2.5, and 3), **Mistral**, and **xAI** (Grok). The picker shows every model currently available on your plan.

As a rule of thumb:

* **Larger models** (e.g. Claude Opus, GPT-5) give the highest answer quality for complex or nuanced conversations.
* **Balanced models** (e.g. Claude Sonnet, Gemini Flash) offer a strong mix of quality, speed, and cost, a good default for most stores.
* **Smaller, faster models** (e.g. Claude Haiku, GPT-5 Mini/Nano) are the cheapest and fastest, ideal for high-volume, straightforward support.

You can switch models at any time; the change applies to new messages immediately.

### Creativity (temperature)

Temperature controls how creative or deterministic your agent's replies are, on a scale from 0 to 2:

* **Lower (around 0 to 0.3)**: focused, consistent, predictable answers. Best for customer support and factual responses.
* **Higher (around 0.7 to 1)**: more varied, creative phrasing. Useful for marketing-style or conversational tones.

For most support and sales agents we recommend keeping temperature low so answers stay accurate and on-brand.

### Instructions

Make sure to write a specific description that will help your agent provide better answers and deliver more value to your business.

We recommend including details such as:

* **Role**: define what the agent should act as (e.g., *"AI shopping agent"* or *"customer support agent"*).
* **Standards**: set the tone, style, and level of detail you expect in replies (e.g., *"friendly and concise"* or *"professional and thorough"*).
* **Values**: reflect your brand's principles (e.g., *"always helpful,"* *"honest about product availability," "focused on customer satisfaction"*).

By adding these instructions, your agent will align more closely with your brand identity and provide more accurate, consistent, and helpful responses for your customers.

<img alt="totebot ai agent settings ai" />

### Language

Totebot supports 95+ languages. Here you can specify the primary language your agent will use for its responses.

Setting a primary language ensures your agent replies consistently and matches your customers' expectations. If needed, you can later add additional languages or switch to another supported language, depending on your audience.

Totebot can also reply in more than one language, automatically adapting to the language your customers speak during the conversation.

### Skills

The AI tab also hosts your agent's skills: reusable instructions that tell the agent how to behave in specific situations. See [Agent Skills](/dashboard/agent-skills) for details.

## Chat Interface

The Chat Interface section lets you fully customize how your agent looks and behaves on your website. This is where you adapt Totebot to reflect your brand. You can control both the visual design and the conversation settings to make sure the agent feels natural and aligned with your business.

### General Settings

* **Agent name and profile image**: Give your agent a name and add a profile image or logo. This helps personalize the interaction and ensures it reflects your brand identity. For example, a beauty store might name the agent "Beauty Agent" with a logo of a lipstick, while a tech shop might use their company logo.
* **Colors and design**: Customize the chat bubble color and text color. As you adjust them, you'll see a live preview on the right-hand side. This makes it easy to experiment until you find the right look. A key tip: make sure your text is highly visible against the background to avoid readability issues.
* **Chat bubble placement**: Decide whether the bubble should appear on the left or right side of the screen, depending on your site's design and user habits.
* **When the chat bubble appears**: You can control when the chat bubble shows up to visitors. For example, you might want it to appear immediately, or after a short delay so it's not too pushy. Think about your audience; sometimes a delayed appearance feels more natural and less intrusive.

  <img alt="totebot ai agent settings chat interface" />

### Content Settings

* **Welcome message**: Craft a greeting that matches your brand voice. This could be as simple as *"Hello, how can I help you today?"* or something more creative like *"Hi there! Looking for the perfect snowboard? I've got you covered."*
* **Message timing**: Choose how soon the welcome message appears after a visitor lands on your site. Often it's better to add a short delay so the message feels contextual rather than immediate.
* **Suggestions**: In the settings, you can add "suggestions", pre-set options that appear to guide users in starting a conversation (for example: *"Browse products", "Check shipping policy", "Talk to support"*). These can help reduce friction by showing visitors what kind of questions they can ask.

<img alt="totebot ai agent settings chat interface " />

### Labels

The Labels section (within Chat Interface) allows you to customize the text shown in different parts of your chatbot interface. These small adjustments are important because they help the agent feel on-brand, natural, and easy to use for your customers.

* **Input box placeholder**: This is the text that appears in the input field before a customer types anything (e.g., *"Type your question here…"*). A clear placeholder encourages users to start interacting.
* **Suggested messages heading**: Shown above the suggestion buttons, this text sets context for quick-start options (e.g., *"Popular questions"* or *"Quick links"*).
* **New Chat Button Label**: The text on the button customers use to start a new conversation. Make it clear and friendly (e.g., *"Start a new chat"*).
* **View Chats Label**: The label customers see when they want to return to past conversations. Keep it simple, like *"View conversations"*.
* **No Conversations Label**: Displayed when there are no past chats. For example, "*No conversations yet".*
* **No Conversations Description**: This text gives extra context when the chat history is empty. Example: *"Once you start chatting, your conversations will appear here."*
* **Start New Conversation Button Label**: Another button for beginning a fresh interaction. Could be labeled as *"Start chatting"* or *"Ask a question".*
* **Messages View Title**: The title displayed at the top of the chat window. Often set as *"Chat with us"* or *"Customer Support".*
* **My Cart Label**: Shown when the agent displays the shopping cart (e.g., *"My Cart"* or *"Your Basket"*).
* **Empty Cart Label**: Text displayed when the cart is empty, e.g., *"Your cart is currently empty."*
* **Checkout Button Label**: The label on the button that moves the customer to checkout, e.g., *"Proceed to Checkout".*
* **View Product Button Label**: The button label when displaying product details. Example: *"View Product"* or *"See Details".*
* **View in Store Button Label**: Opens the product page in your store. Keep it action-driven, e.g., *"View in Store".*
* **Add to Cart Button Label**: The text for adding items to the shopping cart. Example: *"Add to Cart"* or *"Add Item".*
* **Quantity Label**: Shown when adjusting product quantities, e.g., *"Quantity".*

## Security

The Security section allows you to control who can access your Totebot agent and how often they can interact with it. These settings help you balance accessibility with protection against abuse or spam.

### Access control and rate limiting

**Public access**
By default, your agent is publicly accessible. Toggle this off if you want to limit it to specific environments.

**Request limit per visitor**
The maximum number of messages a visitor can send within the time window.

**Time window (seconds)**
How long, in seconds, before the limit resets.

**Limit reached message**
What visitors see when they reach the message limit. Keep it informative and on-brand, for example: *"Rate limit exceeded. Please try again later."*

### Public API key

The Security tab is also where you generate and revoke your agent's Public API key. See the [Public API](/api/public-api) guide for usage.

<img alt="totebot ai agent settings security" />

## Email capture

This feature lets you collect customer email addresses directly within the chat. It's useful for capturing leads, following up on inquiries, and reconnecting with customers outside the conversation.

The Email capture page has two tabs: **Setup** for configuring the prompt, and **Captured emails** for reviewing the addresses you've collected.

### Setup

* **Ask user to provide e-mail address**: when enabled, the agent prompts the visitor for an email after their first question.
* **Prevent user from using chatbot without providing e-mail address**: blocks access to the agent until the visitor enters a valid email. Leave this off to let visitors skip.
* **Incentivize user to provide e-mail address with a discount code**: sends a discount code to the visitor's email after they submit it. You can choose:
  * **Automatic code creation**: a one-time discount code is created on your Shopify store and sent to the user.
  * **Manual code creation**: enter a code and discount percentage yourself, and the agent sends it.

### Captured emails

Collected addresses appear under the **Captured emails** tab, and can also be accessed via the [Public API](/api/public-api).

<img alt="totebot ai agent settings email" />


# Team & Billing
Source: https://docs.totebot.ai/dashboard/team-and-billing

Manage your workspace, members, usage, and subscription

Your **workspace** holds your agents, team members, and subscription. These pages live at the team level, in the sidebar when you're not inside an agent: **Members**, **Usage**, **Billing**, and **Settings**.

## Members

Manage who has access to the workspace. Each member is either:

* **Owner**: full access to team settings, members, and billing.
* **Member**: can view and use team resources.

Owners can **Add member** (enter an email and pick a role), change a member's role, or remove them. Pending invitations show an **Invited** status until accepted. The number of seats depends on your plan (1 on Free, 3 on Basic, 5 on Pro, unlimited on Scale).

## Usage

See how much of your plan you've used in the current period:

* **Messages**: a progress bar of messages used against your monthly allowance. Messages reset on the first of each calendar month, regardless of your subscription date.
* **Extra messages (Pay as you go)**: if enabled, the cost of messages used beyond your allowance.
* **Agents and knowledge**: how many agents you've created and how much knowledge you've used.
* **Daily message usage**: a breakdown by day and by agent, with a date-range picker.

## Billing

<img alt="Billing plans" />

The Billing page has two tabs.

**Plans**: compare Free, Basic, Pro, and Scale, toggle monthly or yearly billing, and **Upgrade**, **Downgrade**, or **Subscribe**. This is also where you turn on **Pay as you go** and set a maximum monthly budget for overage messages. Enterprise options are listed below the plans.

**Billing**: your current plan and status, plan limits (messages, members, agents, knowledge, sitemap URLs), payment method (Stripe or Shopify Billing) with **Manage Billing**, the notification email for billing messages, and your **Billing history**.

Trials, upgrades, downgrades, and cancellations are all handled here. See [Pricing](https://totebot.ai/pricing) for the full plan comparison.

## Pay as you go

Pay as you go lets your agents keep answering after you've used your monthly message allowance, instead of stopping at the limit. Extra messages are billed at \$0.04 each, up to a maximum budget you choose.

### Turn it on

1. Open **Billing** and go to the **Plans** tab.
2. In the **Pay As You Go** card, switch it on.
3. Enter a **Maximum budget** in dollars and click **Save**.

You need a paid plan and a payment method on file. Pay as you go isn't available on Free. If you're billed through Stripe and haven't added a card yet, you'll be asked to add one first. Teams billed through Shopify are covered by their existing app charge.

### How it works

* Messages within your monthly allowance count toward your plan as usual. Once the allowance runs out, each extra message costs \$0.04.
* The **maximum budget** is a hard cap. When your extra-message spend reaches it, further messages stop until the budget resets on the first of the next month, or until you raise it.
* Extra messages are charged to your existing payment method (your Stripe card, or added to your Shopify bill) as they're used.
* Your monthly allowance and your pay-as-you-go spend both reset on the first of each calendar month.
* The **Usage** page shows what you've spent on extra messages. You can change the budget or switch Pay as you go off at any time.

## Settings

The team **Settings** page holds your **Team name** and **Team slug**. Owners can edit these; members can view them.


# Frequently Asked Questions
Source: https://docs.totebot.ai/frequently-asked-questions

Common questions about Totebot, the AI agent for customer support and sales

## General

<AccordionGroup>
  <Accordion title="What is Totebot?">
    Totebot is an AI agent that handles customer support and sales for your business, wherever your customers are. It answers questions, recommends products, captures leads, takes bookings, and closes sales in the same conversation, across your website, WhatsApp, Telegram, and email. When a person is needed, it hands the conversation to your team.
  </Accordion>

  <Accordion title="How does Totebot help my business?">
    Totebot answers customer questions instantly, guides people to what they need, and can take action (add to cart, capture a lead, book a demo) right in the chat. This deflects repetitive support, increases conversions, and frees your team for higher-value work.

    **Key benefits:**

    * 24/7 customer support across channels
    * Faster product and answer discovery
    * Personalized recommendations
    * Higher conversion rates
    * Human handover when it matters
  </Accordion>

  <Accordion title="What kinds of businesses use Totebot?">
    Online stores (Shopify, WooCommerce, or a custom store), property rentals, support teams, and services or B2B companies. Small businesses can start for free, and larger teams scale up with more agents, deeper analytics, and integrations.
  </Accordion>

  <Accordion title="Do I need to be an e-commerce store to use Totebot?">
    No. Any business that wants to answer questions, capture leads, or provide 24/7 support can use Totebot. The e-commerce features, such as product catalog search, cart management, and checkout, apply when you connect a store (Shopify, WooCommerce, or a custom webshop), but they're optional.
  </Accordion>

  <Accordion title="Can Totebot hand off to a human?">
    Yes. When an agent can't resolve something, it escalates the conversation into a support ticket in your team's Help Desk. An operator can reply by email or take the conversation over live, with replies routed back through the customer's original channel. Escalation can be triggered by the customer asking for a human, or by the agent when it can't resolve the issue.
  </Accordion>

  <Accordion title="How long does it take to set up Totebot?">
    You can go live quickly. Connect a channel or store, add some knowledge, and the agent is ready. Shopify connects in one click; other channels and stores connect from the dashboard. You can keep refining at your own pace.
  </Accordion>

  <Accordion title="Do I need coding skills to use it?">
    No coding skills are required. Everything is handled through an intuitive dashboard with clear options for training, customization, and integrations.
  </Accordion>

  <Accordion title="How much does Totebot cost?">
    Totebot has four plans:

    * **Free (\$0)**: 50 messages/month
    * **Basic (\$49/month)**: 1,000 messages/month, basic analytics
    * **Pro (\$149/month)**: 6,000 messages/month, AI insights, Help Desk
    * **Scale (\$399/month)**: 20,000 messages/month, built for larger businesses

    Past your allowance, extra messages cost a flat \$0.04 each on every plan. Yearly billing saves 20%, and every paid plan starts with a 30-day free trial. See the [Pricing](https://totebot.ai/pricing) page for the full feature breakdown.
  </Accordion>
</AccordionGroup>

## Features & Usage

<AccordionGroup>
  <Accordion title="What platforms can I use Totebot on?">
    Totebot works on:

    * Your website (via embed)
    * Shopify
    * WooCommerce
    * WhatsApp
    * Telegram
    * Email
    * And through the [Public API](/api/public-api), it can connect to custom platforms.
  </Accordion>

  <Accordion title="How does Totebot understand what to answer?">
    It uses the knowledge you give it (documents, FAQs, links, and text), plus your product catalog if you connect a store, combined with leading AI models that interpret customer questions in natural language.
  </Accordion>

  <Accordion title="What is the Knowledge section and how do I use it?">
    The Knowledge section is your agent's memory. You fill it with:

    * Uploaded files (PDFs, docs, catalogs)
    * Text entries
    * Links to your pages or policies
    * Q\&A pairs for specific questions

    Your agent uses this to provide brand-aligned, accurate answers.
  </Accordion>

  <Accordion title="Can I train the agent myself?">
    Yes, you can and should. Training is done through the dashboard by adding or updating Knowledge content. The more relevant data you provide, the smarter and more helpful your agent becomes.
  </Accordion>

  <Accordion title="Can Totebot handle multiple languages?">
    Yes. Totebot supports 95+ languages and can reply in multiple languages depending on what your customers speak.
  </Accordion>

  <Accordion title="How does sentiment analysis work?">
    Totebot analyzes the emotional tone of each conversation and classifies it as positive, neutral, or negative. It also provides a confidence score, so you know how certain the AI is about its reading.
  </Accordion>

  <Accordion title="Can I customize the design of the chat widget?">
    Yes. You can adjust the agent's name, profile image, colors, light or dark theme, bubble placement, labels, and welcome messages, so it matches your brand. You can also enable voice input, attachments, message feedback, and per-page welcome messages.
  </Accordion>

  <Accordion title="What analytics does Totebot provide?">
    Analytics is one scrolling page with four areas:

    * **Engagement**: conversations, unique users, messages, messages per conversation
    * **Quality**: resolution rate, friction rate, negative sentiment rate, containment rate
    * **Revenue & Commerce** (with a connected store): products added to cart, checkout starts, revenue generated
    * **Insights** (Pro and Scale): sentiment, intent, top questions, and top product mentions
  </Accordion>

  <Accordion title="How many AI models does Totebot support, and can I choose between them?">
    Totebot supports a wide range of leading AI models from OpenAI (GPT-5 family and GPT-4o), Anthropic (Claude Opus, Sonnet, and Haiku), Google (Gemini 2.0, 2.5, and 3), Mistral, and xAI (Grok). You can switch between them anytime in your dashboard based on performance, cost, or use case. The model picker always shows the full, up-to-date list available on your plan.
  </Accordion>
</AccordionGroup>

## Integrations

<AccordionGroup>
  <Accordion title="Does Totebot integrate with Shopify?">
    Yes. Totebot has 1-click integration with Shopify. It can update carts in real time, read inventory, and allow customers to complete purchases inside the chat.
  </Accordion>

  <Accordion title="Can I connect Totebot with WooCommerce?">
    Yes. Totebot has a native WooCommerce integration: connect your store, install the Totebot AI plugin, and your agent gets your product catalog plus the chat widget on your storefront. See the [WooCommerce integration guide](/integrations/woocommerce).
  </Accordion>

  <Accordion title="My webshop is not built on Shopify or WooCommerce, can I still use Totebot?">
    Yes, absolutely! Totebot offers a Custom Webshop integration that works with any e-commerce platform. Our team will gladly help you with the integration and the whole setup.
  </Accordion>

  <Accordion title="Does Totebot work with WhatsApp and Telegram?">
    Yes. Customers can interact with your agent directly in WhatsApp or Telegram, giving you omnichannel reach.
  </Accordion>

  <Accordion title="What's the purpose of Meta (Facebook/Instagram) integration?">
    Meta integration allows your agent to send events (view product, add to cart, checkout, etc.) to Meta Ads Manager. This lets you build retargeting and lookalike audiences for ads.
  </Accordion>

  <Accordion title="How does Google integration work?">
    By connecting your Google Ads/Analytics account with a Measurement ID and API Secret, your agent can send user activity back to Google. You can then run retargeting campaigns and build audiences.
  </Accordion>

  <Accordion title="Can Totebot integrate with custom webshops or APIs?">
    Yes. Custom Webshop integrations are managed by our support team and can connect Totebot to custom stores or third-party catalogs. [Contact us](mailto:support@totebot.ai) to discuss your setup.
  </Accordion>
</AccordionGroup>

## Privacy & Security

<AccordionGroup>
  <Accordion title="What data does Totebot store from conversations?">
    Totebot keeps a record of conversation logs, which include customer questions, your agent's replies, and sentiment analysis results. If you enable it, your agent can also store optional contact details such as email addresses or phone numbers that customers provide.
  </Accordion>

  <Accordion title="Can I collect customer emails (or other contact details) through Totebot?">
    Yes. You can configure your agent to prompt customers for an email address during a chat (**Settings → Email capture**), and capture richer leads through an [AI Action](/dashboard/ai-actions). Collected contacts appear in your dashboard so your team can follow up.
  </Accordion>

  <Accordion title="Is my customer data secure?">
    Yes. Totebot follows modern security standards including encryption, authentication, and access controls to protect both your data and your customers' information.
  </Accordion>

  <Accordion title="Can I limit how often the agent can be used?">
    Yes. Security settings let you apply IP rate limits. You can set how many requests per IP are allowed in a given time window, and display a custom message when the limit is exceeded. This helps prevent spam and abuse.
  </Accordion>

  <Accordion title="How are Knowledge documents stored?">
    When you upload PDFs, text, links, or Q\&A entries into the Knowledge section, they're securely stored and indexed to train your agent. These documents are never shared outside your account and remain accessible only to your team within Totebot.
  </Accordion>

  <Accordion title="How is customer data managed and secured on your platform?">
    All data is handled with strict security measures. Conversation logs and customer details are encrypted in transit (while being sent) and at rest (when stored). Only authorized users with dashboard access can view this data. You also have full control to delete collected data at any time.
  </Accordion>
</AccordionGroup>

## Customization & Flexibility

<AccordionGroup>
  <Accordion title="Can I change the agent's welcome message?">
    Yes. In Content Settings (under Chat Interface), you can write any welcome message that matches your brand voice.
  </Accordion>

  <Accordion title="Can I customize labels like buttons and placeholders?">
    Yes. The Labels section (within Chat Interface settings) lets you rename elements such as Add to Cart, Checkout, Start Chat, etc.
  </Accordion>

  <Accordion title="Can I add multiple agents for different brands or use cases?">
    Yes. Free and Basic include 1 agent, Pro includes 2, and Scale includes 3. You can point each agent at a different brand, store, or use case.
  </Accordion>

  <Accordion title="Can I control how 'warm' or 'formal' the agent's responses are?">
    Yes. The Temperature setting lets you adjust response style, from reserved and precise to more creative and friendly.
  </Accordion>

  <Accordion title="Can I test different AI models to compare performance?">
    Yes. The Compare page in your dashboard runs the same conversation against different models, temperatures, or instructions side by side, so you can see which setup gives the best balance of quality and cost.
  </Accordion>
</AccordionGroup>

## Need More Help?

<CardGroup>
  <Card title="Contact Support" icon="envelope" href="mailto:info@Totebot.ai">
    Email us for personalized assistance
  </Card>

  <Card title="Getting Started" icon="rocket" href="/getting-started">
    Complete setup guide and tutorials
  </Card>
</CardGroup>


# User Guide: Set Up Your Agent
Source: https://docs.totebot.ai/getting-started

Complete setup guide for your Totebot AI agent

This is a complete guide to setting up and launching your first AI agent with Totebot, whether you run an online store, take bookings, or handle customer support.

## Step 1: Create an Account

<Steps>
  <Step title="Visit Totebot">
    Visit [Totebot.ai](https://Totebot.ai)
  </Step>

  <Step title="Sign In">
    Click **Sign In** in the top-right corner.

    <img alt="totebot ai account" />
  </Step>

  <Step title="Choose Login Method">
    Choose to log in with your email and password, or sign in with your Google account.

    <img alt="totebot register for free " />
  </Step>

  <Step title="Create AI Agent">
    Start creating your first AI Agent by clicking the **Create AI Agent** button.

    <img alt="Create AI Agent" />
  </Step>

  <Step title="Select your business type">
    Choose what best describes your business, then click **Continue**.

    <img alt="Select your business type" />

    Totebot works for online stores (Shopify, WooCommerce, or a custom store), property rentals, and support or services businesses with no online shop at all. If you have a store, have your website URL ready.
  </Step>
</Steps>

## Step 2: Connect a Store or Channel

Connect your agent to where your customers are. This guide uses **Shopify** as the example, but the same applies to the other options:

* **Stores**: [Shopify](/integrations/shopify), [WooCommerce](/integrations/woocommerce), or a [Custom Webshop](/integrations/custom-webshop)
* **Channels**: [Web Widget](/integrations/web-widget), [WhatsApp](/integrations/whatsapp), [Telegram](/integrations/telegram), or [Email](/integrations/email)

<Steps>
  <Step title="Enable Product Page Scanning">
    Let the agent scan product pages to enrich its answers. Click **Connect Shopify**.

    <img alt="totebot-ai-agent-shopify-account.JPG" />
  </Step>

  <Step title="Install App">
    You will be automatically redirected to your Shopify store. Click **Install**.

    <img alt="Install Shopify App" />
  </Step>

  <Step title="Confirm Connection">
    After installation, you'll be redirected back to your Totebot dashboard with a confirmation message that your Shopify store is connected.

    <img alt="Connected to Shopify" />
  </Step>

  <Step title="Verify Integration">
    You will land on the Integrations section of the Dashboard, where you'll confirm that your webshop is already connected. The name of your agent will be automatically assigned based on the name of your webshop; however, you can change it at any time if needed.

    <img alt="Integrations Dashboard" />
  </Step>

  <Step title="Check Status">
    If you click on the Settings gear, additional insights will open. Under **Status**, you can confirm once again that the Totebot app is enabled.

    <img alt="Integration Status" />
  </Step>

  <Step title="Verify in Store">
    Follow the provided link to open your Shopify store. You'll see a confirmation that Totebot is active, along with an indicator in the upper-left corner, and the chat widget displayed and ready to use.

    <img alt="Totebot Active in Store" />
  </Step>
</Steps>

## Step 3: Customize Your Agent

Start customizing by going to **Settings**, then selecting **Chat Interface**. In this section, we'll cover only the basic customization options.

### General Settings

<CardGroup>
  <Card title="Agent Identity" icon="user">
    Add an agent name and profile image
  </Card>

  <Card title="Visual Design" icon="palette">
    Customize bubble color, text color, and more, with a live preview on the right
  </Card>

  <Card title="Appearance Control" icon="eye">
    Choose when and how the chat bubble appears
  </Card>

  <Card title="Live Preview" icon="desktop">
    See changes in real-time as you customize
  </Card>
</CardGroup>

<img alt="Chat Interface Settings" />

### Content Settings

* **Welcome Message**: Write your welcome message
* **Timing**: Choose how soon it should appear after a visitor lands on your site
* **Suggestions**: Add quick-start options to guide user conversations

<img alt="totebot-ai-chat-interface-customize .JPG" />

Explore additional options for further fine-tuning. Click **Save** to apply changes.

## Step 4: Knowledge

Your AI agent learns from the information you provide in the Knowledge section.

<Steps>
  <Step title="Access Knowledge">
    In the left sidebar, click **Knowledge** and prepare the content for upload.
  </Step>

  <Step title="Add Content">
    <CardGroup>
      <Card title="Uploaded Files" icon="file-pdf">
        PDFs, product catalogs, or user manuals
      </Card>

      <Card title="Manual Text Entries" icon="text">
        Add and format content directly
      </Card>

      <Card title="Links" icon="link">
        Add URLs to your store pages, blog posts, policies, etc.
      </Card>

      <Card title="FAQs" icon="question">
        Include commonly asked questions with clear answers
      </Card>
    </CardGroup>
  </Step>

  <Step title="Train the agent">
    Once you've added content, click **Train agent** to update your AI agent with the new knowledge.
  </Step>
</Steps>

<Note>
  You can keep adding and updating your knowledge base over time. The more relevant info you include, the smarter and more helpful your Totebot becomes.
</Note>

## You're Ready

With these four steps, your first Totebot is up and running.

## Peak Performance Tips

Setting up Totebot is straightforward, but fine-tuning your Knowledge Base will make a huge difference in the quality of answers and customer experience. Here are some useful suggestions:

<AccordionGroup>
  <Accordion title="1. Prepare Documents Carefully" icon="file-check">
    Upload PDFs or other files that are clear, structured, and complete. Include product details, FAQs, policies, and guides. The better your documents are, the more precise the agent's replies will be.
  </Accordion>

  <Accordion title="2. Add Relevant Links" icon="link">
    Insert links to your website, blog, or policy pages. Make sure they point to accurate, up-to-date content, and remove any outdated or broken links so your agent doesn't serve old information.
  </Accordion>

  <Accordion title="3. Use Manual Q&A for Gaps" icon="question-circle">
    If customers often ask questions not covered by your documents or links, add them manually as specific Q\&A pairs. This ensures the agent always has an exact, brand-approved answer ready.
  </Accordion>

  <Accordion title="4. Monitor Analytics" icon="chart-line">
    Check engagement, sentiment, and performance in the analytics dashboard. This shows how well your agent is performing and where it may need improvement.
  </Accordion>

  <Accordion title="5. Review Conversations Regularly" icon="comments">
    Go through past conversations to see if customers are getting the right answers. Use the **Revise Answer** option to improve replies and help your agent learn over time.
  </Accordion>

  <Accordion title="6. Track Conversions" icon="shopping-cart">
    Pay attention to how your agent contributes to sales, such as add-to-cart events, initiated checkouts, or generated leads. This helps you see the real business impact.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup>
  <Card title="AI Actions" icon="bolt" href="/dashboard/ai-actions">
    Automate tasks like sending emails and generating leads
  </Card>

  <Card title="Integrations" icon="plug" href="/integrations/web-widget">
    Connect Totebot to channels, stores, and tracking platforms
  </Card>

  <Card title="Analytics" icon="chart-bar" href="/dashboard/analytics">
    Track performance and optimize results
  </Card>

  <Card title="Settings" icon="gear" href="/dashboard/settings">
    Fine-tune your agent's behavior and appearance
  </Card>
</CardGroup>


# Custom Webshop Integration
Source: https://docs.totebot.ai/integrations/custom-webshop

Custom webshop integration for Totebot, managed by our team.

The Custom Webshop integration connects your custom e-commerce platform with Totebot so your AI agent can search your products, manage carts, and help customers make purchases.

<Note>Custom Webshop is available on **Pro** and **Scale** plans.</Note>

<Note>
  Custom Webshop integrations are **managed by our support team**. To set one up for your store, contact us at [support@totebot.ai](mailto:support@totebot.ai?subject=Custom%20Webshop%20integration) with a brief description of your store and your product catalog format. We'll configure the connection, run validation, and enable the integration for your agent.
</Note>

The rest of this page documents the technical contract: the shape of the data your store needs to expose. Sharing this information ahead of your support request helps us configure the integration faster.

### Prerequisites

* A publicly reachable HTTPS endpoint (or product feed) that exposes your catalog. Our team will work with you on the exact format during setup; JSON, CSV, and XML feeds are all supported.

### What our team will set up

Once connected, your store will have three logical endpoints powering the integration:

* **Products endpoint**: paginated list of your full catalog.
* **Search endpoint**: text + filter search across your catalog.
* **Get-by-IDs endpoint**: bulk fetch of specific products.

These are managed for you. The sections below describe the shape of each one for reference.

### Products API

Your API must return products with pagination.

**Endpoint:**

```http theme={null}
GET {productsUrl}?page=1&limit=20
```

**Query Parameters:**

* `page`: 1-based page number (default: 1)
* `limit`: page size (default: 20, recommended up to 250)

**Response Format:**

```json theme={null}
{
  "products": [
    {
      "id": "123",
      "name": "Product name",
      "description": "Optional product description",
      "url": "https://shop.example.com/products/handle",
      "productType": "Shoes",
      "tags": ["summer", "running"],
      "status": "active",
      "availability": true,
      "price": { 
        "amount": 29.99, 
        "currency": "USD" 
      },
      "images": [
        { 
          "url": "https://example.com/image.jpg", 
          "altText": "Product image" 
        }
      ],
      "created_at": "2024-01-01T00:00:00.000Z",
      "updated_at": "2024-01-02T00:00:00.000Z",
      "attributes": {
        "color": "red",
        "size": "10"
      }
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 20,
    "total": 1000,
    "hasNextPage": true
  }
}
```

**Field Requirements:**

* **Required**: `id`, `name`, `url`, `status` (one of `active|archived|draft`), `availability` (boolean)
* **Recommended**: `description`, `productType`, `tags`, `price.amount`, `price.currency`, `images[]`, `created_at`, `updated_at`
* **Optional**: `attributes` (key-value pairs for custom fields)

### Search API

Your search API should handle product queries with optional filters.

**Endpoint:**

```http theme={null}
GET {searchUrl}?query=running shoes&filters[availability]=true&filters[price][min]=10&filters[price][max]=100&filters[productType]=Shoes&page=1&limit=10
```

**Query Parameters:**

* `query`: Search query string (required)
* `filters[availability]`: Filter by availability (boolean)
* `filters[price][min]`: Minimum price filter (number)
* `filters[price][max]`: Maximum price filter (number)
* `filters[productType]`: Filter by product type (string)
* `page`: 1-based page number (default: 1)
* `limit`: page size (default: 10)

**Response Format:**

```json theme={null}
{
  "products": [
    {
      "id": "123",
      "name": "Running Shoes",
      "description": "High-performance running shoes",
      "url": "https://shop.example.com/products/running-shoes",
      "productType": "Shoes",
      "tags": ["running", "athletic"],
      "status": "active",
      "availability": true,
      "price": { 
        "amount": 99.99, 
        "currency": "USD" 
      },
      "images": [
        { 
          "url": "https://example.com/running-shoes.jpg", 
          "altText": "Running shoes" 
        }
      ],
      "created_at": "2024-01-01T00:00:00.000Z",
      "updated_at": "2024-01-02T00:00:00.000Z",
      "attributes": {
        "color": "blue",
        "size": "10"
      }
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 10,
    "total": 25,
    "hasNextPage": true
  },
  "query": "running shoes"
}
```

### Get by IDs API

Your get by IDs API should fetch specific products by their IDs.

**Endpoint:**

```http theme={null}
GET {getByIdsUrl}?ids=123,456,789
```

**Query Parameters:**

* `ids`: Comma-separated list of product IDs (required)

**Response Format:**

```json theme={null}
{
  "products": [
    {
      "id": "123",
      "name": "Product 1",
      "description": "Description for product 1",
      "url": "https://shop.example.com/products/product-1",
      "productType": "Shoes",
      "tags": ["summer"],
      "status": "active",
      "availability": true,
      "price": { 
        "amount": 49.99, 
        "currency": "USD" 
      },
      "images": [
        { 
          "url": "https://example.com/product1.jpg", 
          "altText": "Product 1" 
        }
      ],
      "created_at": "2024-01-01T00:00:00.000Z",
      "updated_at": "2024-01-02T00:00:00.000Z",
      "attributes": {
        "color": "red"
      }
    },
    {
      "id": "456",
      "name": "Product 2",
      "description": "Description for product 2",
      "url": "https://shop.example.com/products/product-2",
      "productType": "Clothing",
      "tags": ["winter"],
      "status": "active",
      "availability": false,
      "price": { 
        "amount": 79.99, 
        "currency": "USD" 
      },
      "images": [
        { 
          "url": "https://example.com/product2.jpg", 
          "altText": "Product 2" 
        }
      ],
      "created_at": "2024-01-01T00:00:00.000Z",
      "updated_at": "2024-01-02T00:00:00.000Z",
      "attributes": {
        "size": "M"
      }
    }
  ]
}
```

**Note:** If no products are found or if the `ids` parameter is empty, return an empty products array:

```json theme={null}
{
  "products": []
}
```

### Reference Implementation

Here's a complete reference implementation based on ToteBot's own products API:

**Products Controller (Node.js/Express):**

```javascript theme={null}
// GET /products?page=1&limit=20
app.get('/products', async (req, res) => {
  const { page = 1, limit = 20 } = req.query;
  
  try {
    const products = await getProductsFromDatabase(page, limit);
    const total = await getTotalProductCount();
    
    res.json({
      products: products.map(product => ({
        id: product.id,
        name: product.name,
        description: product.description,
        url: product.url,
        productType: product.productType,
        tags: product.tags,
        status: product.status,
        availability: product.availability,
        price: product.price ? {
          amount: product.price.amount,
          currency: product.price.currency
        } : undefined,
        images: product.images?.map(img => ({
          url: img.url,
          altText: img.altText
        })),
        created_at: product.created_at,
        updated_at: product.updated_at,
        attributes: product.attributes || {}
      })),
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total,
        hasNextPage: (page * limit) < total
      }
    });
  } catch (error) {
    res.status(500).json({ error: 'Internal server error' });
  }
});
```

**Search Controller:**

```javascript theme={null}
// GET /products/search?query=shoes&filters[availability]=true&page=1&limit=10
app.get('/products/search', async (req, res) => {
  const { query, filters = {}, page = 1, limit = 10 } = req.query;
  
  if (!query) {
    return res.status(400).json({ error: 'Query parameter is required' });
  }
  
  try {
    const searchResults = await searchProducts(query, filters, page, limit);
    
    res.json({
      products: searchResults.products.map(product => ({
        // Same product mapping as above
        id: product.id,
        name: product.name,
        // ... other fields
      })),
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total: searchResults.total,
        hasNextPage: (page * limit) < searchResults.total
      },
      query
    });
  } catch (error) {
    res.status(500).json({ error: 'Internal server error' });
  }
});
```

**Get by IDs Controller:**

```javascript theme={null}
// GET /products/ids?ids=123,456,789
app.get('/products/ids', async (req, res) => {
  const { ids } = req.query;
  
  if (!ids) {
    return res.json({ products: [] });
  }
  
  const idArray = ids.split(',').map(id => id.trim()).filter(Boolean);
  
  if (idArray.length === 0) {
    return res.json({ products: [] });
  }
  
  try {
    const products = await getProductsByIds(idArray);
    
    res.json({
      products: products.map(product => ({
        // Same product mapping as above
        id: product.id,
        name: product.name,
        // ... other fields
      }))
    });
  } catch (error) {
    res.status(500).json({ error: 'Internal server error' });
  }
});
```

### API Validation

ToteBot will validate your API endpoints during the integration setup process:

1. **Products API**: Tests connectivity and response structure
2. **Search API**: Validates search functionality with a test query
3. **Get by IDs API**: Ensures proper handling of product ID lookups

All endpoints must return valid JSON responses with the expected structure. If any validation fails, you'll see specific error messages to help you fix the issues.

### Error Handling

Your APIs should handle errors gracefully and return appropriate HTTP status codes:

**Common Error Responses:**

```json theme={null}
{
  "error": "Product not found",
  "message": "The requested product ID does not exist",
  "code": "PRODUCT_NOT_FOUND"
}
```

**HTTP Status Codes:**

* `200`: Success
* `400`: Bad Request (invalid parameters)
* `404`: Not Found (product/endpoint not found)
* `500`: Internal Server Error

### Security Considerations

* **HTTPS Required**: All API endpoints must use HTTPS
* **Rate Limiting**: Implement rate limiting to prevent abuse
* **Input Validation**: Validate all query parameters and request data
* **CORS**: Configure CORS headers if needed for web requests
* **Authentication**: Consider adding API keys for production use

### Performance Optimization

* **Caching**: Implement caching for frequently accessed product data
* **Pagination**: Use efficient pagination to handle large product catalogs
* **Database Indexing**: Ensure proper database indexes for search queries
* **CDN**: Use a CDN for product images to improve loading times

## Best Practices

### Data Consistency

* Ensure product availability is real-time
* Keep inventory updated across all channels
* Handle price changes during checkout flow
* Validate product data before returning responses

### Testing Your Implementation

1. **API Endpoints**: Test all three endpoints with various parameters
2. **Error Scenarios**: Test with invalid IDs, empty responses, network errors
3. **Performance**: Load test with concurrent users and large catalogs
4. **Integration**: Test end-to-end with ToteBot's conversation flow
5. **Edge Cases**: Test empty product lists, malformed JSON, timeout scenarios

### Validation Rules

* **Products API**: Must return `products` array and `pagination` object with `hasNextPage` boolean
* **Search API**: Must return `products` array, `pagination` object, and `query` string
* **Get by IDs API**: Must return `products` array (can be empty if no products found)
* **Product Objects**: Should align with the field requirements above; unknown fields go into `attributes`

### Troubleshooting

* **Zero Products**: Verify your API returns `products[]` and `pagination.hasNextPage`
* **Search Issues**: Ensure your search endpoint handles queries and filters correctly
* **Connectivity**: Ensure all URLs are reachable from ToteBot's backend
* **Validation Errors**: Check that your API responses match the expected JSON structure
* **Performance**: Monitor response times and implement caching if needed

### Common Issues

**Issue**: "Unable to connect to Products API"

* **Solution**: Verify the URL is correct and accessible via HTTPS

**Issue**: "Invalid response structure from Search API"

* **Solution**: Ensure your search endpoint returns the expected JSON format with `products` and `pagination`

**Issue**: "Get by IDs API connectivity test failed"

* **Solution**: Check that your endpoint handles empty `ids` parameter and returns `{"products": []}`

**Issue**: Products not updating properly

* **Solution**: Verify your pagination logic and ensure `hasNextPage` is calculated correctly


# Email Integration
Source: https://docs.totebot.ai/integrations/email

Let your AI agent receive and reply to customer emails automatically

The Email integration is a channel integration that allows your AI agent to receive customer emails and reply automatically. Customers email a dedicated address (or your existing support address via forwarding), and the agent responds just like it would in the chat widget, with full access to your knowledge base and AI actions.

To access this integration, navigate to **Channels** → **Email** in your dashboard.

<Note>Email integration is available on **Pro** and **Scale** plans.</Note>

## How It Works

<Steps>
  <Step title="Connect the Integration">
    Click **Connect** on the Email integration card. You'll see a dedicated inbound email address generated for your agent (e.g., `your-agent-id+inbound@mail.totebot.ai`). Copy this address.
  </Step>

  <Step title="Set Up Email Forwarding">
    In your email provider (Gmail, Outlook, or any other), set up a forwarding rule to send incoming emails to the inbound address you copied.

    This way, customers can email your regular support address (e.g., `support@yourstore.com`), and those emails will be forwarded to your AI agent automatically.
  </Step>

  <Step title="Configure Reply Settings">
    Set up the following options:

    * **Reply-To Address**: the email address customers will see when they reply to the agent's response (e.g., `support@yourstore.com`). This ensures replies go back to your real inbox.
    * **Reply Delay**: how long the agent waits before sending a reply (0 to 3600 seconds). A short delay (e.g., 60 seconds) makes the response feel more natural.
    * **BCC Address**: optionally receive a copy of every AI response for supervision.
  </Step>

  <Step title="Enable and Save">
    Toggle the integration to **Enabled** and save your settings. Your agent is now ready to handle emails.
  </Step>
</Steps>

## Email Threading

The agent maintains proper email threading using standard email headers (Message-ID, In-Reply-To, References). This means:

* Follow-up emails from the same customer continue the same conversation
* Replies show up as a thread in the customer's email client
* The agent has full context from previous messages when composing a reply

## Smart Content Parsing

When processing incoming emails, the agent:

* **Extracts the latest reply**: removes quoted text, signatures, and forwarding headers so only the new message is processed
* **Detects auto-replies**: skips out-of-office messages and other automatic responses to avoid unnecessary replies
* **Handles HTML and plain text**: works with any email format

## Handover Support

If a customer's email conversation has been taken over by an operator from the [Help Desk](/dashboard/help-desk), the AI agent will not send automatic replies until the operator hands control back. This prevents conflicting messages from AI and human agents.

## Bounce and Complaint Tracking

The system automatically tracks email delivery issues:

* **Bounced emails**: flagged in the conversation so you know the customer didn't receive a response
* **Spam complaints**: tracked to help you monitor deliverability

These events are logged as system messages in the conversation history.

## Email Collection

Separately from the email channel, you can collect customer email addresses directly in the chat widget. This is configured in **Settings** → **Email capture** and works independently of the email integration.

When enabled, customers are prompted to enter their email when they start a conversation. Collected emails are available in your dashboard under **Settings** → **Email capture** → **Collected Email Addresses**, and can also be accessed via the [Public API](/api/public-api).


# Google Integration
Source: https://docs.totebot.ai/integrations/google

Connect Totebot with Google Analytics and Google Ads

The Google integration is a tracking & analytics integration that enables you to monitor customer interactions and retarget them through Google Ads.

To access this integration, navigate to **Integrations** → **Google** in your dashboard.

By connecting your Google Ads/Analytics account with a Measurement ID and API Secret, Totebot can send user activity data from chat conversations back to Google.

* Retarget users through Google Ads (Display, Search, or YouTube).
* Build audiences from people who already interacted with your agent.
* Create lookalike audiences to reach new customers similar to your engaged users.

## Connecting Google

<Steps>
  <Step title="Access Google Integration">
    Go to **Integrations** → **Google** and click **Connect**.
  </Step>

  <Step title="Enter Credentials">
    Enter your **Google Measurement ID** and **API Secret**.

    <img alt="Google Integration Settings" />
  </Step>

  <Step title="Connect Account">
    Click **Connect Google**.

    <img alt="Google Connected" />
  </Step>
</Steps>

## Configuring Events

After setup, you can select which events your agent should track and send to Google. Available options are similar to Meta and include:

* **View content**: when a user browses or requests product details.
* **Add to cart**: when a product is added to their cart through chat.
* **Remove from cart**: when an item is removed from the cart.
* **Update cart**: when changes are made to the cart (quantity, size, etc.).
* **Initiate checkout**: when the checkout process is started.
* **Lead**: when a user submits contact info (e.g., email, phone, company).

<img alt="Google Integration Settings" />


# Meta Integration
Source: https://docs.totebot.ai/integrations/meta-ads

Connect Totebot with Meta (Facebook & Instagram) for retargeting

The Meta integration is a tracking & analytics integration that enables you to track customer interactions and retarget them on Facebook and Instagram. By connecting your Meta Pixel and Access Token, Totebot can send user activity data from chat conversations back to Meta, helping you reach those same users again through ads.

To access this integration, navigate to **Integrations** → **Meta** in your dashboard.

When customers interact with your agent (e.g., view products, add to cart, or show interest), those actions are tracked as events. These events are then sent to your Meta Ads Manager, where you can:

* **Build retargeting audiences** (show ads to people who are already engaged with your agent).
* **Create lookalike audiences** (find new people similar to your engaged users).

## Connecting Meta

<Steps>
  <Step title="Access Integration Settings">
    Go to **Integrations** → **Meta** and click **Connect**.
  </Step>

  <Step title="Enter Credentials">
    Paste your **Pixel ID** and **Access Token**.

    <img alt="Meta Integration" />
  </Step>

  <Step title="Connect Meta">
    Click **Connect Meta**.

    <img alt="Meta Connected" />
  </Step>
</Steps>

<Warning>
  Important: Treat the access token like a password and don't share it publicly.
</Warning>

## Configuring Events

Once connected, you can select which events your agent should track and send to Meta. Available options include:

* **View content**: when a user browses or requests product details.
* **Add to cart**: when a product is added to their cart through chat.
* **Remove from cart**: when an item is removed from the cart.
* **Update cart**: when changes are made to the cart (quantity, size, etc.).
* **Initiate checkout**: when the checkout process is started.
* **Lead**: when a user submits contact info (e.g., email, phone, company).

<img alt="Meta Settings" />


# MyRent Integration
Source: https://docs.totebot.ai/integrations/myrent

Connect Totebot to your MyRent property management account

The MyRent integration connects your MyRent (my-rent.net) property management account to Totebot. Once connected, your AI agent can search your rental catalog, return live property details, check availability, and capture booking inquiries, directly in any conversation.

To access this integration, navigate to **Integrations** → **MyRent** in your dashboard.

<Note>MyRent is available on **Pro** and **Scale** plans.</Note>

## What you need

Two credentials from your MyRent account settings:

* **User key**: exposed as `user_guid` in MyRent
* **B2B key**: exposed as `b2b_guid` in MyRent

Both are UUID-shaped strings. Totebot validates them against the MyRent API before saving, so you'll know immediately if anything is off.

## Setup instructions

<Steps>
  <Step title="Open the integration">
    In your Totebot dashboard, go to **Integrations** and under **MyRent** click **Connect**.
  </Step>

  <Step title="Paste your User key">
    Paste the `user_guid` value from your MyRent account.
  </Step>

  <Step title="Paste your B2B key">
    Paste the `b2b_guid` value from your MyRent account.
  </Step>

  <Step title="Set the default currency">
    Three-letter ISO code (e.g. `EUR`, `USD`). Used when MyRent doesn't return a currency on a price.
  </Step>

  <Step title="(Optional) Website URL template">
    If you want the agent to link properties back to your own website, set the **Website URL template**.

    The template supports these placeholders:

    * `{slug}`: property slug
    * `{property_id}`: numeric MyRent property id
    * `{id_hash}`: hashed id used in some MyRent URLs

    Example: `https://example.com/villa/{slug}`
  </Step>

  <Step title="Save">
    Click **Save**. Totebot validates the keys against MyRent and stores them encrypted.
  </Step>
</Steps>

Once saved, the integration is enabled by default and your agent can start answering property questions.

## What the agent can do

After connecting, the agent gets the following capabilities:

* **Search properties** by location, dates, guest count, bedroom count, amenities, and free-text query.
* **Fetch property details** including description, photos, capacity, bedrooms, bathrooms, area, address, star rating, amenities, and distances to local points of interest.
* **Open the property page** on your own website when a URL template is configured.

## Dashboard

After connecting, the **MyRent integration** view has two tabs:

### Status

Shows whether the integration is enabled and how many properties Totebot can see from your account. The **Edit configuration** button opens the same setup form for updating credentials, currency, or the website URL template.

The list of supported currencies is curated: EUR and USD are first, followed by the most common European, North American and Asian options.

### Properties

Lists every property Totebot is syncing from your MyRent account. Each row links to a detail page that shows the full description, photo gallery, capacity stats, amenities, distances, and a link out to your website (if configured).

## Troubleshooting

**"Invalid MyRent credentials"**: double-check that the values you pasted match `user_guid` and `b2b_guid` in your MyRent account exactly. Both keys are required.

**"No properties listed"**: confirm the integration is **Enabled** in the Status tab, and that your MyRent account has at least one published property. Disabled or draft listings won't show up.

**Property links go to the wrong place**: verify your **Website URL template** uses one of the supported placeholders (`{slug}`, `{property_id}`, `{id_hash}`) and that your site actually serves that URL pattern.


# Shopify Integration
Source: https://docs.totebot.ai/integrations/shopify

Connect Totebot to your Shopify store

The Shopify integration connects your Shopify store with Totebot. This allows your AI agent to access your product catalog, manage shopping carts, and process orders directly within conversations.

To access this integration, navigate to **Integrations** → **Shopify** in your dashboard.

If you have a Shopify store, make sure to connect to it following the instructions:

## Setup Instructions

<Steps>
  <Step title="Connect to Shopify">
    Under **Shopify**, click **Connect**.

    <img alt="ToteBot Integrations" />
  </Step>

  <Step title="Enter Store URL">
    Type in your Shopify store URL and click **Authorize**.

    <img alt="Connect Shopify Store" />
  </Step>

  <Step title="Install the App">
    Click **Install** on your Shopify store.

    <img alt="Install Shopify App" />
  </Step>

  <Step title="Return to Dashboard">
    You'll be redirected back to the Totebot dashboard.

    <img alt="Shopify Connected" />
  </Step>

  <Step title="Enable App Embed">
    In your Shopify admin, go to **App Embeds**, toggle Totebot **ON** (in the upper-left corner), and click **Save** (in the upper-right corner).

    <img alt="Enable App Embed" />
  </Step>
</Steps>

Your Totebot is now live and connected!


# Telegram Integration
Source: https://docs.totebot.ai/integrations/telegram

Connect Totebot to Telegram for direct messaging

The Telegram integration is a channel integration that allows your customers to chat with your AI agent directly through the Telegram app. This allows them to get answers without visiting your website and can help increase your conversion rates.

To access this integration, navigate to **Channels** → **Telegram** in your dashboard.

<Note>Telegram is available on **Basic**, **Pro**, and **Scale** plans.</Note>

## How to connect Telegram:

<Steps>
  <Step title="Access Integration Settings">
    Click the **Connect** button in the Telegram integration section and follow the instructions.
  </Step>

  <Step title="Find BotFather">
    Open the Telegram app and search for **@BotFather**.

    <img alt="totebot-ai-telegram-app.png" />
  </Step>

  <Step title="Create New Bot">
    Start a chat with BotFather and send the command: `/newbot` and follow BotFather's instructions to create your bot.

    <img alt="totebot ai telegram application chat " />
  </Step>

  <Step title="Get Bot Credentials">
    BotFather will provide you with a bot token and a username. Copy the bot token and username, then paste them into the corresponding fields in Totebot.

    <img alt="Bot Token and Username" />
  </Step>

  <Step title="Save Settings">
    Save your settings.
  </Step>
</Steps>

Once saved, you'll see a confirmation that the connection succeeded.

<img alt="Telegram connected" />

Your Telegram bot is now connected and ready to communicate with customers.

To test your bot, open the Telegram app, type the bot's name in the search bar, and start a conversation.


# Web Widget
Source: https://docs.totebot.ai/integrations/web-widget

Add Totebot to your website

The Web Widget integration allows you to add Totebot's AI agent directly to your website. This is a channel integration that enables customers to interact with your agent on your website.

To access this integration, navigate to **Channels** → **Web** in your dashboard.

## Widget Options

**Chat Bubble** provides a code snippet that adds a floating chat icon to your site (usually in the bottom-right corner). When clicked, it opens the chat in a pop-up window without leaving the current page. Copy the generated snippet from the page and paste it before the closing `</body>` tag of your site; it already contains your agent's ID.

**iFrame Embed** provides a code that places the full chat interface directly inside a chosen section or page of your website, making the chat part of the page layout and visible without clicking a bubble.

<img alt="ToteBot Web Widget" />

## Identity Usage

This option lets you assign a verified ID to each visitor so the agent can recognize them across sessions. By passing a user ID together with a hash generated from your secret key, the agent can remember past conversations, maintain context, and personalize interactions. The provided Node.js and Python snippets show how to generate the hash on your server and pass it to the widget.

<Note>Identity verification requires the Personalization feature, available on **Basic**, **Pro**, and **Scale** plans.</Note>

<img alt="User Identity Setup" />


# WhatsApp Integration
Source: https://docs.totebot.ai/integrations/whatsapp

Let customers chat with your AI agent on WhatsApp

The WhatsApp integration is a channel integration that lets customers message your AI agent on WhatsApp. The agent answers with full access to your knowledge base, product catalog, and AI actions, and conversations show up in your dashboard like any other channel.

To access this integration, navigate to **Channels** → **WhatsApp** in your dashboard.

<Note>WhatsApp is available on **Basic**, **Pro**, and **Scale** plans.</Note>

## How to connect WhatsApp

<Steps>
  <Step title="Request a number">
    WhatsApp Business numbers are provisioned by the Totebot team. Contact [support@totebot.ai](mailto:support@totebot.ai) to set up a new number or migrate an existing one.
  </Step>

  <Step title="Enter the sender number">
    Once your number is ready, open **Channels** → **WhatsApp** and enter it in the **Sender Phone Number** field. Use international format without `+` or spaces, for example `447860099299`.
  </Step>

  <Step title="Save settings">
    Click **Save settings**. Your agent now receives and answers WhatsApp messages sent to that number.
  </Step>
</Steps>

## Pricing

WhatsApp messages count toward your plan's monthly message allowance. In addition, messages sent outside the first 24 hours of a conversation are billed at \$0.12 per message, following WhatsApp's conversation window model. Replies within the first 24 hours of a conversation carry no extra WhatsApp fee.

## Help Desk handover

When a customer on WhatsApp asks for a human, the conversation is escalated to a ticket in your [Help Desk](/dashboard/help-desk) inbox. An operator can take the conversation over and reply directly, and those replies are routed back to the customer's WhatsApp chat automatically.

## Disconnecting

To remove the integration, open **Channels** → **WhatsApp** → **Danger** and disconnect. Your number stays reserved with the Totebot team until you ask for it to be released.


# WooCommerce Integration
Source: https://docs.totebot.ai/integrations/woocommerce

Connect Totebot to your WooCommerce store

The WooCommerce integration connects your WooCommerce store with Totebot. Your AI agent gets access to your product catalog, can recommend products with live prices and availability, add items to the customer's cart, and attributes orders back to the conversations that drove them.

To access this integration, navigate to **Integrations** → **WooCommerce** in your dashboard.

<Note>WooCommerce is available on every plan, including the free plan.</Note>

## Step 1: Connect your store

<Steps>
  <Step title="Enter your site URL">
    Click **Connect** on the WooCommerce integration, enter your store's URL, and click **Authorize**.

    <img alt="Connect WooCommerce dialog" />
  </Step>

  <Step title="Approve access">
    You'll be redirected to your WooCommerce store to approve the connection. Log in to your WordPress admin if prompted, review the access, and click **Approve**.

    <img alt="Approve Totebot AI access in WooCommerce" />
  </Step>

  <Step title="Return to the dashboard">
    After approval you're redirected back to Totebot. Your product catalog starts syncing automatically, and webhooks keep it up to date when you add, change, or remove products.

    <img alt="WooCommerce connected confirmation" />
  </Step>
</Steps>

## Step 2: Install the chat widget plugin

The plugin adds the Totebot chat widget to your storefront. Everything you need lives on the WooCommerce integration page: the **Download Plugin** button, the step-by-step, and your **Agent ID**.

<img alt="WooCommerce integration page with plugin steps, Agent ID, and product sync status" />

<Steps>
  <Step title="Download the plugin">
    On the WooCommerce integration page, click **Download Plugin** to get **Totebot AI for WooCommerce** (`totebot-ai-for-woocommerce.zip`).
  </Step>

  <Step title="Upload it to WordPress">
    In your WordPress admin panel, go to **Plugins** → **Add New** → **Upload Plugin**, choose `totebot-ai-for-woocommerce.zip`, and click **Install Now**.
  </Step>

  <Step title="Activate the plugin">
    Click **Activate Plugin**. WooCommerce must be installed and active on your site.
  </Step>

  <Step title="Enter your Agent ID">
    Go to **Settings** → **Totebot AI** in your WordPress admin and enter your **Agent ID**. You'll find it on the WooCommerce integration page in your Totebot dashboard.
  </Step>

  <Step title="Enable the widget">
    Tick **Enable Totebot Chat Widget** and click **Save**. The chat widget now appears on your store.
  </Step>
</Steps>

## What the agent can do

* **Search and recommend products** from your synced catalog, with prices, images, and availability.
* **Show product cards in chat** so customers can view details and jump to the product page.
* **Add products to the cart** directly from the conversation, so customers can keep shopping and check out without leaving the chat.
* **Look up orders** when you enable the order lookup tool on the integration page.
* **Attribute purchases** to conversations, so Analytics shows the revenue your agent generated.

## Product catalog

The **Product catalog** tab on the integration page lists every synced product. You can check sync status, trigger a re-sync, and open each product to see exactly what data the agent works with.


# Quick Start
Source: https://docs.totebot.ai/quickstart

Get started with Totebot

Welcome to Totebot. This guide explains what Totebot does and what to know before you set up, train, and launch your first AI agent.

## What is Totebot?

Totebot is an AI agent that handles customer support and sales for your business, wherever your customers are. It plugs into your website and the channels your customers already use to answer questions, recommend products, capture leads, take bookings, and close sales, all in the same conversation. When a person is needed, it hands the conversation to your team.

It works for a range of businesses:

* **E-commerce**: recommend products, recover carts, and close orders inside the chat (Shopify, WooCommerce, or a custom store).
* **Property rentals**: answer availability, take bookings, and sync with your booking system.
* **Customer support**: answer FAQs, order status, and policy questions instantly, then hand off to a human the moment it matters.
* **Services & B2B**: qualify leads, book demos, and push qualified contacts into your own systems through the API.

## What can the agent do?

Your agent works 24/7 and engages customers the moment they land on your site or message you on a connected channel. It reduces friction across the whole journey, from the first question to the final sale.

* **Answers questions instantly**: product details, order status, shipping, and policies, with no wait time and no tickets.
* **Guides discovery**: helps customers find what they need through natural conversation instead of clunky filters.
* **Takes action**: adds to cart, starts checkout, captures leads, sends emails, and calls your APIs.
* **Personalizes the conversation**: tailors answers and suggestions to the customer and the context.
* **Works across channels**: web widget, WhatsApp, Telegram, and email, with one shared conversation history.
* **Hands off to humans**: escalates the conversation into a ticket in your team's Help Desk when a person is needed.

## What should I know before you start?

### Setup time

You can go live quickly. Connect a channel or store, add some knowledge, and your agent is ready. You can keep customizing and refining it at your own pace from the dashboard.

### No coding required

Everything is managed through the dashboard, so you can set up, train, and manage your agent without writing any code. The API is there if you want it, but it isn't required.

### Training the agent

Your agent answers from the knowledge you give it. Add content to the Knowledge section at any time:

* Files (PDFs, catalogs, manuals)
* Text entries
* Links to your website or resources
* Custom Q\&A

The more relevant and structured your content, the better your agent performs. Update it as your business changes to keep answers accurate.

### Integrations

Connect Totebot to the tools your customers and business already use. Integrations fall into three groups:

**Channels** (where customers talk to your agent):

* Web Widget (embedded chat on your website)
* WhatsApp
* Telegram
* Email

**E-commerce** (product catalog, carts, and order attribution):

* Shopify (1-click integration)
* WooCommerce (native plugin)
* Custom Webshop (any other platform, set up by our team)
* MyRent (property rentals)

**Tracking & Analytics** (measure conversions and interactions):

* Meta (Facebook and Instagram retargeting)
* Google (Analytics and Ads tracking)

### AI models

Totebot supports a range of leading AI models so you can pick the one that fits your performance, budget, and use case. The model picker in your agent's **AI** settings always shows the full, up-to-date list available on your plan.

Supported model families include:

* **OpenAI**: GPT-5 family (5, 5.1, 5.2, 5.4, and 5.5, plus Mini and Nano), GPT-4o and GPT-4o Mini, the open GPT-OSS models, and o4 Mini
* **Anthropic**: Claude Opus, Sonnet, and Haiku
* **Google**: Gemini 2.0, 2.5, and 3 (Flash, Pro, and Lite)
* **Mistral**: Large, Medium, and Small
* **xAI**: Grok 4 and Grok 3

You can switch models at any time from the dashboard.

### Languages

Totebot has built-in support for 95+ languages and adapts to the language your customers write in.

## Next Steps

<Card title="Complete Setup Guide" icon="rocket" href="/getting-started">
  Follow the detailed guide to set up and launch your first agent.
</Card>