# Create conversation
Source: https://docs.quick.bot/api/chat/conversations

POST /v1/conversations
Initiates a new conversation with a bot. Returns session information needed for subsequent interactions.



# Generate upload URL
Source: https://docs.quick.bot/api/chat/generate-upload-url

POST /v1/generate-upload-url
Used to upload anything from the client to S3 bucket

The `presignedUrl` and `formData` fields can be then used to upload the file to the S3 bucket,
directly from the browser if necessary. Here is an example:

```js theme={null}
// data contains the presignedUrl and formData fields from the response

const formData = new FormData()
Object.entries(data.formData).forEach(([key, value]) => {
  formData.append(key, value)
})
formData.append('file', file)
const upload = await fetch(data.presignedUrl, {
  method: 'POST',
  body: formData,
})
```


# API
Source: https://docs.quick.bot/api/general



Some API endpoints are protected, and therefore require that you authenticate using an API token.

## Use your token

You can authenticate by adding an `Authorization` header to all your HTTP calls. The Authorization
header is formatted as such: `Authorization: Bearer <token>` (replace `<token>` with your token
previously generated).

Example:

```sh theme={null}
curl -L -X GET 'https://app.quick.bot/api/v1/analytics/:botId/answers' \
-H 'Accept: application/json' \
-H 'Authorization: Bearer your_api_token_here'
```

### How to find my `botId`

If you'd like to execute the bot in preview mode, you will need to provide the ID of the building
bot available in the editor URL:

<Frame>
  <img alt="Get bot ID" />
</Frame>

### How to find my `publicId`

For published bot execution, you need to provide the public bot ID available here:

<Frame>
  <img alt="Get botpublic ID" />
</Frame>

### How to find my `workspaceId`

In your workspace dashboard, head over to `Workspace > Settings` and copy the workspace ID.


# API Tokens
Source: https://docs.quick.bot/app/account/api-tokens



Create and manage API tokens to authenticate requests to the QuickBot API. API tokens provide secure
access to your account data and bot management functions.

## What are API Tokens?

API tokens are secure authentication keys that allow external applications and scripts to interact
with your QuickBot account programmatically. They provide:

* **Secure Access**: Authentication without exposing your password
* **Granular Control**: Each token can be managed independently
* **Easy Revocation**: Tokens can be deleted instantly if compromised
* **Activity Tracking**: Monitor when and how your tokens are used

## Creating API Tokens

1. Click the **Create** button
2. Enter a descriptive name for your token
3. Click **Create Token**
4. Copy the generated token value and store it securely.

<Warning>
  **Important**: The token value will only be displayed once immediately after creation. Copy and
  save it securely - you won't be able to view it again.
</Warning>

## Viewing Active Tokens

The API Tokens page shows all your active tokens with:

* **Token Name**: The descriptive name you assigned
* **Created Date**: When the token was generated
* **Last Used**: When the token was last used (if available)

### Revoking Tokens

To delete an API token:

1. Find the token in your API Tokens list
2. Click the **Delete** button next to the token
3. Confirm the deletion

<Note>
  Once a token is deleted, all applications using that token will immediately lose access. Make sure
  to update your applications with new tokens before deleting old ones.
</Note>

### API Documentation

For complete API documentation including all available endpoints and parameters, visit the
[API Reference](/api/general) section.

<Tip>
  Create tokens with specific, descriptive names and delete them as soon as they're no longer
  needed. This minimizes security risks and keeps your token list clean and manageable.
</Tip>


# Notifications
Source: https://docs.quick.bot/app/account/notifications



Configure when and how you receive email notifications from QuickBot to stay informed about
important account activities and bot performance.

All notifications are sent to your registered account email address. You can individually control
each type of notification based on your preferences.

## Limits

Stay informed about your account's chat usage to avoid service interruptions.

* **Almost Reached Conversations Limit**: receive a notification when you're approaching your monthly
  chat limit (Sent when you reach 80% of your plan's chat allowance).

* **Reached Conversations Limit**: receive a notification when you've hit your monthly chat limit (Sent immediately when your chat limit is exceeded).

<Note>
  Chat limits are based on your subscription plan. Consider upgrading to a higher tier if you
  frequently receive limit notifications.
</Note>

## Onboarding

* **Onboarding tips**: receive notifications with helpful tips and guidance to get started with QuickBot (Sent during the first week after account creation).

## Billing

* **Payment confirmations**: receive notifications confirming successful payments for your subscription (Sent immediately after payment processing).

* **Plan upgrade/downgrade notifications**: receive notifications when your subscription plan changes (Sent immediately after plan change).

## Collaboration

* **When someone accepts your invitation**: receive notifications when a team member accepts your invitation to collaborate on QuickBot (Sent immediately after acceptance).

* **When you are removed from a workspace**: receive notifications when you are removed from a workspace (Sent immediately after removal).

* **When your workspace role changes**: receive notifications when your role in a workspace is updated (Sent immediately after role change).

## Bots

* **When you publish a bot for the first time**: receive notifications when you publish a new bot (Sent immediately after publication).

* **When a bot reaches conversation milestones**: receive notifications when your bot reaches specific conversation milestones.

* **Periodic workspace analytics digest**: receive a summary of your workspace's bot performance and analytics (Sent weekly).

* **When a bot has recurring errors**: receive notifications when a bot encounters recurring errors.

## Notification history

View your notification history in a table format, including the date, type and workspace of each notification.

<Tip>
  For high-traffic bots, rely on the dashboard analytics rather than email notifications to avoid
  inbox overload while still monitoring performance effectively.
</Tip>


# Preferences
Source: https://docs.quick.bot/app/account/preferences



Configure your QuickBot account preferences to customize your experience across the platform.

## Appearance

Control how the QuickBot interface looks:

* **Light**: Bright interface with light backgrounds (default)
* **Dark**: Dark interface that's easier on the eyes in low-light conditions
* **System**: Automatically matches your operating system's theme preference

The theme setting applies to all QuickBot interfaces including the bot builder, dashboard, and
settings pages.

<Note>
  Your theme preference is saved to your account and will be applied across all devices where you're
  logged in.
</Note>

## Language

QuickBot supports multiple languages for the user interface:

* **English** (en)
* **Français** (fr)
* **Deutsch** (de)
* **Português** (pt)
* **Português (BR)** (pt-BR)
* **Română** (ro)
* **Español** (es)
* **Italiano** (it)

Changing your language preference will:

* Update all menu items, buttons, and interface text
* Change the language for system notifications
* Apply to new bot templates and examples

<Warning>
  Language changes only affect the QuickBot interface. Your bot content and conversations will
  remain in the languages you've created them in.
</Warning>


# Profile
Source: https://docs.quick.bot/app/account/profile



Manage your personal account information and preferences.
Your account profile contains your basic information that's displayed across the QuickBot platform.

<Frame>
  <img alt="Account profile" />
</Frame>

### Your Name

You can update your display name at any time. This name will be shown in:

* Workspace member lists.
* Account notifications.

### Email Address

Your email address is used for:

* Account authentication.
* Important notifications.
* Password reset requests.
* Workspace invitations.

<Note>
  If you update your email, make sure it's an active address you can access, since all
  account-related emails will be sent there.
</Note>

### Profile Picture

Upload a custom profile picture to personalize your account:

<Note>
  **Supported formats:** PNG, JPG, JPEG, GIF
</Note>

### Phone Number

Add a phone number for account recovery and two-factor authentication (2FA).


# Security
Source: https://docs.quick.bot/app/account/security



Manage your account security settings and preferences.

## Authentication

* **Password**: Change your account password. Use a strong, unique password that combines letters,
  numbers, and special characters.
* **Email Address**: Update your registered email address for account notifications and recovery.

## Security Notifications

* **Email Notifications**: Enable or disable email notifications for security-related events, such
  as login attempts, password changes, and suspicious activity.

* **Login Alerts**: Receive alerts for new logins from unrecognized devices or locations.


# Analytics
Source: https://docs.quick.bot/app/bots/analytics



In the **Analytics** section, you can view and analyze the performance of your bots.

Is the part of the product that tells you **how people are using your chatbots**, how
many saw them, how many actually talked to them, how many finished, where they gave up and what
answers they gave along the way.

<Note>
  Analytics is available on paid plans. On the free and personal plans the section appears locked,
  with an option to upgrade.
</Note>

## Key metrics

Everything in Analytics is built on three simple counts, measured over the period you choose:

* **Views**: how many times the chatbot was seen (loaded on a page).
* **Started**: how many people actually began a conversation.
* **Completed**: how many people reached the end of the conversation.

From those, the system calculates the rates that tell the real story:

* **Started Rate**: of everyone who saw the bot, what % started chatting.
* **Completion Rate**: of everyone who started, what % finished.
* **Drop-off Rate**: of everyone who started, what % quit before finishing.

## Filters

At the top of the page you have two filters that control everything below them:

* **Time filter**: choose the period you're looking at (e.g. today, last 30 days, year-to-date). Use
  it to compare periods and spot trends.
* **Variable filter**: narrow the analytics down to a single piece of information your bot collects
  (a "variable", such as budget, city, or plan). Selecting a variable here is what reveals the
  **Collection metrics** section further down the page.

  <Note>
    If your bot doesn't collect any variables, this filter won't appear.
  </Note>

## Summary cards

Shows **Total Views**, **Total Started**, and **Total Completed** for the period you picked, each
with its percentage underneath.

<Frame>
  <img alt="Summary Cards" />
</Frame>

## Performance chart

A bar-and-line chart showing how those numbers move **day by day**. The bars show a raw count (e.g.
views per day) and the line shows a rate (e.g. completion rate %). You can switch which metric each
shows using the two dropdowns. This is where you spot trends — a good day, a bad week, the effect of
a marketing campaign.

<Frame>
  <img alt="Performance Chart" />
</Frame>

Here you can see the total number of views, started sessions and sessions completed.

## Conversion funnel

A funnel-shaped picture that stacks **Views → Started → Completed** on top of each other so you can
see how many people fall away at each step. A funnel that narrows sharply tells you exactly where
you're bleeding potential customers.

<Frame>
  <img alt="Analytics Conversion Funnel" />
</Frame>

## Collection metrics

When you select a variable in the **Variable filter** at the top of the page, a **Collection
metrics** section appears below the conversion funnel.

<Frame>
  <img alt="Analytics Collection Metrics: Variable" />
</Frame>

Variable analytics lets you:

* See the **collection rate**: of the people who started, how many actually gave you that piece of
  info?

* Break results down **by answer**: e.g. for the question "What's your budget?", see how many chose
  "low / medium / high" and — crucially — the completion rate *for each group*. Maybe "high budget"
  people finish 90% of the time and "low budget" people quit early. That's a real business insight.

* For numeric answers, see the **average value** (e.g. average budget entered).

The section includes a table with one row per answer, and these columns:

| Column | What it means |
| - | - |
| **\[Variable]** | Each different answer people gave (e.g. "Low", "Medium", "High"). |
| **Started** | How many people started the bot and ended up with this answer. |
| **Completed** | How many of those people finished the whole conversation. |
| **Completion Rate** | Of the people who gave this answer, what % finished the bot. |
| **Drop-off Rate** | Of the people who gave this answer, what % started but quit before the end. |

The **Completion Rate** is color-coded so you can scan it at a glance:

* 🟢 **Green**: 75% or higher (this group finishes well).
* 🟠 **Orange**: 50 to 74% (mediocre).
* 🔴 **Red**: below 50% (this group is dropping off).

<Tip>
  Analytics can also show **combined numbers across all of your bots at once**, not just one bot at a
  time. Use it for a workspace-wide pulse-check, then drill into an individual bot for detail.
</Tip>

## Examples

### 1. Business type (button choice)

Suppose your bot asks visitors what kind of business they run and offers **three options as
buttons** — for example *Retail*, *Services*, and *Manufacturing* — saved into a variable such as
`businessType`.

Select that variable in the **Variable filter**, and the **Collection metrics** section shows you:

* The **collection rate**: of everyone who started, what % actually picked a business type. If this
  is low, the question may be appearing too late or feel intrusive.
* The **percentages table**, one row per option, so you can compare how each segment behaves:

| businessType | Started | Completed | Completion Rate | Drop-off Rate |
| - | - | - | - | - |
| Retail | 420 | 357 | 🟢 85.0% | 15.0% |
| Services | 310 | 186 | 🟠 60.0% | 40.0% |
| Manufacturing | 130 | 52 | 🔴 40.0% | 60.0% |

At a glance you can see that *Retail* visitors finish well, while *Manufacturing* visitors are
dropping off — a signal that the flow after that choice needs work for that segment.

### 2. Rating at the end of the conversation (1 to 5)

Now suppose the **last step** of your bot asks people to rate their experience from **1 to 5**,
saved into a variable such as `rating`.

Because this is the final question, its **collection rate closely mirrors your completion rate** —
only people who reach the end can leave a rating, so "how many gave a rating" and "how many finished
the conversation" are almost the same number. It's a useful sanity check that the two line up.

Since the answers are numeric, the Collection metrics also show the **average value** — your average
rating across all sessions (e.g. `4.3`). Watch this number over time: if it drops after you change
the flow, your latest version is landing worse with users.


# Bots
Source: https://docs.quick.bot/app/bots/bots



In the **Bots** section, you can create, view, and manage all the bots in your workspace.

<Frame>
  <img alt="bots page" />
</Frame>

You will see all your workspace bots with the following columns:

* **Avatar**: The bot image your customers see in the chat — the same one you
  set in the bot **Theme**, under **Bubbles**. Click it to change it right from
  this list; the new avatar reaches your customers immediately, on live bots too.
* **Name**: The bot name.
* **Views**: Number of times the bot was viewed.
* **Starts**: Number of times the bot was started.
* **Completed**: Number of completed conversations.
* **Status**: Current state (Live or Draft).
* **Publish**: Toggle to enable or disable the bot.
* **Actions**: Menu with all available bot operations.

You can filter by **Status** or search by name using the search bar.

## Build my first bot

To start building your first bot you can click on **Build my first bot**. It will open a modal
design to create your first bot step by step.

<Frame>
  <img alt="Build your first bot" />
</Frame>

**Step 1: Start**

* In this step you can choose to start from scratch with an empty conversation flow (this is for
  advanced users), Learn the basic with a guided example bot (this is the recommended option for new
  users), or start from a template (this is for users that want to use a pre-built bot and customize
  it, the fatest option).

**Step 2: Customize**

* In this step you will learn how you can customize your bot, from drag and drop blocks, collect
  data and integrate with external services, to customize the bot's theme and appearance.

  <Info>
    To learn more about blocks and how to use them, start with the [Flow
    documentation](/builder/editor/flow).
  </Info>

**Step 3: Deploy**

* In this step you will learn the different ways you can deploy your bot, from embedding it in your
  website, or integrating it with WhatsApp usign the Meta Cloud API or via QR code.

  <Info>
    To learn more about deploying your bot in WhatsApp, see the [WhatsApp deployment documentation](/builder/deploy/whatsapp).
  </Info>

**Step 4: Explore**

* In this step you will learn about new and advanced features after you have deployed your bot, like
  analytics (track sessions, completions, and user interactions), use inbox to read every message
  sent to your bot and human handoff to let your team take over the conversation when needed.
  <Info>
    To learn more about human handoff, see the [Human Handoff documentation](/human-handoff/general).
  </Info>

## Bot Actions

<Frame>
  <img alt="bot actions" />
</Frame>

Cliking the **Actions** menu (three dots) will show the following options:

* **Editor**: Open the flow editor to design the conversation.
* **Viewer**: Open the live version of your bot. If the bot hasn't been published yet, a 404 Not
  Found page will be displayed.
* **Export bot**: Export the bot as a JSON file.
* **Duplicate**: Create an exact copy of the bot to modify without affecting the original.
* **Delete**: Permanently remove the bot.

<Warning>
  Deleting a bot immediately stops it from functioning if it is live, and cannot be undone.
</Warning>

## Bot Status Management

Bots can have different states:

**Draft**

* Not yet published.
* Only visible to workspace members.
* Can be tested in preview mode.
* Freely editable without affecting any live bot.

**Live**

* Published and available to end users.
* Deployed through your selected channels.
* Collecting analytics and conversation data.
* Updates require republishing to take effect.

## Importing a bot

When importing a bot from a `.json` file, QuickBot recreates the entire bot flow, theme, and
configuration.

<Info>
  To learn more about the bot structure in the json file, see the [Export
  documentation](/builder/editor/export).
</Info>


# Inbox
Source: https://docs.quick.bot/app/bots/inbox



In the **Inbox** section, you can view and manage all the messages sent to your bots. This is where
you can read user messages, respond to them, and manage conversations.

The inbox handle human handoff, allowing your team to take over conversations when needed. This is
especially useful for complex queries that require human intervention.

<Note> This is a paid feature available in the Pro plan and above. </Note>

<Frame>
  <img alt="inbox page" />
</Frame>

In the main table, you will an history of all messages sent to your bots with the following columns:

* **Bot**: the bot name.
* **Avatar**: The customer's avatar.
* **Conversation**: the conversation ID.
* **Last message**: The content of the last message in the conversation.
* **Time**: The timestamp of the last message.
* **Channel**: The channel through which the message was received (web or whatsapp).
* **Status**: The status of the conversation (customer response, open, closed).

You can search (name, email, phone), sort by newest/oldest (last activity or created) and filter by
time.

## Channels

The inbox currently supports two channels: web and WhatsApp. You can filter the conversations by channel using
the filter options.

## Viewing a conversation

Clicking on the row of a conversation will open the conversation view, where you can see the full
history of messages.

<Frame>
  <img alt="inbox conversation page" />
</Frame>

In the left panel you can see the list of conversations for quick access.

In the right panel you can see the conversation details:

* **Platform**: the platform through which the message was received (web or whatsapp).
* **Contact Phone**: the phone number of the customer if it's provided (auto-filled on whatsapp
  conversations).
* **Device type**: the type of device used by the customer (only for web conversations).
* **Contact Name**: the name of the customer if it's provided (auto-filled on whatsapp
  conversations).
* **Contact Email**: the email address of the customer if the flow asked for it.
* **Click-to-WhatsApp Click ID**: the click ID of the customer if it's provided (only for whatsapp
  conversations).
* **User IP**: the IP address of the customer if it's provided (only for web conversations).

  <Card title="Human Handoff" icon="handshake" href="/human-handoff/general">
    Elevate your customer support with human handoff. Learn what this poweful feature offers and how to use it in your bots.
  </Card>


# Welcome to QuickBot
Source: https://docs.quick.bot/app/getting-started/welcome



## Introduction

QuickBot is a powerful platform for **building**, **deploying**, and **managing** chatbots across
multiple channels. It helps businesses automate customer support, generate leads, and create
engaging conversational experiences.

More than just a chatbot builder, QuickBot includes **human handoff** allowing conversations to be
seamlessly transferred from a chatbot to a real agent whenever personal assistance is needed.

The platform also includes **chatbot building tools**, **analytics**, conversation management, and
integrations with channels such as **WhatsApp**.

## Next Steps

We invite you to check out our quick guides.

<CardGroup>
  <Card title="Build your bot" icon="graduation-cap" href="/builder/editor/flow">
    Learn how QuickBot works and how to use it to build your first chatbot
  </Card>

  <Card title="Deploy your bots" icon="rocket" href="/builder/deploy/web">
    Explore the different ways you can deploy your bot.
  </Card>

  <Card title="Human Handoff" icon="handshake" href="/human-handoff/general">
    Learn how to transfer conversations from a chatbot to a real agent.
  </Card>

  <Card title="Analytics" icon="chart-bar" href="/app/bots/analytics">
    Learn how to analyze conversation data and improve your chatbot's performance.
  </Card>
</CardGroup>


# Billing
Source: https://docs.quick.bot/app/workspace/billing



Manage your workspace subscription, monitor usage, and handle billing information. Track your
current plan limits, view invoices, and upgrade or modify your subscription as your needs grow.

<Frame>
  <img alt="Workspace billing and usage" />
</Frame>

## Billing Overview

The billing header displays key information about your current subscription:

* **Plan**: Your current plan (Free, Starter, Grow, Scale).
* **Method**: Payment method (Currently Stripe for all transactions).
* **Status**: Subscription status (Active, Canceled, Past Due).
* **Seats**: Current members vs. plan limit (e.g., "3 / 10").
* **Conversations**: Monthly chat consumption vs. limit.
* **Renewal/Cancellation**: Next payment or cancellation date.
* **Next Payment**: Cost for the upcoming billing cycle.

## Information

* **Company Name**: add your company name for billing purposes.
* **Billing email**: add a billing email to receive invoices and payment notifications.
* **Tax ID**: add your tax ID for tax purposes (if applicable).
  * **ID Type**: select the type of tax ID depending on your location.

<Tip>
  Monitor your usage regularly and upgrade proactively to avoid service interruptions. The Grow plan
  offers the best balance of features and value for most growing teams.
</Tip>


# Credentials
Source: https://docs.quick.bot/app/workspace/credentials



Manage integration credentials for your workspace. Credentials allow your bots to connect securely
with external services and platforms.

## What are Workspace Credentials?

Workspace credentials are secure authentication keys and tokens that enable your bots to integrate
with external services. Unlike API tokens which authenticate API requests, credentials store
third-party service authentication data.

### Supported Integration Types

QuickBot supports credentials for various integration types:

* **Google Sheets**: OAuth tokens for accessing Google Sheets
* **SMTP**: Email server credentials for sending emails
* **Stripe**: Payment processing credentials
* **WhatsApp**: Meta Business API credentials
* **OpenAI**: API keys for AI integrations
* **Other integrations**: Various service-specific credentials

## Add New Credentials

To create new integration credentials:

1. Navigate to **Workspace** > **Credentials**
2. Click the **Create new** dropdown button
3. Select the integration type you want to configure
4. Fill in the required authentication information
5. Assign a descriptive name to identify the credentials
6. Save the credentials

<Note>
  Each integration type has different required fields. For example, SMTP requires server host, port,
  username, and password, while OAuth services like Google Sheets require authorization through
  their respective platforms.
</Note>

## Managing Existing Credentials

The credentials page displays all configured credentials with:

* **Type**: The integration service (shown with service icon)
* **Name**: Your custom name for the credentials
* **Actions**: Edit and delete options

## Edit and Delete Credentials

**To modify existing credentials:**

1. Find the credentials in your list
2. Click the **Edit** button (pencil icon)
3. Update the necessary fields
4. Save your changes

<Warning>
  Some credential types like WhatsApp and Google Sheets cannot be edited after creation due to OAuth
  token restrictions. You'll need to delete and recreate these credentials if changes are needed.
</Warning>

**To remove credentials:**

1. Click the **Delete** button (trash icon) next to the credentials
2. Confirm the deletion in the popup dialog

<Warning>
  **Important**: Before deleting credentials, ensure they are not being used by any published bots.
  Deleting credentials will break integrations in live bots that depend on them.
</Warning>

## Using Credentials in Bots

Once credentials are created, they become available for use in integration blocks:

1. Add an integration block to your bot flow
2. In the block settings, select the appropriate credentials from the dropdown
3. The block will use those credentials to authenticate with the service

## Credential Scope

* **Workspace Level**: All credentials belong to a specific workspace
* **Bot Access**: Any bot within the workspace can use the credentials
* **Member Access**: Workspace members with appropriate permissions can manage credentials

<Tip>
  Test your credentials immediately after creation by using them in a simple bot integration to
  ensure they work correctly before implementing complex workflows.
</Tip>


# Members
Source: https://docs.quick.bot/app/workspace/members



Manage workspace membership, roles, and permissions. Control who has access to your workspace and
what they can do within it. Members can collaborate on bots, access analytics, and contribute to
your workspace based on their assigned role.

## User Roles and Permissions

There are two types of users in a QuickBot workspace:

### Admins

* **Full workspace control**: Can manage workspace settings and delete the workspace
* **Member management**: Can invite, remove, and change roles for other members
* **Bot permissions**: Full access to create, edit, publish, and delete bots
* **Billing access**: Can manage subscription, view usage, and handle payments
* **Analytics access**: View detailed analytics and export data

### Members

* **Bot creation**: Can create, edit, and collaborate on bots within the workspace
* **Limited management**: Cannot manage workspace settings or invite other members
* **Analytics access**: Can view bot performance and analytics
* **Collaboration**: Can work with other members on every bot of the workspace

## Workspace Members

The members table displays:

* **Name**: Member's display name (if provided)
* **Email**: Member's email address
* **Role**: Current role (Admin or Member)
* **Status**: Active (confirmed) or Pending (invitation sent but not accepted)
* **Invite link**: Option to resend the invitation email (for pending members)
* **Actions**: Role management and removal options (for admins)

<Note>Workspace member limits are determined by your billing plan.</Note>

When you reach your member limit:

* An upgrade prompt will appear
* New invitations will be disabled until you upgrade
* An "Upgrade Plan" button provides quick access to billing options

## Inviting New Members

1. Enter email address of the person you want to invite.
2. Select the role from the dropdown.
3. Click "Invite" to send the invitation.

After sending an invitation, the invitation appears in the members table with "Pending" status. The
invitee receives an email with instructions to join. Once accepted, the status changes to "Active"

<Note>Pending invitations count toward your member limit.</Note>

## Actions for Admins

As an admin, you can manage member roles and remove members from the workspace. Use the actions menu
(three dots) next to each member to access these options.

<Warning>
  **Immediate Effect**: Removing a member immediately revokes their access to the workspace, all
  bots, and associated data. They will no longer be able to access any workspace resources.
</Warning>


# Settings
Source: https://docs.quick.bot/app/workspace/settings



Manage your workspace configuration.

* **Icon**: Change the workspace icon.

* **ID**: View the workspace ID. you can't change it.

* **Delete Workspace**: Permanently delete the workspace.

<Warning>
  Deleting a workspace will permanently remove all associated bots, analytics, and member data. This
  action cannot be undone.
</Warning>


# API
Source: https://docs.quick.bot/builder/deploy/api



Your bot can also be executed with HTTP requests. This is useful if you want to integrate your bot
with another service or if you want to use it in a different programming language.

## Usage

1. All your requests need to be authenticated with an API token. [See instructions](/api/general).
2. To start the chat, send a POST request to `https://viewer.quick.bot/api/v1/conversations` The
   first response will contain a conversationId that you will need for subsequent requests.
3. To send replies, send POST requests to
   `https://viewer.quick.bot/api/v1/conversations/<session ID>/messages` With the following JSON
   body:

   ```json theme={null}
   {
     "message": "This is my reply"
   }
   ```

Check out the [Start chat API reference](/api/chat/conversations) for more information


# Link and Domain
Source: https://docs.quick.bot/builder/deploy/general



In the **Deploy** tab, you can find your bot's URL in the sidebar and the option to add a custom domain.

## Your Bot's URL

Here, you can customize the bot's ID. For example, if you set it to `my-awesome-bot`, your bot's URL
will become `https://viewer.dev.quick.bot/my-awesome-bot`.

## Custom Domain

If you have your own domain, you can use it as your bot's URL.

1. Click in **add my domain** and then **+ New Domain**.
2. Add your domain and copy the generated record.
3. In your DNS Provider paste the generated record for your domain.

<Frame>
  <img alt="custom domain" />
</Frame>

<Note>
  Publishing features may be restricted based on your plan:

  * **Custom domains**: Paid plans only
  * **Embed customization**: Advanced on higher tiers
  * **WhatsApp integration**: Enterprise plans
</Note>


# Web
Source: https://docs.quick.bot/builder/deploy/web



Our web client provides three display modes and multiple customization options to seamlessly
integrate your bot into any web application.

**Display modes**:

* **Bubble**: Embeds the bot as a "chat bubble" at the bottom right corner of your site. Can be
  triggered automatically or with a click. It can also come with a "proactive message".
* **Popup**: Embeds the bot in a Popup that overlays your website. It can be triggered after a delay
  or with a click of a button for example
* **Standard**: Embeds the bot in a box with the size of your choice anywhere on your app. This is
  what is used on QuickBot homepage: You can also set the width to `100%` and the height to `100vh`
  to make it take the entire page dimensions

**Customization options**:

* Theme and styling
* Trigger conditions
* User identification
* Pre-filled variables

***

## Integration

You can get the standard HTML and Javascript code by clicking on the "Javascript" button in the
"Deploy" tab of your bot.

There are also appropriate instructions to deploy your bot in your platform of choice, make sure to
head over the `Deploy` tab of your bot and select the platform you want to deploy your bot on.

Here we will explain you the general integration steps for any platform.

### Code snippet

Copy and paste the following code in your website HTML, ideally in the `<head>` section:

```html theme={null}
<script type="module">
  import QuickBot from 'https://cdn.jsdelivr.net/npm/@quick.bot/js@latest/dist/web.js'

  QuickBot.initStandard({
    botId: 'your-bot-id',
  })
</script>

<quickbot-standard style="width: 100%; height: 600px; "></quickbot-standard>
```

This code is creating a container with a 100% width (will match parent width) and 600px height.

### Multiple bots

If you have different bots on the same page you will have to make them distinct with an additional
`id` prop:

```html theme={null}
<script type="module">
  import QuickBot from 'https://cdn.jsdelivr.net/npm/@quick.bot/js@latest/dist/web.js'

  QuickBot.initStandard({
    id: 'bot1',
    botId: 'your-bot-id',
  })

  QuickBot.initStandard({
    id: 'bot2',
    botId: 'my-bot-2',
  })
</script>

<quickbot-standard id="bot1" style="width: 100%; height: 600px; "></quickbot-standard>
...
<quickbot-standard id="bot2" style="width: 100%; height: 600px; "></quickbot-standard>
```

### Popup

You can get the popup HTML and Javascript code by clicking on the "Javascript" button in the
"Deploy" tab of your bot.

Here is an example:

```html theme={null}
<script type="module">
  import QuickBot from 'https://cdn.jsdelivr.net/npm/@quick.bot/js@latest/dist/web.js'

  QuickBot.initPopup({
    botId: 'your-bot-id',
    apiHost: 'https://viewer.quick.bot',
    autoShowDelay: 3000,
  })
</script>
```

This code will automatically trigger the popup window after 3 seconds.

### Bubble

You can get the bubble HTML and Javascript code by clicking on the "Javascript" button in the
"Deploy" tab of your bot.

Here is an example:

```html theme={null}
<script type="module">
  import QuickBot from 'https://cdn.jsdelivr.net/npm/@quick.bot/js@latest/dist/web.js'

  QuickBot.initBubble({
    botId: 'your-bot-id',
    previewMessage: {
      message: 'I have a question for you!',
      subtext: "We're here to assist you 💚",
      avatarUrl: 'https://placehold.co/90x90',
    },
    theme: {
      button: { backgroundColor: '#01a952', iconColor: '#FFFFFF' },
      previewMessage: { backgroundColor: '#ffffff', textColor: 'black' },
      chatWindow: { backgroundColor: '#ffffff', maxWidth: '100%' },
    },
  })
</script>
```

This code will show the bubble and let a preview message appear after 5 seconds.

### Custom button position

You can move the button with some custom CSS on your website. For example, you can place the bubble
button higher with the following CSS:

```css theme={null}
quickbot-bubble::part(button) {
  bottom: 60px;
}

quickbot-bubble::part(bot) {
  bottom: 140px;
  height: calc(100% - 140px)
}
```

If you have a preview message, you'll also have to manually position it:

```css theme={null}
quickbot-bubble::part(bubble-message) {
  bottom: 140px;
}
```

## Commands

Here are the commands you can use to trigger your embedded bot:

* `QuickBot.open()`: Open popup or bubble

* `QuickBot.close()`: Close popup or bubble

* `QuickBot.toggle()`: Toggle the bubble or popup open/close state,

* `QuickBot.showPreviewMessage()`: Show preview message from the bubble,

* `QuickBot.hidePreviewMessage()`: Hide preview message from the bubble,

* `QuickBot.setPrefilledVariables(...)`: Set prefilled variables. Example:

  ```js theme={null}
  QuickBot.setPrefilledVariables({
    Name: 'Jhon',
    Email: 'john@gmail.com',
  })
  ```

  For more information, check out [Additional configuration](#additional-configuration).

* `QuickBot.setInputValue(...)`: Set the value in the currently displayed input.

You can bind these commands on a button element, for example:

```html theme={null}
<button onclick="QuickBot.open()">Contact us</button>
```

## Callbacks

If you need to trigger events on your parent website when the user interact with the bot, you can
use the following callbacks:

```js theme={null}
QuickBot.initStandard({
  botId: 'your-bot-id',
  onNewInputBlock: (inputBlock) => {
    console.log('New user block displayed', inputBlock.id)
  },
  onAnswer: (answer) => {
    console.log('Answer received', answer.message, answer.blockId)
  },
  onInit: () => {
    console.log('Bot initialized')
  },
  onEnd: () => {
    console.log('Bot ended')
  },
})
```

## Variables

You can prefill the bot variable values in your embed code by adding the `prefilledVariables`
option. Here is an example:

```js theme={null}
QuickBot.initStandard({
  botId: 'your-bot-id',
  prefilledVariables: {
    varURL: 'https://my-site.com/account',
    varName: 'Francisco',
  },
})
```

This will prefill the `varURL` variable with "[https://my-site.com/account](https://my-site.com/account)" and the `varName`
variable with "Francisco". More info about variables: [here](/builder/editor/variables).

Note that if your site URL contains query params (i.e.
[https://viewer.quick.bot/my-publicid?varName=John\&varSurname=Doe](https://viewer.quick.bot/my-publicid?varName=John\&varSurname=Doe)), the variables will automatically
be injected to the bot. So you don't need to manually transfer query params to the bot embed
configuration.


# WhatsApp
Source: https://docs.quick.bot/builder/deploy/whatsapp



You can deploy your bot to **WhatsApp** using one of two methods. Choose the one that best fits your
needs. Once your number is connected, you can start chatting with your bot on WhatsApp immediately.

## Deploy via Meta Cloud API

<Frame>
  <img alt="Whatsapp deploy API" />
</Frame>

1. Go to your bot’s **Deploy** tab.
2. Click the **WhatsApp (API)**.
3. Choose between **New number** or **Existing number**.
   <Info>
     * **New Number**: lets you set up a new WhatsApp Business account from scratch through Quick.bot.
     * **Existing number**: use an existing WhatsApp Business number.
   </Info>
4. Accept all checkbox.
5. Click in **Connect with Facebook**.
6. Follows the instructions in facebook
7. After you finish the facebook authentication, you will be redirected back to the deploy page
8. Now your Bot is connected to your number.

***

## Deploy via QR

<Frame>
  <img alt="Whatsapp deploy QR" />
</Frame>

<Note>
  You need an existing business account to deploy via this method. If you don't have an existing
  number, we recommend you to deploy via API.
</Note>

1. Go to your bot’s **Deploy** tab.
2. Click the **WhatsApp (QR)**.
3. Accept all checkbox.
4. Click in **Connect with Facebook**.
5. Now in Facebook, select your businnes portfolio.
6. Select **Connect a WhastApp Business App**.
7. Enter your Phone number.
8. Scan the QR using the Whatsapp Business App:
   * Open Whatsapp Business App (WA Business).
   * Go to settings.
   * Go to Linked Devices.
   * Now you can scan the QR.
9. Follow the remaining instructions, then click **Finish**.
10. After you finish the facebook authentication, you will be redirected back to the deploy page.
11. Now your Bot is connected to your number.

## FAQ

<AccordionGroup>
  <Accordion title="How many WhatsApp numbers can I use?">
    You can integrate as many numbers as you need. QuickBot does not provide these numbers — you
    must use your own Meta application.
  </Accordion>

  <Accordion title="Can I link multiple bots to the same WhatsApp number?">
    Yes. You’ll need to configure a **Start bot condition** for each bot so the correct one triggers
    when a user starts a conversation.
  </Accordion>

  <Accordion title="Does WhatsApp integration require a paid API?">
    Integration uses the official **WhatsApp Business Platform** from Meta. Currently, the first
    **1,000 service conversations per month** are free. More details:

    <a href="https://developers.facebook.com/docs/whatsapp/cloud-api/get-started#pricing---payment-methods">
      Meta Pricing Documentation
    </a>

    .
  </Accordion>

  <Accordion title="I receive the initial preview message, but the bot doesn’t reply">
    This may be caused by a mismatch between the WhatsApp number shown in your WhatsApp profile
    settings and the number entered in QuickBot. For example, in Brazil some users have two numbers:
    one with 8 digits and another with 9. You must enter the exact number displayed in your WhatsApp
    profile for the bot to work correctly.
  </Accordion>
</AccordionGroup>


# Audio
Source: https://docs.quick.bot/builder/editor/blocks/agent/audio



The Audio agent block allows you to play audio content to your users. You can either upload an audio
file or provide a direct URL to an audio resource.

<Frame>
  <img alt="Audio bubble" />
</Frame>

## Configuration Options

### Audio Source

The Audio block provides two methods to add audio content:

* **Upload**: Upload an audio file directly from your device
* **Embed Link**: Provide a direct URL to an audio file hosted elsewhere

### Autoplay Setting

You can enable or disable automatic playback of the audio when the block is displayed. Note that
autoplay behavior is subject to browser policies and user interactions.

## Supported Features

* **Variable Support**: The audio URL can include variables that will be dynamically replaced at
  runtime
* **Audio Controls**: Users can play, pause, and control the audio playback
* **Responsive Design**: The audio player adapts to different screen sizes with a maximum width
  constraint

## Troubleshooting

### The first audio bubble is not autoplaying

This is expected behavior. Most web browsers have policies that prevent audio from playing
automatically without user interaction. The user needs to interact with the page before audio can be
played automatically.

### The audio is not playing on iOS / Safari

This typically indicates that your audio file is malformed or uses an unsupported format. Depending
on the source of your audio file, ensure the encoding is done correctly. To verify the file
integrity:

1. Download the audio file to your computer
2. Try playing it locally with your system's media player
3. If it doesn't play locally, re-encode the file using standard audio formats (MP3, WAV, OGG)

### Variables not resolving in audio URLs

If you're using variables in your audio URL and they're not being replaced:

1. Ensure the variable exists in your bot's variable list
2. Check that the variable name is spelled correctly
3. Verify the variable has a value assigned before the audio block is reached


# Embed
Source: https://docs.quick.bot/builder/editor/blocks/agent/embed



The Embed agent block allows you to display websites, iframe content, or multimedia from various
sources to your users.

<Warning>
  Not all websites allow embedding due to security policies (X-Frame-Options). If you see a blank
  space, it means the website you're trying to embed doesn't allow iframe embedding.
</Warning>

<Frame>
  <img alt="Embed bubble" />
</Frame>

To use this block, paste any embeddable URL, an HTML `<iframe>` snippet, or a variable with an URL inside (http\:// or https\://).

## Settings

* **Height**: Configure the height of the embedded content in pixels. This can also be set using
  variables for dynamic sizing.

* **Wait for event?**: Enable this feature when you own the embedded website and want to control the
  bot flow based on events from the embedded content.
  * **Event Name**: Specify the name of the event to listen for.
  * **Save Data**: Choose a variable to store any data sent with the event.

**Event Implementation Example:**

```js theme={null}
window.parent.postMessage(
  {
    name: 'My event',
    data: 'Custom data passed to the bot variable',
  },
  '*',
)
```

The event name must match what you've configured in the Embed block settings.

<Frame>
  <img alt="Embed bubble wait for event configuration" />
</Frame>

### Embed a PDF hosted on Google Drive

1. Select the PDF file you want to embed
2. Right-click → Preview → More actions → Open in a new window
3. Click More actions → Embed item
4. Copy the embed code and paste it in the Embed agent block URL field


# Image
Source: https://docs.quick.bot/builder/editor/blocks/agent/image



The Image block allows you to display images to your users.

<Frame>
  <img alt="Image bubble" />
</Frame>

## Options

The Image block provides multiple ways to add visual content:

* **Upload**: Upload image files directly from your device (supports common formats: PNG, JPG, GIF,
  etc.)
* **URL**: Paste a direct link to an image hosted elsewhere.
* **Variables**: Use variables that contain image URLs for dynamic content.
* **Giphy Integration**: Search and select GIFs directly from Giphy.

Also you can make images interactive by enabling the **On Click link** button

* **URL**: Define where users will be redirected when they click the image.
* **Alt Text**: Provide alternative text for accessibility and as a clickable label.
* **Variable Support**: Both URL and alt text fields support variables for dynamic content.


# Text
Source: https://docs.quick.bot/builder/editor/blocks/agent/text



The Text agent block allows you to display messages to your users. Text bubbles support styling,
links, variables, and can be chained together to create smooth conversational animations.

<Frame>
  <img alt="Text bubbles" />
</Frame>

## Text editor

<Frame>
  <img alt="Text styles" />
</Frame>

Clicking the block opens the text editor. From left to right, you'll find the following options:

### **Variables**

Insert any available variable into the text. The variable format is `{{variable}}` inside the text
editor.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Text variables" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Text variables" />
    </Frame>
  </Tab>
</Tabs>

### **Bold and Italic**

Format the selected text in bold, italic or both.

<Frame>
  <img alt="Text styles" />
</Frame>

### **Link**

Insert or edit a hyperlink.

<Frame>
  <img alt="Text link" />
</Frame>


# Video
Source: https://docs.quick.bot/builder/editor/blocks/agent/video



The Video agent block allows you to display videos from multiple sources to your users. It supports
direct video files (MP4) and automatic embedding from popular video platforms like YouTube, Vimeo,
TikTok, and more.

<Frame>
  <img alt="Video bubble" />
</Frame>

Paste any supported video URL. The system automatically detects the video service and configures
proper embedding.

## Supported Video Services

* **YouTube**: Regular videos and Shorts (automatic URL parsing and iframe embedding)
* **Vimeo**: Professional video hosting with clean player interface
* **TikTok**: Social media videos with custom embed player (300px height)
* **Gumlet**: Video hosting and optimization platform
* **OneDrive**: Microsoft cloud-hosted videos
* **MP4**: Direct video file URLs with HTML5 video player
* **Customizable Controls**: Toggle video controls visibility
* **Variable Support**: Use variables for dynamic video URLs

## Video Configuration

* **Controls Display**: Show or hide video playback controls for direct video files
* **Aspect Ratio**: Configurable video dimensions and sizing
* **Max Width**: Control maximum display width for optimal viewing
* **Auto-sizing**: Automatic size suggestions based on video type
* Use variables in video URLs for dynamic content

## Unsupported Content

* **YouTube Clips**: Not supported due to embed URL restrictions
* **Age-restricted videos**: May not embed properly due to platform restrictions

<Tip>
  If a video service is not supported, use the [Embed block](/builder/editor/blocks/agent/embed) instead.
</Tip>

For video services not in the supported list:


# Grouping Blocks
Source: https://docs.quick.bot/builder/editor/blocks/general



<Frame>
  <img alt="Grouping blocks" />
</Frame>

A group is a collection of blocks that can be moved, duplicated, or deleted. Groups are useful for
organizing complex flows and keeping related blocks together.

A group can not exist without at least one block. If you delete all blocks in a group, the group
will be deleted as well.

You can rename the group by clicking on the group name in the top left corner of the group.

## Group Actions

<Frame>
  <img alt="Group actions" />
</Frame>

When clicking on a group, above the group you will see a menu with the following options, from left to right:

* **Preview** to test the group in a live simulation environment
* **Duplicate** to create a duplicated group with the same blocks and settings
* **Delete** to remove the group.


# Email
Source: https://docs.quick.bot/builder/editor/blocks/integrations/email



The Send Email integration allows you to automatically send emails during your bot flow. Whether you
want to notify yourself when a user completes the bot, send a recap to the user, or trigger any
other email-based workflow, this block provides comprehensive email delivery capabilities.

<Frame>
  <img alt="Email block example" />
</Frame>

## Configuration

### Email Settings

**Recipients (To:)**

* Add multiple email addresses separated by commas
* Supports variable insertion to dynamically set recipients
* Example: `user@example.com, {{Contact Email}}, admin@company.com`

**Subject Line**

* Set a custom subject for your emails
* Supports variable insertion for dynamic subject lines
* Example: `Thank you {{Name}} for completing our bot!`

**Body**

* Choose between Default, Text, or Code/HTML content modes
* Supports variable insertion in all modes
* Default mode generates a professional recap of user responses

### Advanced Options

**Reply-To Address**

* Set a different email address for replies
* Useful for directing responses to a specific inbox
* Supports variable insertion

**Carbon Copy (CC)**

* Send copies to additional recipients
* Multiple addresses supported (comma-separated)
* Recipients can see other CC addresses

**Blind Carbon Copy (BCC)**

* Send hidden copies to recipients
* Other recipients cannot see BCC addresses
* Useful for internal notifications

## SMTP Configuration

Configure your own SMTP server for branded email delivery:

### Required Settings

* **From email**: The sender's email address (e.g., `noreply@yourcompany.com`)
* **From name**: Display name for the sender (e.g., `Your Company Name`)
* **Host**: SMTP server hostname (e.g., `smtp.gmail.com`, `smtp.sendgrid.net`)
* **Username**: SMTP authentication username
* **Password**: SMTP authentication password
* **Port**: SMTP server port (common values: 25, 587, 465)

**Security Settings:**

* **TLS/SSL**: Enable secure connection (recommended for ports 587/465)

### SMTP Provider Compatibility

The Send Email integration works with popular SMTP providers:

**Gmail/Google Workspace**

* Host: `smtp.gmail.com`
* Port: 587 (TLS) or 465 (SSL)
* Use App Passwords for enhanced security

**SendGrid**

* Host: `smtp.sendgrid.net`
* Port: 587
* Use API key as password

**Mailgun**

* Host: `smtp.mailgun.org`
* Port: 587
* Use Mailgun SMTP credentials

**AWS SES**

* Host: Regional endpoint (e.g., `email-smtp.us-east-1.amazonaws.com`)
* Port: 587 or 25
* Use SES SMTP credentials

### Security Features

**Credential Encryption**

* All SMTP credentials are encrypted at rest
* Passwords are never logged or displayed
* Secure credential storage with AES encryption

**Connection Security**

* TLS/SSL support for encrypted transmission
* Authentication required for all custom SMTP configs
* Secure credential validation during setup

### How To Setup a GMail SMTP

To use Gmail's SMTP server, follow these steps:

**Activate two-step verification**

1. Open your [Google Account](https://myaccount.google.com/).
2. Tap **Security & sign-in**.
3. Under “How you sign in to Google,” select Turn on 2-Step Verification.
4. Follow the on-screen steps.

**Create & use app passwords**

if you use 2-Step-Verification and get a "password incorrect" error when you sign in, you can try to
use an app password.

1. Go to your [Create and manage your app passwords](https://myaccount.google.com/apppasswords). You
   may need to sign in to your Google Account. If you've set up 2-Step Verification but can't find
   the option to add an app password, it might be because:

   * Your Google Account has 2-Step Verification
     [set up only for security keys](https://support.google.com/accounts/answer/6103523).
   * You're logged into a work, school, or another organization account.
   * Your Google Account has
     [Advanced Protection](https://support.google.com/accounts/answer/7539956).

   TIP: Usually, you'll need to enter an app password once per app or device.

2. Add a custom name for the application and click **generate**.

3. Copy the generated password and use it as the SMTP password in your email block configuration.

   **IMPORTANT**: save the generated password securely, as you won't be able to view it again. If you lose it, you'll need to generate a new one.

4. Inside your email block configuration, use the following settings:
   * **Name**: a name for your SMTP configuration (e.g., "Gmail SMTP")
   * **From email**: your full Gmail email
   * **From name**: your desired sender name (e.g., "Your Name" or "Your Company")
   * **Host**: `smtp.gmail.com`
   * **Username**: your full Gmail email address
   * **Password**: the generated app password from step 3
   * **Secure**: enabled (SSL)
   * **Port**: 465 (SSL)

## Troubleshooting

### SMTP Configuration Issues

**Connection Problems**

```
Error: Unable to connect to SMTP server
```

* Verify host and port settings
* Check firewall/network restrictions
* Confirm TLS/SSL settings match provider requirements
* Test with telnet: `telnet smtp.provider.com 587`

**Authentication Failures**

```
Error: Invalid login credentials
```

* Verify username and password accuracy
* Use App Passwords for Gmail (not account password)
* Check if two-factor authentication requires special credentials
* Confirm account has SMTP access enabled

**TLS/SSL Issues**

```
Error: TLS negotiation failed
```

* Try different security settings (TLS vs SSL vs none)
* Verify port matches security setting (587 for TLS, 465 for SSL)
* Check if provider requires specific TLS versions
* Test with different port numbers

### Email Delivery Problems

**Emails Not Received**

1. Check spam/junk folders
2. Verify recipient email addresses are correct
3. Review email logs in the bot results
4. Test SMTP configuration with simple test email
5. Check sender reputation and domain authentication

**Attachment Issues**

* Ensure file variable contains valid file URLs
* Check file size limits (most providers limit to 25MB)
* Verify file types are allowed by recipient email system
* Test with different file formats

**Variable Replacement Problems**

* Confirm variable names match exactly (case-sensitive)
* Check that variables have been collected before the email block
* Test variable values in other parts of the bot
* Review variable scope and availability

### Performance Optimization

**Slow Email Sending**

* Check SMTP provider response times
* Consider using dedicated IP addresses for high volume
* Implement connection pooling for multiple emails
* Monitor server resources during email processing

**Rate Limiting**

* Respect provider sending limits
* Implement delays between emails if needed
* Consider queuing emails for large batches
* Monitor bounce rates and delivery statistics

### Debugging Tools

**Email Logs** Access detailed email logs in the [bot results table](/builder/results/table):

* SMTP connection details
* Email content and recipients
* Error messages and stack traces
* Delivery status and timing information

**SMTP Testing** Use the built-in SMTP test feature:

1. Configure SMTP settings in the email block
2. Click "Create" to test the configuration
3. Check for test email delivery
4. Review any error messages in the interface

**Log Analysis** Common log entries:

* `Email successfully sent`: Email delivered to SMTP server
* `Email not sent`: General delivery failure
* `Emails are not sent in preview mode`: Preview mode protection active
* Connection timeout or authentication errors: SMTP configuration issues

For additional support, check the logs first, then contact support through the chat button in the
application.


# FreshDesk
Source: https://docs.quick.bot/builder/editor/blocks/integrations/freshdesk

Integrate your QuickBot with FreshDesk to manage support tickets automatically

The FreshDesk integration allows you to automatically create support tickets and manage customer
inquiries through your QuickBot, without leaving the conversation flow.

## Configuration

### Credentials Setup

Before using the FreshDesk block, you must configure your domain and API key:

1. **FreshDesk credentials**: Select or create FreshDesk credentials in the block settings.

2. **Get your domain** — this is the URL you use to access your FreshDesk account:
   * It follows the format `yourcompany.freshdesk.com`
   * Enter it **without** the `https://` prefix (e.g., `acme.freshdesk.com`)

3. **Get your API key** — if you don't have it yet:

   1. Log into your FreshDesk account.
   2. Click your **profile avatar** (top-right corner) and go to **Profile Settings**.
   3. Scroll to the **Your API Key** section on the right side of the page.
   4. Copy the key and paste it into the **API Key** field in the credentials form.

   <Note>
     Your API key is unique to your FreshDesk user account. If you need team-level access,
     consider using a dedicated agent account. The key is securely encrypted and stored.
   </Note>

   <Tip>
     You can also find step-by-step instructions in the [FreshDesk documentation](https://support.freshdesk.com/en/support/solutions/articles/215517-how-to-find-your-api-key).
   </Tip>

## Actions

### Create Ticket

Automatically creates a new support ticket in FreshDesk with the following fields:

* **Subject**: Title of the support ticket
* **Description**: Detailed description of the issue
* **Priority**: Ticket priority level (Low, Medium, High, Urgent)
* **Requester email**: Email address of the customer
* **Custom fields**: Any additional fields configured in your FreshDesk instance

### Get Ticket Types

Retrieves available ticket types from your FreshDesk instance so you can use them in
conditional logic or dynamic dropdowns within your bot flow.

## Use Cases

* Automatically create support tickets from bot conversations
* Escalate issues based on user responses
* Collect customer information for support cases
* Route inquiries to the appropriate department based on the topic selected by the user

## Troubleshooting

### "Authentication Failed" or "Invalid API Key"

**Resolution Steps:**

1. Verify the API key is correct — go to your [FreshDesk Profile Settings](https://support.freshdesk.com/en/support/solutions/articles/215517-how-to-find-your-api-key) to find it again.
2. Ensure the key was copied in full (no leading/trailing spaces).
3. Confirm the agent account associated with the key is active and not suspended.

### Tickets Not Being Created

**Common Causes:**

* **Missing required fields**: Subject, description, and requester email are required.
* **Invalid email format**: Ensure the requester email is a valid address.
* **Wrong domain**: Double-check the domain — it should be `yourcompany.freshdesk.com` without `https://`.
* **Permission issue**: The API key must belong to an agent with ticket creation permissions.

### Ticket Types Not Loading

**Troubleshooting:**

* Verify that ticket types are configured in your FreshDesk account under **Admin → Ticket Fields**.
* Ensure the credentials used have access to list ticket type values.

### Getting Help

* **FreshDesk API docs**: [developers.freshdesk.com](https://developers.freshdesk.com/api/)
* **FreshDesk Status**: Check [freshdesk.com/status](https://www.freshdesk.com/status) for service issues
* **Community Support**: Reach out to the QuickBot community for implementation help


# Google Analytics
Source: https://docs.quick.bot/builder/editor/blocks/integrations/google-analytics



The Google Analytics integration block allows you to track Google Analytics events at specific
moments in your bot flow. This integration supports Google Analytics 4 (GA4) with comprehensive
event tracking and conversion measurement capabilities.

When your flow contains a Google Analytics block, it automatically:

* Initializes Google Analytics (GA4) on page load with your tracking ID
* Tracks a "PageView" event when the page loads
* Executes custom event tracking when the block is reached in your flow

## Credentials Setup

Before using the Google Analytics block, you must configure your GA4 credentials:

* **Measurement ID (Required)**: Your GA4 Measurement ID, format: `G-XXXXXXXXXX`. Supports variable
  substitution for dynamic tracking IDs

  <Info>
    Can be found in your Google Analytics dashboard under Admin > Property Settings > Data Streams
  </Info>

* **Event Action (Required)**: The name of the event you want to track. e.g: `conversion`,
  `lead_generated`, `form_completed`. Supports variable substitution for dynamic event names

## Advanced

* **Event Category**: Categorizes your events for better organization e.g: `Bot`, `Form`,
  `Engagement`
* **Event Label**: Additional context for your events e.g: Campaign names, specific form names, or
  user segments
* **Event Value**: Numeric value associated with the event commonly used for conversion values or
  scoring
* **Send To**: sends events to specific Google Ads accounts for conversion tracking. Format:
  `AW-CONVERSION_ID` for Google Ads

### Debug Mode

Enable debug mode to see detailed console logs of GA4 events. Verify event parameters and values are
being sent correctly

<Note>
  Install the [Google Analytics
  Debugger](https://chrome.google.com/webstore/detail/google-analytics-debugger/jnkmfdileelhofjcijamephohjechhna)
  Chrome extension
</Note>

For Google Ads conversion tracking specifically, ensure your conversion actions are properly
configured and that you're using the correct conversion ID format.


# Google Sheets
Source: https://docs.quick.bot/builder/editor/blocks/integrations/google-sheets



The Google Sheets integration block enables data management with Google Spreadsheets, supporting
create, read, update operations with advanced filtering, data mapping, and OAuth authentication.

## Authentication Setup

1. Click in **+ Add Google Sheets Account**.
2. Then continue with Google and select the account you want to use.
3. Grants access to your Google Sheets.

## Select an action

Select from three primary operations:

### Get Row

Retrieve and filter spreadsheet data with flexible options:

* **Row Selection**: Extract All, First, Last, or Random matching rows
* **Advanced Filtering**: Complex filter rules with multiple comparison operators
* **Column Extraction**: Select specific columns to retrieve
* **Variable Mapping**: Save extracted data to bot variables for reuse

### Insert Row

Add new records to your spreadsheet with full variable support:

* **Column Mapping**: Map bot variables to specific spreadsheet columns
* **Dynamic Values**: Use variables, static text, or expressions
* **Header Validation**: Ensures columns exist before insertion
* **Batch Support**: Insert multiple values in a single operation

### Update Row

Modify existing spreadsheet data with advanced filtering:

* **Filter Criteria**: Define complex filter rules to identify target rows
* **Logical Operators**: Combine filters with AND/OR operations
* **Selective Updates**: Update only specific columns while preserving others
* **Batch Updates**: Update multiple rows matching filter criteria

## Data Filtering System

The Google Sheets integration provides a sophisticated filtering system for precise data operations:

### Comparison Operators

* **Equal to**: Exact value matching
* **Not equal to**: Value exclusion
* **Contains**: Substring matching (case-insensitive)
* **Greater than**: Numeric comparison
* **Less than**: Numeric comparison
* **Is set**: Check for non-empty values

### Logical Operations

* **AND Logic**: All filter conditions must match
* **OR Logic**: Any filter condition can match
* **Mixed Logic**: Combine multiple filter rules with different operators

### Example Filter Configuration

```
Email [Equal to] {{User_Email}}
AND
Status [Not equal to] "inactive"
OR
Last_Login [Greater than] {{30_Days_Ago}}
```

## Output

Extract data from spreadsheet responses:

* Individual column values
* Complete row data
* Calculated results
* Row count information


# HTTP Request
Source: https://docs.quick.bot/builder/editor/blocks/integrations/http-request



The HTTP Request block allows you to send HTTP requests to external services and APIs. This powerful
integration enables you to connect your bot with virtually any web service, send data, retrieve
information, and automate workflows.

## Configuration Options

### Basic Configuration

* **URL**: The endpoint URL where the request will be sent (supports variable interpolation)
* **Method**: HTTP method (GET, POST, PUT, PATCH, DELETE, HEAD, CONNECT, OPTIONS, TRACE)
* **Execution Location**: Choose between server-side or client-side execution

### Advanced Configuration

* **Query Parameters**: Add URL query parameters with variable support
* **Headers**: Set custom HTTP headers including authentication tokens
* **Custom Body**: Define request body with JSON, form data, or custom formats
* **Timeout**: Configure request timeout (1-600000ms, default: 10000ms)
* **Variable Mapping**: Map response data to bot variables for reuse

## Features

### Variable Support

The HTTP Request block fully supports QuickBot variables in:

* URL endpoints
* Query parameters
* Headers
* Request body
* Test values for debugging

### Response Processing

* Automatic JSON response parsing
* Deep key extraction from nested objects
* Variable mapping from response data
* Test response preview with syntax highlighting

### Error Handling

* Request timeout management
* HTTP status code handling
* Detailed error messages in logs
* Test mode for debugging before deployment

## Advanced Features

### Custom Request Body

Enable custom body to send structured data with your variables:

```json theme={null}
{
  "name": "{{Name}}",
  "email": "{{Email}}",
  "timestamp": "{{Now}}",
  "metadata": {
    "source": "quickbot",
    "bot_id": "{{Bot ID}}"
  }
}
```

### Authentication Headers

Add authentication headers for secure API access:

* `Authorization: Bearer {{API_Token}}`
* `X-API-Key: {{API_Key}}`
* `Content-Type: application/json`

### Query Parameters

Add dynamic query parameters:

* `user_id={{User_ID}}`
* `timestamp={{Now}}`
* `format=json`

### Response Variable Mapping

Map API response data to bot variables for later use:

* Extract user information from API responses
* Store calculated values
* Capture IDs for follow-up requests

## Examples

### Example: Employee Management API

This video demonstrates configuring HTTP Request blocks for CREATE and GET operations:

<YoutubeVideo />

### Example: Movie Information API

Create a bot that fetches movie information from OMDB API:

**Step 1: Configure URL with Variables**

```
http://www.omdbapi.com/?t={{Movie_Title}}&apikey={{OMDB_API_Key}}
```

<Frame>
  <img alt="Variable in URL" />
</Frame>

**Step 2: Set Test Values** Configure test values to preview the request:

<Frame>
  <img alt="Variable test values" />
</Frame>

**Step 3: Test and Map Response** Test the request and map response data to variables:

<Frame>
  <img alt="Test request" />
</Frame>

**Step 4: Use Response Data** Display the retrieved information in subsequent blocks:

### Integration Capabilities

* Connect with any REST API
* Support for GraphQL endpoints
* HTTP-based triggers for real-time updates
* Third-party service integrations (Zapier, Make.com, etc.)
* Custom authentication flows
* Data transformation and validation

Need help setting up an HTTP Request? Join our [community](https://discord.com/invite/U3rs3rPPQ4)
for assistance.

## Third-Party Integration

### Quick Setup for Automation Services

For services like Make.com, Zapier, or Pabbly Connect:

1. **Get Webhook URL**: Copy the webhook URL from your automation platform
2. **Paste URL**: Enter the URL in the HTTP Request block
3. **Test Request**: Click "Test the request" to send sample data
4. **Customize Payload**: Modify the request body to include specific bot data

<Frame>
  <img alt="Simple Webhook POST" />
</Frame>

### Custom Payload Configuration

Tailor the data sent to your automation service:

```json theme={null}
{
  "bot_id": "{{Bot ID}}",
  "user_data": {
    "name": "{{Name}}",
    "email": "{{Email}}",
    "phone": "{{Phone}}"
  },
  "form_data": {
    "message": "{{Message}}",
    "timestamp": "{{Now}}"
  },
  "metadata": {
    "source": "quickbot_http_request",
    "conversation_id": "{{Conversation ID}}"
  }
}
```

## Advanced Configuration

### Timeout Settings

* **Default Timeout**: 10 seconds (10,000ms)
* **Configurable Range**: 1ms to 600,000ms (10 minutes)
* **Failure Behavior**: Block fails if timeout exceeded
* **Location**: Advanced Parameters section

### Execution Context

* **Server-side Execution**: Secure, hidden from client, supports all HTTP methods
* **Client-side Execution**: Faster for simple requests, CORS restrictions may apply
* **Default**: Server-side execution recommended for security

### Request Methods

Supported HTTP methods:

* **GET**: Retrieve data from APIs
* **POST**: Create new resources or send data
* **PUT**: Update existing resources completely
* **PATCH**: Partial resource updates
* **DELETE**: Remove resources
* **HEAD**: Get headers without body
* **OPTIONS**: Check supported methods
* **CONNECT/TRACE**: Advanced networking (rarely used)

## Troubleshooting

### Common Configuration Issues

**Request Failures**

* Check the [logs](/builder/results/table) for detailed error messages
* Verify URL format and accessibility
* Confirm API endpoint accepts your HTTP method
* Validate authentication headers and credentials

**Variable-Related Problems**

* Ensure variables exist before using in requests
* Check variable names match exactly (case-sensitive)
* Verify test values are set for debugging
* Confirm variable interpolation syntax: `{{Variable_Name}}`

**Response Mapping Issues**

* Verify response structure matches mapping configuration
* Check that response keys exist in API response
* Ensure proper JSON format in API response
* Test response structure with "Test the request" feature

### Platform-Specific Considerations

**CORS Errors (Client-side Execution)**

* Switch to server-side execution for cross-origin requests
* Contact API provider about CORS policy
* Use proxy endpoints when necessary

**Execution Order** HTTP Requests execute in sequence during block processing:

* All blocks between user inputs are computed server-side
* Results are processed before displaying to user
* Use proper flow design for dependent HTTP Request calls

**Authentication Failures**

* Verify API key/token validity and permissions
* Check authentication method (Bearer token, API key header, etc.)
* Ensure credentials are stored in variables, not hardcoded
* Test authentication with API documentation examples

### Performance Issues

* Increase timeout for slow APIs
* Optimize request payload size
* Consider caching for frequently requested data
* Monitor API rate limits and usage quotas

<YoutubeVideo />

Need additional help? Contact support through the chat button in the QuickBot interface.


# OpenAI
Source: https://docs.quick.bot/builder/editor/blocks/integrations/openai



The OpenAI integration block provides access to OpenAI's AI models and services. This block supports
both OpenAI's official API and compatible providers with custom configurations.

## Credentials Setup

Before using any OpenAI functionality, you must configure your API credentials:

1. **OpenAI Account**: Select or create OpenAI API credentials in the block settings.

2. **Get your API key** — if you don't have one yet:

   1. Create an account or sign in at [platform.openai.com](https://platform.openai.com).
   2. Go to **Dashboard → API keys** (or visit the
      [API keys page](https://platform.openai.com/account/api-keys) directly).
   3. Click **Create new secret key**, give it a name, and copy it immediately — it won't be shown
      again.
   4. Paste the key into the **API key** field in the credentials form.

   <Note>
     API keys are securely encrypted and stored. Never share them or expose them in client-side
     code.
   </Note>

3. **Custom Provider Settings** (Optional)
   * **Base URL**: Override the default OpenAI API endpoint (`https://api.openai.com/v1`)
   * **API Version**: Specify API version for Azure OpenAI or other compatible services
   * Supports OpenAI-compatible providers like Azure OpenAI, LocalAI, or custom implementations

## Configurations

<Frame>
  <img alt="OpenAI block" />
</Frame>

### Actions

Select a task for the bot to perform.

* **Create chat completion**: Generate conversational responses using GPT models.

<Note>Currently, only one action is supported, but this may change in the future.</Note>

### Models

Choose one of the avaiable models

<Tip>
  If you're not sure where to start, use gpt-5.4, for complex reasoning and coding. If you're
  optimizing for latency and cost, choose a smaller variant like gpt-5.4-mini or gpt-5.4-nano.
</Tip>

### Message

Configure the conversation context with message types:

* **System**: Define AI behavior and instructions
* **User**: Represent user input and queries
* **Assistant**: Include AI responses for context
* **Dialogue**: Reference conversation history variables

You can add multiple message types here, depending on how complex you want your bot to be.

<Tip> We recommend adding a system message in this format for the best results.</Tip>

```
### Instructions
You are a friendly assistant collecting names from users through natural conversation.

Your goal is to collect the following information:
1. **Full Name** - The user's complete name
### CRITICAL: Review the conversation history to see what information has already been provided!

### Guidelines:
- Be conversational and friendly
- If information is missing, politely ask ONLY for the missing fields
- Be helpful and guide the user naturally

### Examples:
User: "My name is John Doe"
Assistant: "Great to meet you, John!"

Always be polite and make the user feel comfortable sharing their information.
```

<Tip>
  For dialogue type,we recommend using the **conversation** system variable, which is automatically
  available.
</Tip>

<Frame>
  <img alt="OpenAI messages sequence" />
</Frame>

### Tools

Define tools that the AI can use to perform actions or retrieve information. Each tool works like a
programming function, with configurable parameters and custom code that is executed when the tool is
called.

<Note>
  This feature requires a basic understanding of programming. We recommend using templates to see
  how this feature works in practice.
</Note>

The parameter required for this are:

* **Name**: the name of the function.
* **Description**: a description of what this function do.
* **Parameters**: Define the parameters required by this function. You can add as many parameters as
  needed. For each parameter, specify:
  * Data type (string, number, boolean, or enum).
  * Name.
  * Description.
  * Whether it is required. If not, the function will accept an empty value for that parameter.

<Frame>
  <img alt="OpenAI messages sequence" />
</Frame>

Inside the code snippet, write your custom code using the parameters defined above. It should return
a value.

```javascript theme={null}
// Return the captured data as a structured object
return JSON.stringify({
  fullName,
  email,
  address,
  capturedAt: new Date().toISOString(),
})
```

### Settings

Adjust the core parameters used to control the AI model’s output.

* **Temperature**: Controls the randomness of the AI responses. Lower values make the output more
  focused and deterministic, while higher values increase creativity and variability.

* **Max Tokens**: Tokens are the building blocks of text that OpenAI models process. They can be as
  short as a single character or as long as a full word, depending on the language and context.
  Spaces, punctuation, and partial words all contribute to token counts.

### Response

Define how the AI's response should be saved into variables so it can be used later. You can store:

* **Message content**: the model's text reply
* **Token usage**: token usage count
* **Tool results**: the output of the last tool that ran:


# Stripe
Source: https://docs.quick.bot/builder/editor/blocks/integrations/stripe



The Stripe block allows you to collect payment. You first need to add your Stripe:

## Connect Stripe account

After clicking on `Select an account > Connect new`, a configuration popup appears:

* Account name could be anything you'd like it's not something that has to come from Stripe.
* Test keys can be found here: [https://dashboard.stripe.com/test/apikeys](https://dashboard.stripe.com/test/apikeys)
* Live keys can be found here: [https://dashboard.stripe.com/apikeys](https://dashboard.stripe.com/apikeys)

Test keys will be used in the preview for testing purposes. Live keys will be used in the published
bot.

If you'd still like to still use the test keys in the published bot you just need to also fill in
the test keys into the live keys inputs.

*If you would like to simulate a successful payment, use test cards from the following list in
Stripe -> [https://docs.stripe.com/testing?testing-method=card-numbers#cards](https://docs.stripe.com/testing?testing-method=card-numbers#cards)*

## Input configuration

Once you have a Stripe account, you can select it and configure your input:

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="stripe input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="stripe input in bot" />
    </Frame>
  </Tab>
</Tabs>

Make sure to enable any payment method you'd like to appear in your Stripe dashboard at this URL:
[https://dashboard.stripe.com/settings/payment\_methods](https://dashboard.stripe.com/settings/payment_methods).

This is where you can enable Cards, Apple Pay, Google Pay, Alipay, WeChat Pay etc.


# WooCommerce
Source: https://docs.quick.bot/builder/editor/blocks/integrations/woocommerce



The **WooCommerce integration block** allows you to connect your QuickBot to a WooCommerce store and
search for products directly within your chat flows. This enables you to create interactive shopping
experiences, product recommendations, and automated customer support with real-time product data.

***

## General

This block integrates with the WooCommerce REST API to provide product search functionality. After
authentication, you can search for products by name and display formatted results with prices,
links, and detailed information to enhance user engagement.

***

## Prerequisites

Before configuring the WooCommerce block, ensure your WooCommerce store is properly set up:

### 1. Enable REST API

1. Navigate to **WooCommerce > Settings > Advanced > REST API** in your WordPress dashboard.

<Frame>
  <img alt="woocommerce api panel" />
</Frame>

2. Click **Create an API Key** to create new API credentials.

3. Configure the API key settings:
   * **Description**: Give it a descriptive name (e.g., "QuickBot Integration")
   * **User**: Select a user with appropriate permissions
   * **Permissions**: Select **Read**

<Frame>
  <img alt="WooCommerce REST API generation" />
</Frame>

4. After creating the API key, copy the following credentials for later use:

* **Consumer Key**
* **Consumer Secret**
* **Site URL** (your WordPress site URL)

<Frame>
  <img alt="Woocommerce api generated" />
</Frame>

***

## Configuring the WooCommerce Block

1. Grab the WooCommerce block from integrations, and drop into the flow.

<Frame>
  <img alt="Woocommerce block flow" />
</Frame>

2. In the WooCommerce block, click **Add WooCommerce credentials** button.

<Frame>
  <img alt="Woocommerce block" />
</Frame>

3. Fill in the fields using the credentials generated earlier, then click **Create**.

<Frame>
  <img alt="WooCommerce Credentials" />
</Frame>

***

## Setting Up Variables

Done with the authentication. Click on WooCommerce Block, then **Select an action** and select
**Search Products**

<Frame>
  <img alt="Select Search Products Action" />
</Frame>

Create a new variable for the search functionality, such as **productSearch** and assign it in
Search Term selector

<Frame>
  <img alt="Input variable" />
</Frame>

Create a another variables for the result of the search, **productsResult**. Assign it in the Output
Variable selector.

<Frame>
  <img alt="Output variable" />
</Frame>

You can check your variables created in the flow editor sidebar, at Variables tab.

<Frame>
  <img alt="Variables" />
</Frame>

***

## Using the variables into the flow

Now with our variables created for our WordPress block, you can start using it into the flow.

1. Add a **text input component** from the **User section** in the Flow sidebar into the group. This
   input will allow the user to search products .

   Important: the Input component must be loaded before the WordPress block. To ensure this, either:

   a. Place the input components above the WordPress block within the same group, or

   <Frame>
     <img alt="group example 1" />
   </Frame>

   b. Create a flow that first loads a group with the input components, and then a second group that
   loads the WordPress block.

   <Frame>
     <img alt="group example 2" />
   </Frame>

2. Assign their respective variables in the **Save the answer in a variable** field.

<Frame>
  <img alt="text variable" />
</Frame>

3. Add a **Text component** from the **Agent section** to your flow. Inside the message body, insert
   the variable assigned in the Output Variable field from the WooCommerce block to display the
   search result.

<Frame>
  <img alt="agent component" />
</Frame>

`Note: variables need to be inside "{{}}" in text inputs.`

4. Lastly, anchor the User group with the Agent group. Your flow needs to look like this:

<Frame>
  <img alt="flow example" />
</Frame>

And this is how it looks like in the preview.

<Frame>
  <img alt="woocommerce preview" />
</Frame>

***

## Advanced Features

### Authentication & Security

* **OAuth 1.0a Authentication**: Secure API access using HMAC-SHA1 signature method
* **Encrypted Credentials**: Consumer keys and secrets stored with encryption
* **Read-only Access**: Recommended permissions for safe product data retrieval
* **SSL/HTTPS Support**: Secure connections to WooCommerce endpoints

### API Capabilities

#### Search Products Action

* **Text-based Search**: Search products by name, description, or SKU
* **Pagination Support**: Configure results per page (max 100 products)
* **Multiple Format Options**: List or detailed product display formats
* **Customizable Output**: Control price display and link inclusion
* **Variable Integration**: Output formatted text and structured data to variables

#### Get Product By ID Action

* **Direct Retrieval**: Fetch specific products using WooCommerce product IDs
* **Detailed Information**: Access complete product data including variations
* **Custom Formatting**: Control display format and included information
* **Error Handling**: Graceful handling of non-existent product IDs

### Data Processing

* **Product Formatting Service**: Automated formatting of product data for display
* **Link Generation**: Automatic conversion of permalinks to clickable links
* **Price Formatting**: Currency-aware price display with WooCommerce settings
* **Template System**: Reusable formatting templates for consistent presentation

### Performance Optimization

* **Connection Pooling**: Efficient API connection management
* **Request Optimization**: Optimized API calls to minimize response times
* **Error Recovery**: Automatic retry logic for transient failures
* **Rate Limiting**: Respect WooCommerce API rate limits

***

## Troubleshooting

### Common Issues

#### Authentication Problems

* **Invalid Consumer Key**: Verify the consumer key is correctly copied from WooCommerce
* **Invalid Consumer Secret**: Ensure the consumer secret matches the WooCommerce settings
* **Permission Denied**: Check that the API key has read permissions enabled
* **SSL Certificate Issues**: Verify SSL certificates are properly configured

#### API Connection Issues

* **Site URL Mismatch**: Ensure the site URL matches your WordPress installation
* **REST API Disabled**: Verify WooCommerce REST API is enabled
* **Firewall Blocking**: Check for firewall rules blocking API access
* **Plugin Conflicts**: Test for WordPress plugin conflicts affecting the API

#### Search and Data Issues

* **No Results Found**: Verify products exist and match search criteria
* **Incomplete Data**: Check product data completeness in WooCommerce
* **Format Issues**: Verify output format settings and variable configurations
* **Variable Not Set**: Ensure output variables are properly configured

#### Performance Issues

* **Slow Responses**: Check WooCommerce server performance and optimization
* **Timeout Errors**: Consider increasing timeout settings or optimizing queries
* **High Memory Usage**: Monitor memory usage with large product catalogs
* **Rate Limiting**: Implement proper rate limiting to avoid API throttling

### Debugging Steps

1. **Test API Directly**: Use tools like Postman to test WooCommerce API directly
2. **Check Server Logs**: Review WordPress and server error logs
3. **Validate Credentials**: Verify API credentials in WooCommerce settings
4. **Network Connectivity**: Test network connectivity between QuickBot and WooCommerce
5. **Product Data**: Verify product data exists and is properly configured

### Error Messages

* **"WooCommerce API credentials are not properly configured"**: Check consumer key and secret
* **"Required parameters are missing"**: Verify all required fields are filled
* **"Product not found"**: Check product ID exists and is published
* **"No products found"**: Verify search term matches existing products
* **"WooCommerce API Error"**: Check WooCommerce API status and configuration


# WordPress
Source: https://docs.quick.bot/builder/editor/blocks/integrations/wordpress



The **WordPress integration block** allows you to connect your QuickBot to a WordPress site and
manage content, users, and interactions directly within your chat flows. This enables you to create
dynamic content management experiences, user registration workflows, and automated content
publishing with real-time WordPress data.

***

## General

This block integrates with the WordPress REST API and miniOrange OAuth/OpenID Connect Server to
provide comprehensive WordPress functionality. After authentication, you can create posts, manage
users, and handle content dynamically to enhance user engagement and automate content workflows.

***

## Prerequisites

Before configuring the WordPress block, ensure your WordPress site is properly set up:

### 1. WordPress Installation

Ensure you have:

* A working WordPress installation (version 5.6 or higher)
* Administrator access to your WordPress dashboard
* HTTPS enabled on your WordPress site (recommended for secure connections)

### 2. Install miniOrange OAuth Plugin

1. Navigate to **Plugins > Add New** in your WordPress dashboard.
2. Search for **miniOrange OAuth/OpenID Connect Server**.
3. Install and activate the plugin.

### 3. Configure OAuth Client

1. In your WordPress dashboard, go to **miniOrange OAuth Server > Configure your Application**.
2. Click **Add Client** to create new OAuth credentials.
3. Configure the client settings:
   * **Client Name**: Give it a descriptive name (e.g., "QuickBot Integration")
   * **Redirect URI**: Configure according to your QuickBot setup
   * **Grant Types**: Select appropriate grant types for your use case

<Frame>
  <img alt="WordPress miniOrange Credentials" />
</Frame>

4. After creating the client, copy the following credentials for later use:

* **Client ID**
* **Client Secret**
* **Token Endpoint** (usually `https://your-site.com/wp-json/moserver/token`)

### 4. Generate Application Password

Application Passwords allow QuickBot to authenticate with WordPress REST API using the admin email
without exposing the actual WordPress login password. The Application Password works together with
the Admin Email to create a secure authentication pair.

**Steps to generate an Application Password:**

1. Log in to your WordPress site: `https://yoursite.com/wp-admin/`

2. Navigate to **Users > Profile** (or **Users > Your Profile** for your own account).

3. Scroll down to the **Application Passwords** section (located near the bottom of the page).

4. In the **New Application Password Name** field, enter a descriptive name:

   * Example: `quick.bot` or `Quick.bot API`
   * This helps you identify which application is using this password

5. Click **Add Application Password**.

6. WordPress will display a green notification banner with your generated password:
   * Format: `BMEn ybFR Kjpa SS18 1Tg6 isFb` (5 groups of 4 characters, 24 total)
   * The password is separated by spaces for readability
   * A **Copy** button is provided for easy copying

<Frame>
  <img alt="WordPress Application Password generation and display" />
</Frame>

7. **Copy the password immediately** using the Copy button or by selecting the text.

   * The message "Be sure to save this in a safe location. You will not be able to retrieve it."
     will be displayed
   * Once you leave or refresh the page, this password cannot be viewed again

8. The newly created password will appear in the table below showing:
   * **Name**: The name you provided (e.g., "quick.bot")
   * **Created**: The date it was generated
   * **Last Used**: When it was last used for authentication
   * **Last IP**: The IP address of the last authentication
   * **Revoke**: Button to revoke this password if needed

**Important Notes:**

* The Application Password must be used together with the Admin Email address
* Format: WordPress displays the password with spaces (e.g., `BMEn ybFR Kjpa SS18 1Tg6 isFb`), but
  you can enter it with or without spaces - WordPress accepts both formats
* If you lose the password, you cannot recover it. You must revoke it from the table and create a
  new one
* Store this password securely (e.g., in a password manager or QuickBot credentials storage)
* Each Application Password is unique and can be revoked independently from the Application
  Passwords table
* You can create multiple Application Passwords for different applications or purposes

**How Application Password relates to Admin Email:**

The WordPress REST API uses Basic Authentication with these credentials:

* **Username**: Admin Email (e.g., `admin@yoursite.com`)
* **Password**: Application Password (the generated key)

This combination allows QuickBot to perform authenticated API operations such as creating posts,
managing users, and accessing protected content without using your main WordPress password.

### 5. Verify Token Endpoint

To confirm your token endpoint:

1. Open the OpenID Discovery configuration URL:
   `https://your-site.com/wp-json/moserver/<CLIENT_ID>/.well-known/openid-configuration`
2. Look for the `"token_endpoint"` field and verify its value.

Note: In older versions, it might appear as `/wp-json/mo_oauth/token`. Always use the endpoint shown
in the discovery document.

***

## Configuring the WordPress Block

### Required Configuration Fields

The WordPress Authentication block requires the following fields:

#### 1. Name

* An internal name to identify this connection within QuickBot
* Example: `My WordPress Account`
* This is user-defined and helps you organize multiple WordPress connections

#### 2. Client ID

* The public OAuth client identifier generated by miniOrange
* Located in **miniOrange OAuth Server > Configure your Application**
* Copy from the **Client ID** field of your created client

#### 3. Client Secret

* The secret key associated with the Client ID
* Located in the same client configuration under **miniOrange OAuth Server**
* Use the visibility toggle if the secret is hidden

**Security Note**: Never share this value publicly or expose it in client-side code.

#### 4. Token Endpoint

* The URL where miniOrange provides OAuth tokens
* Standard format: `https://your-site.com/wp-json/moserver/token`
* Verify using the OpenID Discovery configuration document

#### 5. Admin Email

* The administrator's email address for WordPress operations
* This email is used as the username for REST API authentication (paired with Application Password)
* Found in **Users > All Users** (select admin user) or **Settings > General > Administration Email
  Address**
* **Important**: Use the email of the same user who generated the Application Password
* Consider using a dedicated admin email (e.g., `bot-admin@yoursite.com`)

#### 6. Application Password

* An application password generated for the admin user specified in the Admin Email field
* Required for REST API authentication (creating users, posts, etc.)
* Generated from **Users > Profile > Application Passwords** section
* **Must match the user whose email is specified in Admin Email field**
* This password is used together with the Admin Email for Basic Authentication to WordPress REST API
* Format: 24-character string displayed with spaces (e.g., `BMEn ybFR Kjpa SS18 1Tg6 isFb`)
* When entering in QuickBot: spaces are optional - both formats work

***

## Configuration Summary

| Field | Source | Example |
| - | - | - |
| Name | User-defined | My WordPress Account |
| Client ID | miniOrange OAuth Server | gUPBxleDZ... |
| Client Secret | miniOrange OAuth Server | (encrypted) |
| Token Endpoint | OpenID Discovery or miniOrange settings | [https://site.com/wp-json/moserver/token](https://site.com/wp-json/moserver/token) |
| Admin Email | WordPress admin user profile | [admin@yoursite.com](mailto:admin@yoursite.com) |
| Application Password | WordPress Application Passwords | BMEn ybFR Kjpa SS18 1Tg6 isFb |

***

## Advanced Features

### Authentication & Security

* **OAuth 2.0 / OpenID Connect**: Secure API access using industry-standard protocols
* **Encrypted Credentials**: Client secrets and application passwords stored with encryption
* **Token Management**: Automatic token refresh and expiration handling
* **HTTPS Support**: Secure connections to WordPress endpoints
* **Application Passwords**: Separate credentials for API access without exposing main password

### API Capabilities

#### Content Management

* **Post Creation**: Create and publish posts programmatically
* **Post Updates**: Modify existing post content and metadata
* **Custom Fields**: Support for custom post fields and meta data
* **Media Management**: Upload and attach media to posts
* **Taxonomy Support**: Handle categories, tags, and custom taxonomies

#### User Management

* **User Registration**: Create new WordPress user accounts
* **Profile Updates**: Modify user profile information
* **Role Assignment**: Assign and manage user roles
* **Authentication**: Verify user credentials and manage sessions

### Integration Features

* **REST API Access**: Full access to WordPress REST API endpoints
* **Custom Endpoints**: Support for custom REST API routes
* **Webhook Support**: Trigger actions based on WordPress events
* **Variable Integration**: Pass data between QuickBot and WordPress seamlessly

***

## Troubleshooting

### Common Issues

#### Authentication Problems

* **Invalid Client ID**: Verify the client ID is correctly copied from miniOrange
* **Invalid Client Secret**: Ensure the client secret matches the miniOrange settings
* **Token Endpoint Error**: Verify the token endpoint URL is correct
* **Application Password Invalid**: Check that the application password is active and correctly
  copied (24 characters with or without spaces). Verify it hasn't been revoked in the Application
  Passwords table
* **Admin Email Mismatch**: Ensure the Admin Email matches the user who created the Application
  Password
* **SSL Certificate Issues**: Verify SSL certificates are properly configured

#### API Connection Issues

* **Site URL Mismatch**: Ensure the site URL matches your WordPress installation
* **REST API Disabled**: Verify WordPress REST API is enabled
* **Plugin Conflicts**: Test for WordPress plugin conflicts affecting the API
* **Firewall Blocking**: Check for firewall rules blocking API access
* **CORS Issues**: Configure CORS settings if accessing from different domains

#### WordPress Operation Issues

* **Permission Denied**: Verify the user has appropriate WordPress capabilities
* **Post Creation Failed**: Check required fields and post status settings
* **User Registration Blocked**: Verify user registration is enabled in WordPress settings
* **Media Upload Failed**: Check file upload permissions and size limits
* **Invalid Credentials**: Verify admin email and application password are correct and belong to the
  same user account. Check that the password hasn't been revoked

#### Configuration Issues

* **miniOrange Not Configured**: Ensure miniOrange plugin is properly set up
* **Missing Client**: Verify OAuth client exists in miniOrange settings
* **Invalid Token Endpoint**: Check token endpoint URL format and accessibility
* **Expired or Revoked Password**: Check the Application Passwords table in WordPress - if the
  password was revoked or doesn't exist, generate a new one
* **Wrong User Password**: Ensure you're using the Application Password from the same user account
  whose email is configured in Admin Email field

### Debugging Steps

1. **Test OAuth Flow**: Verify OAuth authentication works independently
2. **Check WordPress Logs**: Review WordPress error logs for API errors
3. **Validate Credentials**: Confirm all credentials in miniOrange and WordPress settings
4. **Verify Application Password**:
   * Check the Application Passwords table in **Users > Profile**
   * Ensure the password exists and hasn't been revoked
   * Verify the Admin Email matches the user who owns the Application Password
5. **Test REST API**: Use tools like Postman to test WordPress REST API directly with the Admin
   Email and Application Password
6. **Network Connectivity**: Test network connectivity between QuickBot and WordPress
7. **Plugin Status**: Verify miniOrange plugin is active and up to date

### Error Messages

* **"WordPress API credentials are not properly configured"**: Check all required fields are filled
  correctly. Verify Admin Email and Application Password match the same user
* **"Invalid token endpoint"**: Verify token endpoint URL is accessible and correctly formatted
* **"Authentication failed"**: Check client ID, client secret, admin email, and application
  password. Verify the Application Password hasn't been revoked
* **"Invalid Application Password"**: The password may be incorrect, revoked, or doesn't match the
  Admin Email. Generate a new password or verify the correct pairing
* **"Permission denied"**: Verify user has required WordPress capabilities for the attempted
  operation
* **"WordPress API Error"**: Check WordPress API status and configuration
* **"User already exists"**: Handle duplicate user registration attempts appropriately
* **"REST API disabled"**: Verify WordPress REST API is enabled in WordPress settings

***

## Additional Resources

For more information about WordPress REST API and miniOrange OAuth:

* WordPress REST API Handbook: [https://developer.wordpress.org/rest-api/](https://developer.wordpress.org/rest-api/)
* miniOrange OAuth Documentation: Available in plugin settings
* WordPress Application Passwords:
  [https://make.wordpress.org/core/2020/11/05/application-passwords-integration-guide/](https://make.wordpress.org/core/2020/11/05/application-passwords-integration-guide/)


# Zoho CRM
Source: https://docs.quick.bot/builder/editor/blocks/integrations/zoho-crm

Connect your QuickBot with Zoho CRM to manage leads, contacts, and customer relationships

# Zoho CRM Integration

The Zoho CRM integration allows your QuickBot to automatically create leads, update contacts, and
manage customer data in your Zoho CRM system.

## Setup

### 1. Zoho CRM API Setup

1. Log into your Zoho CRM account
2. Go to **Setup** > **Developer Space** > **APIs**
3. Create a new client application
4. Note your Client ID and Client Secret

### 2. Configure Authentication

1. Add the Zoho CRM block to your flow
2. Enter your Client ID and Client Secret
3. Complete OAuth authentication
4. Select your Zoho CRM organization

## Actions

### Create Lead

Automatically create new leads with:

* Contact information
* Lead source
* Industry and company details
* Custom fields
* Lead status and priority

### Create Contact

Add new contacts to your CRM with:

* Personal information
* Company details
* Communication preferences
* Custom contact fields

### Update Records

Modify existing CRM records:

* Update lead status
* Add notes and activities
* Modify contact information
* Update deal stages

### Search Records

Find existing records by:

* Email address
* Phone number
* Company name
* Custom field values

## Use Cases

* Capture leads from bot conversations
* Qualify prospects automatically
* Update customer information in real-time
* Track interaction history
* Route leads to appropriate sales teams

## Field Mapping

Map bot variables to Zoho CRM fields:

* Standard fields (Name, Email, Phone)
* Custom fields specific to your CRM
* Multi-select and dropdown values
* Date and currency fields

## Troubleshooting

* Verify OAuth permissions are granted
* Check API rate limits
* Ensure required fields are mapped
* Validate data formats (email, phone, date)
* Review Zoho CRM field permissions


# AB Test
Source: https://docs.quick.bot/builder/editor/blocks/logic/ab-test



The AB Test block allows you to split the path in 2 randomly. It's a great way to test the
performance of 2 different paths and optimize your bot's conversion rates.

<Frame>
  <img alt="AB Test block" />
</Frame>

## Configuration Options

### Traffic Split Percentage

* **A Path Percent**: Set the percentage of users (0-100%) who will follow path A
* **B Path Percent**: Remaining users automatically follow path B
* **Variable Support**: The percentage field supports variables for dynamic testing
* **Validation**: Percentage must be between 0 and 100

## Features

### Random Distribution

* Users are randomly assigned to path A or B based on the configured percentage
* Distribution is calculated per user session to ensure consistent experience
* Perfect for A/B testing different conversation flows, messages, or features

### Performance Tracking

* Monitor conversion rates for each path through your analytics
* Compare user engagement between different approaches
* Make data-driven decisions about your bot's flow

## Advanced Features

### Dynamic Percentage Control

Use variables to control the A/B split percentage programmatically:

* Set percentage based on user characteristics
* Adjust split ratios based on time of day or other conditions
* Implement gradual rollouts by changing percentage over time

### Multiple Path Testing

This approach allows you to:

* Test 3 or more different paths simultaneously
* Create nested A/B tests for more granular optimization
* Implement multi-variate testing strategies

## Troubleshooting

### Common Issues

* **Uneven Distribution**: Verify percentage settings add up correctly
* **Variable Conflicts**: Ensure percentage variables contain valid numeric values
* **Path Isolation**: Make sure both paths are completely independent

### Testing Your Setup

* Use preview mode to verify both paths work correctly
* Test with different percentage values to confirm distribution
* Monitor initial results to ensure proper randomization

### Integration Problems

* Check that downstream blocks handle both paths appropriately
* Verify variable scoping doesn't cause conflicts between paths
* Ensure error handling works consistently on both paths


# Bot
Source: https://docs.quick.bot/builder/editor/blocks/logic/bot-link



The bot link logic block allows you to transition into another bot flow, helping keep your flows
modular and enabling reusability across multiple conversation paths.

<Frame>
  <img alt="Bot logic block" />
</Frame>

## Configuration Options

### Bot Selection

* **Target Bot**: Choose which bot to link to from your workspace
* **Current Bot**: Option to link to groups within the same bot
* **Group Selection**: Select specific starting group in the target bot
* **Workspace Scope**: Only bots within the current workspace are available

### Merge Settings

* **Merge Results**: Combine answers from linked bot with current bot's results
* **Variable Inheritance**: Automatic sharing of variable values between bots
* **Session Continuity**: Maintain user session across bot transitions

## Features

### Automatic Variable Sharing

Variables are automatically shared between the current and linked bots:

* **Variable Matching**: Variables with identical names are pre-filled automatically
* **Data Persistence**: User data collected in the first bot is available in the linked bot
* **Bidirectional Transfer**: Changes in linked bot variables can affect the original bot

Example workflow:

1. First bot collects user's name in `Name` variable
2. Link to second bot that displays personalized greeting using `Name`
3. User sees seamless transition with preserved context

### Result Merging

The merge answers feature provides unified data collection:

* **Consolidated Results**: Combine responses from multiple bots into single results table
* **Third-party Integration**: Send unified data to external applications
* **Analytics Enhancement**: Analyze complete user journey across multiple bot flows

## Advanced Features

### Modular Bot Architecture

* **Reusable Components**: Create specialized bots for common functions
* **Flow Organization**: Keep complex conversations manageable
* **Team Collaboration**: Different team members can work on separate bot modules

### Dynamic Bot Linking

* Use conditional logic to link to different bots based on user responses
* Implement multi-bot workflows for complex use cases
* Create fallback bots for error handling or escalation

### Cross-Bot Analytics

* Track user paths across multiple linked bots
* Measure conversion rates across the entire user journey
* Identify bottlenecks in multi-bot workflows

## Troubleshooting

### Common Configuration Issues

* **Bot Not Found**: Ensure target bot exists and is accessible in workspace
* **Missing Groups**: Verify selected group exists in target bot
* **Permission Errors**: Check workspace permissions for linked bot access
* **Circular Links**: Avoid creating infinite loops between bots

### Variable-Related Problems

* **Missing Variables**: Ensure required variables exist in both bots
* **Type Mismatches**: Verify variable data types are compatible
* **Scope Issues**: Check if variables are properly scoped for sharing
* **Overwritten Values**: Monitor for unintended variable overwrites

### Performance Optimization

* **Loading Delays**: Optimize bot loading times for smoother transitions
* **Memory Usage**: Monitor resource consumption with multiple linked bots
* **Cache Management**: Ensure proper caching of linked bot data
* **Network Issues**: Handle connectivity problems gracefully

### Integration Challenges

* **Results Merging**: Verify merge functionality works as expected
* **Third-party APIs**: Ensure external integrations handle merged data correctly
* **Analytics Tracking**: Confirm user journey tracking across linked bots
* **Export Functions**: Test data export with merged results from multiple bots


# Condition
Source: https://docs.quick.bot/builder/editor/blocks/logic/condition



The Condition block allows you to split your conversation flow into two paths based on logical conditions, enabling dynamic and personalized bot experiences.

<Frame>
  <img alt="Condition" />
</Frame>

## Configuration Options

### Comparison Setup

* **Variable Selection**: Choose which bot variable to evaluate
* **Operator Selection**: Select from 12 different comparison operators
* **Value Input**: Specify the comparison value (supports variables)
* **Multiple Conditions**: Add multiple comparisons with logical operators

### Logical Operators

* **AND**: All comparisons must be true for the condition to pass
* **OR**: At least one comparison must be true for the condition to pass
* **Mixed Logic**: Combine multiple comparisons with consistent logical operators
* **Evaluation Order**: Comparisons are evaluated in the order they appear

## Features

### Comprehensive Comparison Operators

The condition block supports 12 different comparison types for maximum flexibility:

#### Text Comparisons

* **Equal to**: Exact string matching (case-sensitive)
* **Not equal**: Inverse of equal comparison
* **Contains**: Checks if variable contains the specified value
* **Does not contain**: Inverse of contains comparison
* **Starts with**: Checks if variable begins with specified value
* **Ends with**: Checks if variable ends with specified value

#### Numeric Comparisons

* **Greater than**: Numeric comparison (greater than or equal to)
* **Less than**: Numeric comparison (less than or equal to)

#### Existence Checks

* **Is set**: Checks if variable has any value (not null, undefined, or empty string)
* **Is empty**: Checks if variable is null, undefined, or empty string

#### Pattern Matching

* **Matches regex**: Advanced pattern matching using regular expressions
* **Does not match regex**: Inverse of regex pattern matching

### Advanced Variable Support

* **Dynamic Values**: Use variables in both sides of comparisons
* **Type Flexibility**: Handles strings, numbers, arrays, and boolean values
* **Nested Conditions**: Complex logical structures with multiple variables
* **Real-time Evaluation**: Conditions are evaluated dynamically during conversation

<YoutubeVideo />

## Operators

<ResponseField name="Equal to">
  Will match if the provided value is strictly equal to the value.
</ResponseField>

<ResponseField name="Not equal">
  Will match if the provided value is not equal to the value.
</ResponseField>

<ResponseField name="Contains">
  Will match if the provided value contains the value. If a list is provided, it will match if the
  list has at least one element in common with the value.
</ResponseField>

<ResponseField name="Does not contain">
  Same as `Contains` but will match the inverse.
</ResponseField>

<ResponseField name="Greater than">
  Will match if the provided value is greater or equal than the value.
</ResponseField>

<ResponseField name="Less than">
  Will match if the provided value is less or equal than the value.
</ResponseField>

<ResponseField name="Is set">
  Will match if the provided value is not null or undefined and not an empty string.
</ResponseField>

<ResponseField name="Is empty">
  Will match if the provided value is null, undefined, or an empty string.
</ResponseField>

<ResponseField name="Starts with">
  Will match if the provided value starts with the value.
</ResponseField>

<ResponseField name="Ends with">
  Will match if the provided value ends with the value.
</ResponseField>

<ResponseField name="Matches regex">
  Value should start and end with `/` and contain a valid regex pattern.

  Example:

  * `/^hello$/` will match if the string is strictly equal to "hello".
  * `/hello/` will match if the string contains "hello". Like "hello world".
  * `/hello/i` will match if the string contains "hello" case-insensitive. Like "Hello world".
  * `/[0-9]+/` will match if the string contains one or more digits. Like "123".
</ResponseField>

<ResponseField name="Does not match regex">
  Same as `Matches regex` but will match if the provided value does not match the regex pattern.
</ResponseField>

## Advanced Features

### Complex Logical Structures

Build sophisticated decision trees with multiple conditions:

```
Example: User Qualification Logic
Condition 1: Score > 80 AND Category = "Premium"
Condition 2: Experience > 5 OR Referral = "Yes"
Combined: (Score > 80 AND Category = "Premium") OR (Experience > 5 OR Referral = "Yes")
```

### Dynamic Condition Values

Use variables in comparison values for maximum flexibility:

```
Dynamic Pricing Example:
- Variable: {{Current Price}}
- Operator: Greater than
- Value: {{Minimum Price Threshold}}

User Segmentation Example:
- Variable: {{User Type}}
- Operator: Contains
- Value: {{Target Segment}}
```

### Array and List Handling

Handle complex data structures with contains operations:

* **Array Variables**: Check if arrays contain specific values
* **Comma-separated Lists**: Search within concatenated strings
* **Multiple Values**: Use contains to match any item in a list

### Regular Expression Power

Advanced pattern matching for complex validation:

```
Email Validation: /^[^\s@]+@[^\s@]+\.[^\s@]+$/
Phone Numbers: /^\+?[\d\s\-\(\)]{10,}$/
Custom Formats: /^[A-Z]{2}\d{4}$/
Case Insensitive: /hello/i
```

## Example Use Cases

### User Segmentation

```
Condition: Premium User Check
- Variable: {{Subscription Type}}
- Operator: Equal to
- Value: "premium"

Result: Route premium users to exclusive content
```

### Dynamic Pricing

```
Condition: Bulk Discount Eligibility
- Variable: {{Order Quantity}}
- Operator: Greater than  
- Value: 10

Result: Apply bulk pricing for large orders
```

### Content Personalization

```
Multiple Conditions with AND logic:
1. {{User Region}} equals "North America"
2. {{User Language}} equals "English"
3. {{User Age}} greater than 18

Result: Show region and age-appropriate content
```

### Form Validation

```
Email Format Validation:
- Variable: {{Email Address}}
- Operator: Matches regex
- Value: /^[^\s@]+@[^\s@]+\.[^\s@]+$/

Result: Proceed only with valid email addresses
```

## Troubleshooting

### Common Logic Errors

* **Case Sensitivity**: "Premium" ≠ "premium" - use exact case matching
* **Type Mismatches**: Comparing strings with numbers may not work as expected
* **Empty Variables**: Undefined variables may cause unexpected behavior
* **Operator Confusion**: "Greater than" includes equality, use appropriate operators

### Variable-Related Issues

* **Undefined Variables**: Check that variables exist before comparison
* **Array Handling**: Use "Contains" operator for array values, not "Equal to"
* **Dynamic Values**: Ensure comparison value variables contain expected data
* **Scope Problems**: Variables may not be available in all conversation contexts

### Regex Troubleshooting

* **Syntax Errors**: Validate regex patterns before deployment
* **Escape Characters**: Properly escape special characters in patterns
* **Performance**: Complex regex can slow down condition evaluation
* **Testing**: Use regex testing tools to verify patterns work as expected

### Flow Logic Problems

* **Dead Ends**: Ensure both condition paths lead to meaningful destinations
* **Infinite Loops**: Avoid conditions that could create circular flows
* **Path Coverage**: Test all possible condition outcomes
* **Default Handling**: Provide fallback behavior for edge cases

### Platform-Specific Considerations

* **Mobile Compatibility**: Test conditions across different devices
* **Browser Differences**: Some regex patterns may behave differently
* **Network Issues**: Handle cases where variable updates may be delayed
* **Internationalization**: Consider locale-specific formatting in comparisons


# Jump
Source: https://docs.quick.bot/builder/editor/blocks/logic/jump



The jump block allows you to jump directly to a specific block or group in your bot flow. This is
essential for creating clean, organized flows and implementing advanced navigation patterns.

<Frame>
  <img alt="Jump block" />
</Frame>

## Configuration Options

### Target Selection

* **Group Selection**: Choose which group to jump to from available groups in your bot
* **Block Selection**: Optionally select a specific block within the target group
* **Current Group Exclusion**: Cannot jump to the same group where the jump block is located
* **Visual Indicators**: Block icons help identify target block types

### Navigation Behavior

* **Direct Jump**: Instantly moves conversation to the specified location
* **Session Continuity**: Maintains all variables and conversation state
* **Clean Flow**: Helps organize complex conversation logic without visual clutter

## Features

### Smart Group Filtering

* **Available Groups**: Only shows groups with titles (excluding empty or unnamed groups)
* **Current Group Exclusion**: Prevents infinite loops by excluding the current group
* **Title-Based Selection**: Groups are identified by their titles for easy navigation

### Precise Block Targeting

* **Block-Level Precision**: Jump to specific blocks within a group, not just the beginning
* **Visual Block Identification**: Block icons and numbers help identify the target
* **Optional Targeting**: If no specific block is selected, jumps to the first block in the group

### Flow Organization Benefits

* **Reduced Visual Complexity**: Eliminate long connecting lines across your flow canvas
* **Modular Design**: Create reusable sections that can be accessed from multiple points
* **Loop Creation**: Build loops and iterative flows efficiently

## Advanced Features

### Complex Flow Patterns

* **Multi-Path Convergence**: Have multiple paths jump to the same target
* **Loop Implementation**: Create repeating sections using jump blocks
* **Conditional Jumping**: Combine with condition blocks for dynamic navigation
* **Error Handling**: Jump to error handling sections when needed

### Flow Architecture

* **Hierarchical Organization**: Structure complex bots with clear navigation
* **Reusable Sections**: Create utility sections accessible from anywhere
* **Performance Optimization**: Reduce canvas size and improve editor performance

### Advanced Navigation Strategies

* **Menu Systems**: Create navigation menus that jump to different sections
* **Back Navigation**: Implement back button functionality
* **Skip Logic**: Allow users to skip optional sections
* **Progressive Flows**: Build sequential flows with jump-based progression

## Troubleshooting

### Common Configuration Issues

* **Missing Target Groups**: Ensure target groups exist and have proper titles
* **Empty Group Selection**: Verify target groups contain blocks to jump to
* **Self-Reference Attempts**: Cannot jump to the same group as the jump block
* **Block Not Found**: Ensure specified target blocks still exist in target groups

### Flow Navigation Problems

* **Infinite Loops**: Avoid creating circular jump patterns
* **Dead Ends**: Ensure jumped-to sections have proper continuation paths
* **Variable Scope**: Verify variables are accessible in jumped-to sections
* **User Confusion**: Jumps should feel natural, not disorienting

### Performance Issues

* **Complex Jump Chains**: Avoid excessive chaining of jump blocks
* **Large Group Targets**: Be cautious when jumping to very large groups
* **Memory Leaks**: Monitor for memory issues with frequently used jumps
* **Editor Performance**: Too many jumps can slow down the visual editor

### Integration Challenges

* **Analytics Tracking**: Ensure user path analytics account for jumps
* **Third-party Integrations**: Verify external systems handle non-linear flows
* **Export Functions**: Confirm flow exports maintain jump relationships
* **Version Control**: Track changes to jump targets across bot versions


# Redirect
Source: https://docs.quick.bot/builder/editor/blocks/logic/redirect



The Redirect logic block allows you to redirect users to external URLs either in the current tab or
a new tab, enabling seamless integration with external services and websites.

<Warning>
  Safari and iOS devices will block a redirect in a new tab by default so a popup will be displayed
  to the user. Make sure to test your redirect logic block on these devices.
</Warning>

<Frame>
  <img alt="Redirect logic block" />
</Frame>

## Configuration Options

### URL Settings

* **Target URL**: Specify the destination URL for redirection
* **Variable Support**: Use variables to create dynamic URLs based on user data
* **Validation**: Ensures proper URL formatting for successful redirection
* **Protocol Handling**: Automatically handles HTTP/HTTPS protocols

### Navigation Behavior

* **Current Tab**: Redirects in the same browser tab (default behavior)
* **New Tab**: Opens the URL in a new browser tab or window
* **Cross-Platform Support**: Works across web, mobile web, and embedded environments

## Features

### Dynamic URL Construction

Build personalized redirect URLs using variables:

* **User Data Integration**: Include user information in URLs (e.g.,
  `https://example.com/user/{{User ID}}`)
* **Parameter Passing**: Pass form responses as URL parameters
* **External System Integration**: Direct users to external dashboards with context

### Flexible Navigation Options

* **Same Tab Redirect**: Seamless transition for completing workflows
* **New Tab Opening**: Keep the conversation open while accessing external resources
* **Context Preservation**: Maintain bot session when opening in new tabs

### Cross-Platform Compatibility

* **Web Browsers**: Full support across all modern browsers
* **Mobile Devices**: Optimized for mobile web experiences
* **Embedded Environments**: Works within iframe and embedded implementations

## Advanced Features

### Conditional Redirecting

* **Variable-Based Logic**: Redirect to different URLs based on user responses
* **A/B Testing**: Use with A/B test blocks to redirect users to different landing pages
* **Personalization**: Create personalized redirect experiences based on user data

### External System Integration

* **CRM Integration**: Direct users to personalized CRM portals
* **Payment Processing**: Redirect to payment gateways with pre-filled information
* **Third-party Dashboards**: Link to external analytics or reporting tools
* **Document Systems**: Direct to specific documents or resources

### Analytics and Tracking

* **UTM Parameter Support**: Add tracking parameters for analytics
* **Campaign Tracking**: Monitor redirect performance and user behavior
* **Conversion Tracking**: Measure success rates of redirect-based flows

## Troubleshooting

### Common Redirect Issues

* **Invalid URLs**: Ensure URLs are properly formatted with protocols
* **Variable Errors**: Check that variables contain valid URL components
* **Encoding Problems**: Properly encode special characters in URLs
* **Protocol Mismatches**: Verify HTTP/HTTPS protocol consistency

### Browser-Specific Problems

* **Popup Blockers**: New tab redirects may be blocked by popup blockers
* **Safari Limitations**: iOS Safari has strict popup blocking policies
* **CORS Issues**: Some embedded environments may restrict redirects
* **Mobile Browsers**: Different behavior between mobile and desktop browsers

### Platform-Specific Challenges

* **Mobile Apps**: Redirects may behave differently in WebView components
* **Iframe Restrictions**: Some sites prevent iframe-based redirects
* **Third-party Blockers**: Ad blockers or privacy tools may interfere
* **Network Firewalls**: Corporate networks may block certain redirects

### Integration Problems

* **External System Failures**: Handle cases where target sites are unavailable
* **Authentication Issues**: Manage expired or invalid authentication tokens
* **Parameter Handling**: Ensure external systems properly receive passed parameters
* **Session Management**: Maintain proper session state across redirects


# Script
Source: https://docs.quick.bot/builder/editor/blocks/logic/script



The Script block allows you to execute custom JavaScript code within your bot flow, enabling
advanced logic, external API calls, and browser interactions.

<Info>This block doesn't allow you to create a custom visual block</Info>

<Frame>
  <img alt="Code block" />
</Frame>

## Configuration Options

### Script Name

* **Name Field**: Optional identifier for organizing and debugging scripts (default: "Script")
* **Purpose**: Helps identify scripts in flow diagrams and logs

### Code Editor

* **Full JavaScript Editor**: Syntax highlighting and multi-line support
* **Variable Integration**: Direct access to bot variables using `{{Variable Name}}` syntax
* **Variable Button**: Insert variables directly into your code

### Execution Environment

<Warning>
  The "Execute on Client" toggle is a beta feature and only available in beta environments.
</Warning>

Choose where your script executes:

* **Client-side (Default)**: Code runs in the user's browser

  * Full access to browser APIs (`window`, `document`, `navigator`, etc.)
  * No access to `setVariable()` function
  * Depends on user's browser capabilities
  * Good for DOM manipulation, browser APIs, and client-side features

* **Server-side**: Code runs in a secure, isolated environment
  * Access to `setVariable()` function for modifying bot variables
  * Custom `fetch()` API for external HTTP requests
  * No access to browser APIs
  * Better for security-sensitive operations and API integrations

<Info>
  Variables in script are not parsed, they are evaluated. So it should be treated as if it were real javascript variables.

  You need to write `console.log({{My variable}})` instead of `console.log("{{My variable}}")`
</Info>

## Features

### Variable Management (Server-side Only)

<Warning>
  The `setVariable()` function is **ONLY available in server-side execution**. It will not work when
  the script runs on the client (default behavior).
</Warning>

Use the `setVariable()` function to modify bot variables programmatically when running server-side:

```js theme={null}
// This only works when "Execute on Client" is disabled (server-side)
if({{My variable}} === 'foo') {
  setVariable('My variable', 'bar')
} else {
  setVariable('My variable', 'other')
}
```

**How it works:**

* First parameter: Variable name (as a string, exactly as it appears in your bot)
* Second parameter: The new value to set
* The variable must already exist in your bot

### API Integration (Server-side)

<Info>
  Server-side scripts have access to a custom `fetch()` function. Client-side scripts can use the
  standard browser `fetch()` API.
</Info>

Make HTTP requests to external services:

**Server-side fetch:**

```js theme={null}
// Server-side fetch returns response body as a string directly
const data = await fetch('https://api.example.com/data')
const parsed = JSON.parse(data) // Parse JSON manually

// Set results in variables
setVariable('API Response', parsed.result)
```

**Client-side fetch:**

```js theme={null}
// Standard browser fetch API (default execution)
const response = await fetch('https://api.example.com/data')
const data = await response.json() // Standard response methods available

// Note: setVariable() is NOT available client-side
console.log(data.result)
```

### Conditional Logic

Implement complex business logic that's difficult to achieve with standard blocks:

```js theme={null}
// Complex conditional logic
const score = parseInt({{User Score}})
const category = {{User Category}}

if (score > 80 && category === 'premium') {
  setVariable('Qualification', 'gold')
  setVariable('Discount', 25)
} else if (score > 60) {
  setVariable('Qualification', 'silver')
  setVariable('Discount', 15)
} else {
  setVariable('Qualification', 'bronze')
  setVariable('Discount', 5)
}
```

## Advanced Features

### External API Calls

Integrate with third-party services and APIs:

```js theme={null}
// CRM integration example
const customerData = {
  name: {{Customer Name}},
  email: {{Customer Email}},
  score: {{Lead Score}}
}

const response = await fetch('https://api.crm.com/leads', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  body: JSON.stringify(customerData)
})

const result = JSON.parse(response)
setVariable('CRM Lead ID', result.id)
```

### Data Processing

Process and transform user data:

```js theme={null}
// Process array data
const responses = {{Survey Responses}} || []
const processed = responses
  .filter(item => item.length > 0)
  .map(item => item.toUpperCase())
  .join(', ')

setVariable('Processed Responses', processed)
```

### Browser Interactions (Client-side Only)

Access browser APIs when running on the client (default execution):

```js theme={null}
// Get user's screen dimensions
const screenInfo = `${window.innerWidth}x${window.innerHeight}`
console.log('Screen size:', screenInfo)

// Detect dark mode preference
const isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches
console.log('Dark mode:', isDarkMode)

// Access user's timezone
const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
console.log('Timezone:', timezone)

// Redirect to another page
if ({{User Status}} === 'premium') {
  window.location.href = 'https://example.com/premium'
}
```

<Warning>
  Client-side scripts cannot use `setVariable()`. To store values from client-side scripts, you'll
  need to use other methods like displaying the value in a message or using browser storage APIs.
</Warning>

## Server-side Limitations

Because server scripts run in an isolated, secure environment:

### Unavailable APIs

* **Console Functions**: `console.log`, `setTimeout`, `setInterval` not available
* **Browser APIs**: No access to `window`, `document`, `localStorage`, etc.
* **Node.js Modules**: Cannot use `import` or `require` statements
* **Global Objects**: Limited global scope compared to browser environment

### Modified Fetch Behavior

The `fetch` function works differently on the server:

```js theme={null}
// ❌ Standard fetch pattern doesn't work
const response = await fetch('https://api.example.com/data')
const data = await response.json() // This will fail

// ✅ Simplified server-side fetch
const data = await fetch('https://api.example.com/data')
const parsed = JSON.parse(data) // Parse manually if JSON
```

Response is always returned as a string, even for JSON responses.

## Example Use Cases

### CRM Integration (Server-side)

```js theme={null}
// Server-side script - requires beta environment toggle
// Update CRM with form data
const leadData = {
  name: {{Full Name}},
  email: {{Email}},
  phone: {{Phone Number}},
  source: 'chatbot'
}

const response = await fetch('https://api.yourcrm.com/leads', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(leadData)
})

const result = JSON.parse(response)
setVariable('CRM Updated', result.success)
```

### Dynamic Pricing (Server-side)

```js theme={null}
// Server-side script - requires beta environment toggle
// Calculate dynamic pricing
const basePrice = 100
const userType = {{User Type}}
const volume = parseInt({{Order Volume}}) || 1

let discount = 0
if (userType === 'premium') discount = 0.2
else if (userType === 'standard') discount = 0.1

if (volume > 10) discount += 0.05

const finalPrice = basePrice * volume * (1 - discount)
setVariable('Final Price', finalPrice.toFixed(2))
```

### Browser Page Control (Client-side)

```js theme={null}
// Client-side script (default execution)
// Redirect based on conditions
if({{Category}} === 'qualified') {
  window.location.href = 'https://my-site.com/qualified'
} else {
  window.location.href = 'https://my-site.com/info'
}
```

## Troubleshooting

### Common Script Errors

* **Variable Access**: Ensure variables exist and contain expected data types
* **Syntax Errors**: Check JavaScript syntax and bracket matching
* **Async Issues**: Use await with Promise-based operations
* **Type Errors**: Validate variable types before processing

### Server-side Issues

* **Fetch Errors**: Remember server-side fetch returns strings directly
* **Missing Functions**: Global browser functions aren't available
* **API Timeouts**: Implement proper error handling for external calls
* **Memory Limits**: Keep scripts efficient to avoid timeout issues

### Client-side Issues

* **Browser Compatibility**: Test across different browsers and devices
* **Security Restrictions**: Some browsers block certain operations
* **Network Issues**: Handle offline scenarios gracefully
* **Mobile Limitations**: Consider mobile browser capabilities

### Performance Problems

* **Slow Execution**: Optimize loops and reduce API calls
* **Memory Usage**: Clean up variables and avoid memory leaks
* **Network Delays**: Implement reasonable timeouts for external calls
* **Error Recovery**: Provide fallbacks when scripts fail


# Variable
Source: https://docs.quick.bot/builder/editor/blocks/logic/variable



The Variable block allows you to create, modify, and manage variables throughout your bot
conversation, enabling dynamic content and sophisticated data handling.

<Frame>
  <img alt="Variable" />
</Frame>

## Configuration Options

### Variable Selection

The first step is to select which variable you want to work with:

* **Variable Dropdown**: Choose from existing variables in your bot or create a new one
* **Automatic Creation**: New variables are created on-the-fly if they don't exist
* **System Variables Hidden**: System variables (like `{{system_now}}`) are not shown in the
  dropdown for this block

### Operation Type

Choose the operation you want to perform on the variable:

* **Set**: Assign a value using text or JavaScript expressions
* **Empty**: Reset the variable to an undefined state
* **Append value(s)**: Add values to arrays (automatically converts to array if needed)
* **Pop**: Remove and optionally store the last item from an array
* **Shift**: Remove and optionally store the first item from an array
* **Map item with same index**: Cross-reference between two related arrays

### Operation-Specific Configuration

Depending on the selected operation type, additional configuration options appear:

#### For "Set" Operation:

* **Text/Code Mode Toggle**: Switch between simple text input and full JavaScript editor
* **Value Input**: Enter the value or expression to assign to the variable

#### For "Pop" and "Shift" Operations:

* **Store Item Variable**: Optional dropdown to select where to store the removed item

#### For "Append value(s)" Operation:

* **Value to Append**: Text input supporting variables to append to the array

#### For "Map item with same index" Operation:

* **Base Item Variable**: The item you're searching for
* **Base List Variable**: The array containing the base item
* **Target List Variable**: The array to retrieve the corresponding value from

#### For "Empty" Operation:

* No additional configuration needed

## Set

You can set your variable with any value with `Set`. It can be any kind of plain text (**Text**
mode) but also **Javascript code** (**Code** mode). Text is text: it is never evaluated. To compute
a value, switch the block to Code mode.

### Expressions with existing variables (Code mode)

In Code mode you can apply operations on existing variables.

Add a value to your variable:

```
{{Score}} + 5
```

Compute a sum of variables:

```
{{Score}} + {{Answer}}
```

Multiply variables together:

```
{{Score}} * {{Multiplier}}
```

Compute a percentage:

```
{{Score}} * 100 / {{Max Score}}
```

Extract the first name from a full name:

```
{{Full name}}.split(' ')[0]
```

Transform existing variable to upper case or lower case:

```
{{Name}}.toUpperCase()
```

```
{{Name}}.toLowerCase()
```

This can also be Javascript code. It will read the returned value of the code and set it to your
variable.

```js theme={null}
const name = 'John' + 'Doe'
return name
```

If you don't provide the `return` keyword then it will be automatically prepended to the beginning
of your code.

```js theme={null}
'John' + 'Doe'
```

is the same as

```js theme={null}
return 'John' + 'Doe'
```

### Text vs Code Mode

When using the **Set** operation, you can choose between two input modes using the toggle buttons:

#### Text Mode

* **Simple text input** with variable interpolation
* The text is stored exactly as written, with each `{{variable}}` replaced by its value
* **Never evaluated**: dates, prices, coordinates or `{{Score}} + 5` stay as plain text
* Ideal for concatenation, labels and URLs

**Example:**

```
{{First Name}} {{Last Name}}
https://my-site.com/{{Slug}}
```

If a text looks like a formula, the editor suggests switching the block to Code mode.

#### Code Mode

* **Full JavaScript editor** with syntax highlighting
* Required for any calculation, even a simple `{{Score}} + 5`
* Access to the complete JavaScript expression engine
* Supports advanced operations like loops, conditionals, and array methods
* If the code fails, the variable is left empty and the error is shown in the preview and in the
  conversation logs of the inbox

**Example:**

```js theme={null}
const total = {{Price}} * {{Quantity}}
const discount = {{User Type}} === 'premium' ? 0.15 : 0.05
return total * (1 - discount)
```

<Info>
  Variables in code are not parsed, they are evaluated. So it should be treated as if it were real Javascript variables.

  So, if you write `"{{My variable}}"`, the quotes turn the reference into a plain string (its
  internal alias, something like `$My_variable`), not its value. Remove the quotes to get the variable
  content; the editor flags quoted references for you.

  For example,

  * ❌ `"{{URL base}}/path"` => `$URL_base/path`
  * ✅ `{{URL base}} + '/path'` => `https://my-site.com/path`
  * ✅ `` `${{{URL base}}}/path` `` => `https://my-site.com/path`

  A variable that does not exist evaluates to `undefined` (so `({{Missing}} || []).length` is `0`).
</Info>

<Info>
  Variables content can either be a string or a list of strings. Check out [Valid value
  types](../../variables#valid-value-types) for more information.
</Info>

## Empty

Resets your variable as if it was never initialized.

## Append value(s)

A conveniant value that automatically transform your variable into a list of strings. It will append
the value(s) to the list.

3 possible cases here:

* If the variable is empty, it will create a new array with the provided value(s)
* If the variable is not an array, it will create a new array with the existing value followed by
  the provided value(s).
* If the variable is an array, it will concatenate the provided value(s) to the existing array.

This is useful to provide context to an AI block or to send it as a recap with the
[Email](../integrations/email) block.

<YoutubeVideo />

## Pop

Remove and store the **last item** from an array. This operation:

* Removes the last element from the array stored in the selected variable
* Optionally stores the removed item in another variable for later use
* If the variable is not an array, it returns the value as-is

**Configuration:**

* Select a variable to store the removed item (optional)

**Example:**

```
Variable: {{Responses}} = ["First", "Second", "Third"]
After Pop → {{Responses}} = ["First", "Second"]
Removed item: "Third"
```

## Shift

Remove and store the **first item** from an array. This operation:

* Removes the first element from the array stored in the selected variable
* Optionally stores the removed item in another variable for later use
* If the variable is not an array, it returns the value as-is

**Configuration:**

* Select a variable to store the removed item (optional)

**Example:**

```
Variable: {{Queue}} = ["First", "Second", "Third"]
After Shift → {{Queue}} = ["Second", "Third"]
Removed item: "First"
```

## Map item with same index

This operation allows you to cross-reference between two related arrays by finding an item in one
array and retrieving the corresponding item at the same index from another array.

**Use Case:** When pulling data from external services, you often have two related lists - one with
human-readable labels displayed to users, and another with IDs used for API requests.

**Configuration:** The block requires three variable selections:

1. **Base Item Variable**: The specific item you're looking for (e.g., selected label)
2. **Base List Variable**: The array containing the base item (e.g., array of labels)
3. **Target List Variable**: The array to retrieve the corresponding item from (e.g., array of IDs)

**How it works:**

1. Find the index of the base item in the base list
2. Return the item at that same index from the target list

**Example:**

```
Labels = ["Basic Plan", "Pro Plan", "Enterprise"]
IDs = ["plan_001", "plan_002", "plan_003"]
Selected Label = "Pro Plan"

Result: "plan_002" (item at index 1 in both arrays)
```

## Advanced Features

### JavaScript Expression Engine

The Custom value type provides a full JavaScript expression engine:

```js theme={null}
// Mathematical calculations
{{Price}} * {{Quantity}} * (1 - {{Discount}} / 100)

// String manipulation
{{First Name}}.toUpperCase() + ' ' + {{Last Name}}.toLowerCase()

// Conditional expressions
{{Score}} > 80 ? 'Pass' : 'Fail'

// Date calculations
new Date({{Birthday}}).getFullYear()

// Array operations
[{{Answer1}}, {{Answer2}}, {{Answer3}}].filter(a => a.length > 0)
```

### Dynamic Array Management

Sophisticated array handling for complex data structures:

```js theme={null}
// Create arrays from user responses
Append Values: {{New Response}}
// Result: ["Response1", "Response2", "Response3"]

// Process survey responses
Pop from {{Responses}} → stores last response in new variable
Shift from {{Responses}} → stores first response in new variable

// Cross-reference arrays
Map Item: Find item in {{IDs}} at same index as {{Selection}} in {{Labels}}
```

### Context-Aware Variable Setting

Smart variable management based on conversation context:

* **Session Variables**: Temporary data that expires with the conversation
* **Persistent Variables**: Data saved to results table for long-term storage
* **Linked Variables**: Variables connected to user blocks for automatic updates
* **Computed Variables**: Variables that depend on other variables and update automatically

## Example Use Cases

### E-commerce Cart Management

```js theme={null}
// Calculate total price with tax and discount
const subtotal = {{Cart Items}}.reduce((sum, item) => sum + (item.price * item.quantity), 0)
const discount = {{User Type}} === 'premium' ? 0.15 : 0.05
const tax = subtotal * 0.08
return (subtotal * (1 - discount) + tax).toFixed(2)
```

### User Personalization

```js theme={null}
// Set personalized greeting based on time and user data
const hour = new Date().getHours()
const name = {{User Name}} || 'there'
const timeOfDay = hour < 12 ? 'morning' : hour < 17 ? 'afternoon' : 'evening'
return `Good ${timeOfDay}, ${name}!`
```

### Survey Response Processing

```js theme={null}
// Calculate satisfaction score from multiple responses
const responses = [{{Q1 Rating}}, {{Q2 Rating}}, {{Q3 Rating}}]
const validResponses = responses.filter(r => r !== null && r !== undefined)
const average = validResponses.reduce((sum, r) => sum + parseInt(r), 0) / validResponses.length
return Math.round(average * 10) / 10 // Round to 1 decimal
```

### Dynamic Content Selection

```js theme={null}
// Select content based on user profile
const segments = {
  'new': 'Welcome! Here\'s what you need to know...',
  'returning': 'Welcome back! Here\'s what\'s new...',
  'premium': 'Welcome to your premium experience...'
}
return segments[{{User Segment}}] || segments['new']
```

## Troubleshooting

### Common Variable Issues

* **Undefined Variables**: Check that variables are created before use
* **Type Conflicts**: Ensure consistent data types (string vs number vs array)
* **Scope Problems**: Verify variables are accessible in their usage context
* **Naming Conflicts**: Avoid duplicate variable names that could cause confusion

### JavaScript Expression Errors

* **Syntax Errors**: Validate JavaScript syntax before deployment
* **Variable References**: Use `{{Variable Name}}` syntax correctly
* **Return Statements**: Remember that expressions auto-prepend `return` if not present
* **Null Handling**: Check for null/undefined values before operations

### Array Operation Problems

* **Empty Arrays**: Handle cases where arrays might be empty
* **Index Errors**: Verify array indices exist before accessing
* **Type Mixing**: Ensure array elements are compatible types
* **Memory Usage**: Be mindful of large arrays in browser memory

### Integration Challenges

* **External APIs**: Handle API failures and timeout scenarios gracefully
* **Data Format**: Ensure data formats match expected patterns
* **Session Management**: Handle session expiration and variable persistence
* **Cross-platform**: Test variable behavior across web and WhatsApp environments


# Wait
Source: https://docs.quick.bot/builder/editor/blocks/logic/wait



The Wait block allows you to pause the conversation for a specified duration, creating natural
conversation rhythm and controlling message timing.

This is useful for emphasizing important messages, creating dramatic pauses, or ensuring users have
time to read content before proceeding to the next step.

<Info>
  This should be used wisely. For general typing speed adjustments, use the [Typing emulation
  settings](/builder/settings/general#typing-emulation) instead.
</Info>

## Configuration Options

### Timing Control

* **Seconds to Wait**: Specify the exact number of seconds to pause
* **Variable Support**: Use variables to create dynamic wait times based on conditions
* **Flexible Duration**: Accept decimal values for precise timing control
* **Real-time Preview**: See the effect immediately during bot testing

### Settings

* **Pause the Flow**: Control whether to interrupt the natural block processing flow
* **Processing Control**: Decide when long-running actions should be preceded by messages
* **User Experience**: Balance between natural conversation flow and technical requirements

## Features

### Natural Conversation Pacing

* **Message Emphasis**: Add pauses after important announcements
* **Reading Time**: Give users adequate time to process complex information
* **Dramatic Effect**: Create suspense or emphasis in conversation flow
* **Rhythm Control**: Maintain natural conversation timing

### Dynamic Wait Times

Use variables to create contextual wait times:

* **User-based Timing**: Adjust pauses based on user preferences
* **Content-based Delays**: Longer waits for complex information
* **Conditional Pauses**: Different timing based on conversation state

### Flow Management

* **Processing Control**: Manage when messages appear relative to background processes
* **Synchronization**: Coordinate timing with external system responses
* **User Experience**: Prevent overwhelming users with rapid-fire messages

## Advanced Features

### Contextual Timing

```
Short message: 1-2 seconds
Medium message: 3-4 seconds
Long content: 5+ seconds
Variable timing: {{Wait Time}} seconds
```

### Flow Interruption Control

The "Pause the flow" option provides granular control:

* **Standard Flow**: Bot processes all blocks between inputs continuously
* **Paused Flow**: Forces a break to display messages before continuing
* **Long-running Actions**: Show status messages before time-consuming operations

### Integration with Other Blocks

* **Pre-redirect Pauses**: Ensure users read final messages before redirects
* **API Call Delays**: Show loading messages before external API calls
* **Form Submission**: Pause before processing to show confirmation messages
* **Error Handling**: Controlled timing for error message sequences

### Variable-Based Timing

Create intelligent wait systems:

```
Wait Time Calculation:
- Simple message: {{Base Wait Time}}
- Complex message: {{Base Wait Time}} * 2
- User preference: {{User Reading Speed}}
- Content length: {{Message Length}} / 10
```

## Example Use Cases

### Information Emphasis

```
Bot: "Your order has been confirmed! 🎉"
Wait: 2 seconds
Bot: "You'll receive a confirmation email shortly."
```

### Pre-redirect Timing

```
Bot: "Thanks for completing our survey!"
Wait: 3 seconds
Bot: "Redirecting you to our special offers page..."
Wait: 2 seconds
Redirect: to offers page
```

### Processing Notifications

```
Bot: "Processing your request..."
Wait: 2 seconds (with pause flow enabled)
Script: Perform API call
Bot: "Processing complete! Here are your results:"
```

### Dramatic Conversation Flow

```
Bot: "The results are in..."
Wait: 3 seconds
Bot: "You scored 95%! Congratulations! 🎉"
```

## Troubleshooting

### Common Timing Issues

* **Too Short**: Users miss important information due to insufficient reading time
* **Too Long**: Users lose engagement or think the bot is broken
* **Inconsistent**: Varying wait times without clear reasoning confuse users
* **Context Mismatch**: Formal timing in casual conversations (or vice versa)

### Variable-Related Problems

* **Invalid Values**: Variables containing non-numeric values cause errors
* **Negative Numbers**: Negative wait times default to zero seconds
* **Decimal Precision**: Very precise decimals may not work as expected
* **Empty Variables**: Undefined variables may cause unexpected behavior

### Flow Control Issues

* **Pause Timing**: Incorrect pause flow settings affect message sequencing
* **Block Processing**: Long-running actions may not respect pause settings
* **Session Timeouts**: Very long waits may cause session expiration
* **User Abandonment**: Extended pauses may cause users to leave conversation

### Platform-Specific Challenges

* **Mobile Switching**: Users switching apps during waits may miss subsequent messages
* **Network Issues**: Slow connections may compound wait time effects
* **Browser Behavior**: Different browsers may handle timing differently
* **Embedded Environments**: Wait behavior may vary in iframe or embedded contexts


# Buttons
Source: https://docs.quick.bot/builder/editor/blocks/user/buttons



The Buttons user block allows you to offer your user predefined choices, either single choice
options or multiple choices. It's one of the most versatile user blocks, supporting static items,
dynamic content, and various configuration options.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Buttons input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Buttons input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Submit Button**: Customize the text shown on the submit button (only for multiple choice)
* **Save Answer**: Choose a variable to store the user's selection(s)

### Multiple Choice

Enable multiple choice selection to allow users to select more than one option. When enabled:

* Users can select multiple buttons before submitting
* A custom submit button appears with configurable text
* Selected answers are joined with commas in the saved variable

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Multiple choices in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Multiple choices in bot" />
    </Frame>
  </Tab>
</Tabs>

### Add Search input

Enable search functionality to help users filter through many options:

* Adds a search input field above the buttons
* Allows users to type and filter available choices
* **Search Placeholder**: Set placeholder text for the search input field

### Image support

Upload custom images for each choice option:

* **Label**: Add a label to each picture choice (supports variables)
* **Value**: Add a value to each picture choice (supports variables), if it's empty it take the label as value.
* **Display Conditions**: Show/hide specific options based on variable conditions.

### Dynamic data

Instead of adding items manually, you can also display a dynamic list of items based on a variable.

This is useful when you want to display a list of items from another data source. For this to work,
you first need to make sure the variable you are using contains a list of values. This list can be
extracted from an integration block like Google Sheets.

### Allow alternative flow

Enable the "Allow alternative flow" option when you want to give users the flexibility to provide
their own response instead of selecting from predefined choices.

**How it works:**

* Adds an additional flow path that activates when the user wants to provide a custom answer
* Perfect for scenarios where predefined options might not cover all cases
* Typically connected to a "Text" user block to capture the user's custom input
* Replaces the need for manual "Other" buttons in your flow

**Use cases:**

* Product preference forms where users might have unique requirements
* Feedback collection when predefined options may not capture all responses
* Search-like functionality where users can specify exactly what they need

<Frame>
  <img alt="Allow alternative flow setup" />
</Frame>

### Integration Considerations

* When using with webhooks, parse comma-separated values for multiple choices
* Dynamic button data should be formatted as an array of strings
* Variable updates from other blocks may affect dynamic button display


# Date
Source: https://docs.quick.bot/builder/editor/blocks/user/date



The Date user block allows you to ask your user for a date. You can ask for a specific date or range
and include time. The block uses native date pickers that adapt to different devices and browsers.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Date input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Date input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Button Label**: Customize the text shown on the submit button
* **Save Answer**: Choose a variable to store the collected date/range

### Date Range Toggle

Enable date range selection to allow users to pick both start and end dates:

* **From Label**: Customize the label for the start date field (range mode only)
* **To Label**: Customize the label for the end date field (range mode only)
* Collected as a formatted range string in the saved variable

### Time Integration

Enable time selection alongside date picking:

* Changes input type from `date` to `datetime-local`
* Allows users to specify both date and time
* Affects the format patterns and display options

### Date Constraints

* **Minimum Date**: Set the earliest selectable date (format: YYYY-MM-DD or YYYY-MM-DDTHH:mm)
* **Maximum Date**: Set the latest selectable date (format: YYYY-MM-DD or YYYY-MM-DDTHH:mm)
* Supports variable integration for dynamic date limits

### Format

The `Format` setting lets you customize the picked date format.

<Info>
  Under the hood, it is done using the [date-fns](https://date-fns.org/) library. You can use any of
  the [formatting tokens](https://date-fns.org/docs/format) supported by the library.
</Info>


# Email
Source: https://docs.quick.bot/builder/editor/blocks/user/email



The Email user block allows you to ask your user for an email address with automatic format
validation. It provides a specialized input field that ensures proper email format before allowing
the user to proceed.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Email input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Email input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Placeholder**: Set the placeholder text shown in the email input field (supports variables).
* **Button Label**: Customize the text shown on the submit button (supports variables).
* **Save Answer**: Choose a variable to store the collected email address.

### Email Format Validation

The block automatically validates email format and displays a retry message when detection fails.
Common validation rules include:

* Presence of exactly one @ symbol
* Valid characters in username and domain parts
* Proper domain structure (e.g., domain.extension)

it does **NOT** verify:

* Whether the email address actually exists
* If the domain is valid and reachable
* If the mailbox can receive messages

<Note>
  For comprehensive email validation beyond format checking, you'll need to integrate with external
  services using an [HTTP Request block](/builder/editor/blocks/integrations/http-request):

  * Email deliverability services
  * Domain verification APIs
  * Real-time email validation services
</Note>

## Integration Examples

### Basic Email Collection

```
User Input: john.doe@example.com
Validation: ✓ Format valid
Saved Variable: john.doe@example.com
```

### Invalid Format Handling

```
User Input: john.doe@
Validation: ✗ Format invalid
Display: Custom retry message
User Action: Re-enter valid email
```


# File upload
Source: https://docs.quick.bot/builder/editor/blocks/user/file-upload



The File upload user block allows you to collect files from your user. It supports single and
multiple file uploads with customizable visibility settings and comprehensive labeling options.

## Configuration Options

### File Upload Settings

* **Required**: Make file upload mandatory or optional for form completion
* **Allow Multiple Files**: Enable users to upload multiple files in a single interaction
* **Placeholder**: Custom HTML-enabled content displayed in the upload area
* **Visibility**: Control whether uploaded files are publicly accessible or private

### Custom Labels

Comprehensive labeling system with context-aware options:

* **Button Label**: Text for the submit/upload button
* **Clear Label**: Text for clearing selected files (multiple files only)
* **Skip Label**: Text for skipping upload (when not required)
* **Success Labels**: Different messages for single vs. multiple file uploads

### Variable Integration

* **Save Upload**: Choose a variable to store file URLs or file information
* Variable content adapts based on single vs. multiple file configuration

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="File upload input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="File upload input in bot" />
    </Frame>
  </Tab>
</Tabs>

## HTML Placeholder Support

The placeholder field accepts [HTML](https://en.wikipedia.org/wiki/HTML) for rich formatting:

* Use HTML tags to style instructions
* Include images or icons in upload areas
* Create visually appealing upload prompts
* Support for basic HTML elements and styling

### HTML Examples

```html theme={null}
<strong>Upload your resume!</strong> <br />Accepted formats: PDF, DOC, DOCX

<div style="color: #007bff;">📎 Drop files here or click to browse</div>
```

## File Size and Type Limitations

### Size Limit

There is a 10MB fixed limit per uploaded file. For larger files:

* Direct users to cloud storage services (Google Drive, Dropbox, OneDrive)
* Request shareable links instead of direct uploads
* Consider breaking large files into smaller parts
* Implement file compression recommendations

### File Type Handling

The block accepts all file types by default:

* Images: JPG, PNG, GIF, SVG, WebP
* Documents: PDF, DOC, DOCX, TXT, RTF
* Archives: ZIP, RAR, 7Z
* Media: MP4, MP3, AVI, WAV
* Data: CSV, XLS, XLSX, JSON

## Visibility Options

### Public vs. Private Files

Choose how uploaded files are accessible:

**Public Files:**

* Generate publicly accessible URLs
* Anyone with the link can view files
* Compatible with external services and integrations
* Suitable for sharing and embedding

**Private Files:**

* Restricted to workspace members only
* Require authentication to access
* Cannot be used with external services
* Enhanced security for sensitive documents

**Auto Mode (Default):**

* Public for web-based uploads
* Private for WhatsApp and other messaging platforms
* Platform-optimized visibility settings

### Integration Impact

**Public files** enable:

* Email attachments via Email block
* Integration with external APIs
* Direct linking in webhooks
* Embedding in external websites

**Private files** restrict:

* External service access
* Direct URL sharing
* Third-party integrations
* Public embedding capabilities

## Multiple File Upload

### Configuration Options

When multiple file upload is enabled:

* Users can select several files at once
* Clear button allows removing all selected files
* Success message includes total count using `{total}` placeholder
* Variable stores array of file URLs

### Success Message Templates

* **Single file**: "File uploaded successfully!"
* **Multiple files**: "Uploaded  files successfully!"
* Customize messages to match your brand voice
* Include file count for user confirmation

## Advanced Features

### Conditional Labels

Labels automatically adapt based on configuration:

* Skip button only appears when upload is not required
* Clear button only appears for multiple file uploads
* Success messages change based on single vs. multiple mode

### File Preview

Uploaded files show:

* Image thumbnails for visual files
* File names and types for documents
* Upload progress indicators
* Remove/clear options

### Mobile Optimization

* Touch-friendly upload interface
* Camera integration for mobile uploads
* Drag-and-drop support where available
* Responsive layout adaptation

## Integration Examples

### Single File Upload

```
Configuration: Required, Public visibility
User uploads: document.pdf
Saved variable: "https://storage.quickbot.io/files/abc123/document.pdf"
```

### Multiple File Upload

```
Configuration: Optional, Private visibility, Multiple files
User uploads: photo1.jpg, photo2.jpg, document.pdf
Saved variable: ["url1", "url2", "url3"]
Success message: "Uploaded 3 files successfully!"
```

## Troubleshooting

### Common Issues

**Files not uploading**

* Check file size is under 10MB limit
* Verify internet connection stability
* Ensure browser supports HTML5 file uploads
* Test with different file types

**Variable not saving file URLs**

* Confirm a variable is selected in settings
* Check that upload completes successfully
* Verify visibility settings don't restrict access
* Ensure workspace has sufficient storage

**Multiple file upload issues**

* Verify "Allow multiple files" is enabled
* Check browser compatibility with multiple file selection
* Test file selection method (drag-drop vs. browse)
* Confirm clear button functionality

**Visibility and access problems**

* Understand public vs. private implications
* Test file URLs in intended integration context
* Verify workspace member access for private files
* Check external service compatibility requirements

### Plan Restrictions

File upload blocks may have plan-specific limitations:

* Free plans may restrict file upload functionality
* Check plan features before implementing file uploads
* Upgrade required messages appear during publishing
* Multiple file uploads may require higher plan tiers

### Integration Considerations

* Parse file URLs correctly in webhook handlers
* Handle array format for multiple file uploads
* Implement appropriate error handling for failed uploads
* Consider file cleanup and retention policies
* Test visibility settings with intended downstream systems


# Number
Source: https://docs.quick.bot/builder/editor/blocks/user/number



The Number user block allows you to ask your user for numerical input with built-in validation and
formatting controls. It provides a specialized input field that ensures only valid numbers are
accepted.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Number input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Number input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Placeholder**: Set placeholder text shown in the number input field (supports variables).
* **Button Label**: Customize the text shown on the submit button (supports variables).
* **Min**: Set the lowest acceptable number (supports variables).
* **Max**: Set the highest acceptable number (supports variables).
* **Step**: Define increment/decrement steps for input controls.
* Automatic validation prevents out-of-range submissions.
* **Save Answer**: Choose a variable to store the collected number.

## Integration Examples

### Age Collection

```
Configuration:
- Min: 0, Max: 120, Step: 1
- Placeholder: "Enter your age"
User Input: 25
Saved Variable: 25
```

### Budget Range with Dynamic Limits

```
Configuration:
- Min: {{userProfile.minBudget}}, Max: {{userProfile.maxBudget}}
- Step: 100, Placeholder: "Your budget"
User Input: 5000
Validation: ✓ Within dynamic range
Saved Variable: 5000
```


# Phone
Source: https://docs.quick.bot/builder/editor/blocks/user/phone



The Phone number user block allows you to ask your user for a phone number and ensure it is properly
formatted. It supports international phone number validation, country code selection, and stores
numbers in a consistent format.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Phone number input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Phone number input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Placeholder**: Customize the input field placeholder (supports variables)
* **Button label**: Configure the submit button label (supports variables)
* **Default Country**: Select a default country code from 200+ supported countries. Leave unset
  (international) to allow users to select any country code
* **Save Answer**: Choose a variable to store the validated phone number

## Automatic Validation

* **Format Checking**: Validates phone number format based on selected country
* **Real-time Feedback**: Provides immediate validation feedback to users
* **Error Handling**: Shows retry message when invalid formats are entered


# Rating
Source: https://docs.quick.bot/builder/editor/blocks/user/rating



The Rating user block allows you to collect user ratings with flexible scales, customizable icons,
and various display options.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Rating input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Rating input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Maximum**: Choose from 3 to 10 rating options.
* **Type**: Select between icons (stars or custom) or numbers to display.
* **Start at**: For number displays, set the starting number (supports variables).
* **1 label**: add a label for the lowest rating.
* **10 label**: add a label for the highest rating.
* **Custom icon**: to add a custom icon use the HTML tag `<svg>...</svg>`.
* **One-Click Submit**: Enable immediate submission upon selection
* **Save Answer**: Choose a variable to store the rating value
* **WhatsApp message**: Custom message for WhatsApp. If empty, a default message will be generated based on the rating configuration.


# Text
Source: https://docs.quick.bot/builder/editor/blocks/user/text



The Text user block allows you to collect text responses from users, it provides a flexible textarea
that automatically adjusts based on user input.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Text" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Text" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Placeholder**: Customize the placeholder text to guide the user (supports variables).
* **Button Label**: Customize the submit button label (supports variables).
* **Allow Audio clip**: Allow users to send voice messages and save it as URLs in dedicated variables.
* **Allow Attachment**: Allow users to send files and save it as URLs in separate variables.
* **Save the Answer**: Store the responses in designated variables.


# Website
Source: https://docs.quick.bot/builder/editor/blocks/user/website



The Website user block allows you to collect URLs from users with automatic format validation. It
ensures URLs are properly structured and provides user-friendly error handling for invalid entries.

<Tabs>
  <Tab title="Flow">
    <Frame>
      <img alt="Website input in flow builder" />
    </Frame>
  </Tab>

  <Tab title="Bot">
    <Frame>
      <img alt="Website input in bot" />
    </Frame>
  </Tab>
</Tabs>

## Configuration

* **Placeholder**: Set the placeholder text shown in the URL input field (supports variables).
* **Button Text**: Customize the submit button label (supports variables).
* **Save Answer**: Choose a variable to store the validated URL.

### URL Validation

* **Format Checking**: Validates URL structure and format automatically
* **Protocol Support**: Accepts HTTP, HTTPS, and other standard protocols
* **Error Handling**: Displays retry message when URLs are improperly formatted
* **Real-time Feedback**: Immediate validation feedback to users


# Export
Source: https://docs.quick.bot/builder/editor/export



Export your bots to create backups, share configurations, or migrate between workspaces. Bot exports
include all flow logic, settings, and configurations in a portable JSON format.

## What's Included in Bot Exports

When you export a bot, the following elements are included:

### Flow Data

* **All blocks**: Every block in your bot flow with their configurations
* **Connections**: How blocks are linked together
* **Variables**: All custom variables and their settings
* **Conditional logic**: If/then conditions and routing rules

### Bot Settings

* **General settings**: Bot name, description, and basic configurations
* **Theme settings**: Colors, fonts, and visual customizations
* **Behavior settings**: Typing delays, transitions, and user experience options
* **Integration configurations**: Block settings (but not credentials)

### What's NOT Included

* **Credentials**: Security credentials are never exported
* **Response data**: User submissions and chat logs
* **Analytics**: Performance metrics and statistics
* **Published URLs**: Deployment-specific configurations

<Note>
  Exported bots are completely portable but will need new credentials configured when imported into
  different workspaces.
</Note>

### Export Naming

Exported files are automatically named using the format:

```
[bot-name]-[timestamp].json
```

For example: `lead-generation-bot-2024-01-15.json`

### File Format

Bot exports use JSON format with the following structure:

* **Metadata**: Bot information and export details
* **Blocks**: Array of all bot blocks with configurations
* **Edges**: Connections between blocks
* **Variables**: Custom variables and settings
* **Theme**: Visual styling configuration

## How to Export a Bot

### From Bot Editor

1. Open the bot you want to export in the editor
2. Click on **Settings** in the top navigation
3. Navigate to the **Export** section
4. Click **Export bot**
5. Choose your export options (if available)
6. Download the generated JSON file

### From Workspace Dashboard

1. Find the bot in your workspace dashboard
2. Click the **More** menu (three dots) on the bot card
3. Select **Export** from the dropdown menu
4. The bot JSON file will be downloaded automatically

<Tip>
  Export your most important bots regularly as part of your backup strategy. Consider it insurance
  for your bot investments.
</Tip>


# Flow Editor
Source: https://docs.quick.bot/builder/editor/flow



The Flow editor is the visual workspace where you design your bot's conversation flow by dragging
and connecting blocks together. It provides an intuitive graph-based interface for building complex
conversational experiences.

Blocks are atomic components used to create a bot conversation. Each block has a specific purpose.
By combining different blocks, you can build rich and dynamic conversational experiences.

<Frame>
  <img alt="Flow editor" />
</Frame>

## Accessing the Flow Editor

To access the Flow editor:

1. Go to [bots](https://app.quick.bot/bots)
2. Select a bot from your bot list or create a new one
3. The Flow editor opens by default in the main editor view
4. You can also click the **Flow** button in the left sidebar to return to Flow view from other
   editor sections

## Interacting with the Flow Editor

### Graph Area

The main graph area is where you build your conversation flow, you can:

* **Drag blocks** from the left sidebar into the graph to add them to your flow.
* **Connect blocks** by dragging from output points to input points, you will see a line connecting
  them.
* **Group blocks** to organize your flow visually.
* **Select multiple blocks** for bulk operations.
* **Zoom** in/out click or `Ctrl` + `Mouse wheel`
* **Pan** the graph by clicking and dragging or using the `Space` key + drag, you can also use the
  mouse wheel for vertical pan.
* **Undo/redo** to correct mistakes. `Ctrl` + `z` to undo and `Ctrl` + `y` to redo
* **Auto organize**: The system automatically aligns blocks and connections for clarity.
* **Preview button**: Test your flow in a live simulation environment.
* **Publish button**: Deploy your flow to make it live for users.

<Frame>
  <img alt="Flow editor" />
</Frame>

### Flow Sidebar

The left sidebar contains all the tools and resources you need to build your flow, is divided into
two main sections, components and variables.

In the **Components tab**, you can find all available block types, organized into categories.

* **Bubbles**: are the main building blocks of your flow, they represent messages, actions, and
  logic in your bot's conversation. Each block type has its own configuration options and can be
  customized to fit your bot's needs.
* **Inputs**: Blocks that capture user input, such as text, buttons, or forms. These blocks allow
  your bot to interact with users and collect information.
* **Logic**: Blocks that control the flow of the conversation based on conditions, variables, or
  user input. These blocks enable your bot to make decisions and respond dynamically.
* **Integrations**: Blocks that connect your bot to external services, APIs, or databases. These
  blocks allow your bot to fetch data, send notifications, or perform actions outside of the chat
  interface.

<Tip>
  You will note that complex blocks, such as integrations, has pre built templates that you can use
  to quickly set up your flow and learn how to use them.
</Tip>

In the **Variables tab**, you can manage all the variables used in your flow. Variables are used to
store and manipulate data throughout the conversation. You can create, edit, and delete variables.

### Warnings and validation

When you have blocks connected in a way that is not valid, the system will show you a warning
message with the issue and where it is located. You can click on the warning to be taken to the
block that has the issue.

<Frame>
  <img alt="Flow editor warning" />
</Frame>

Also working with integrations, you may encounter warnings related to missing or incorrect
configuration. The system will highlight the affected blocks.

<Frame>
  <img alt="Flow editor validation" />
</Frame>

<CardGroup>
  <Card title="Blocks" icon="cube" href="./blocks/general">
    Learn about all available block types and their configurations
  </Card>

  <Card title="Variables" icon="code" href="./variables">
    Manage data flow between blocks with variables
  </Card>
</CardGroup>


# Invite
Source: https://docs.quick.bot/builder/editor/invite



The Invite panel lets you share your bot's flow through a public, read-only link. Everyone in your
workspace already has access to every bot in it; to give someone access, invite them to the
workspace (see [Workspace Members](../../app/workspace/members)).

## Accessing the Invite Panel

1. **Open your bot** in the Flow editor
2. **Click the Invite button** (share icon) in the top toolbar
3. **The invite panel will open** as a dropdown with the sharing options

## Public Sharing

### Make Bot Publicly Available

1. **Open the Invite panel**
2. **Toggle "Make the flow publicly available"**
3. **Copy the generated public URL**
4. **Share the URL** with anyone you want to access the bot

### Public Access Features

When a bot is publicly shared:

* **No authentication required** to access the bot
* **Anyone with the link** can view the flow
* **Signed-in visitors can test** the flow in preview mode, without the workspace's credentials
* **Full flow visibility** including all blocks and connections
* **Read-only access** - no editing capabilities
* **Ideal for**: Client presentations, public demos, or team reviews

<Frame>
  <img alt="Bot invite" />
</Frame>

### Security Considerations

* **Public links** are not indexed by search engines but are accessible to anyone with the URL
* **No sensitive data** should be included in publicly shared bots
* **Results and analytics** are never accessible through public sharing
* **You can disable** public sharing at any time

## Best Practices

* **Disable public sharing** when not needed for security
* **Use descriptive bot names** since they appear in public URLs
* **Test public links** before sharing to ensure proper functionality
* **Monitor usage** if sharing broadly

## Troubleshooting

**Public sharing not working**:

* Ensure "Make the flow publicly available" is enabled
* Verify the public URL is copied correctly
* Check if bot has any configuration errors
* Test the public link in an incognito browser

<CardGroup>
  <Card title="Workspace Members" icon="users" href="../../app/workspace/members">
    Learn how to manage your workspace team and roles
  </Card>

  <Card title="Deploy" icon="rocket" href="../deploy/general">
    Publish your bot and make it available to end users
  </Card>
</CardGroup>


# Publish
Source: https://docs.quick.bot/builder/editor/publish



Publishing your bot makes it available to users at its public URL and enables data collection.

## Published vs Unpublished Bots

**Unpublished bots**:

* Only accessible to workspace members
* Changes are automatically saved as drafts
* No public URL access for end users
* Results collection is disabled

**Published bots**:

* Accessible via public URL to anyone
* Results collection is active
* Can be embedded in websites and applications
* Version-controlled - unpublished changes don't affect live bot

## Publishing Your Bot

To publish your bot:

1. Click the **Publish** button in the top toolbar.
2. Confirm publish in the modal.
   * Optional, enable the **End all active sessions** to close remaining conversations.
3. Your bot is now live at its public URL

The Publish button shows different states:

* **"Publish"** - First time publishing or unpublished bot
* **"Save"** - Bot has unpublished changes that need publishing
* **"Published"** - Bot is live and up-to-date

### Publishing States and Controls

<Frame>
  <img alt="Publish button and menu options" />
</Frame>

* **"Unpublish bot"** - Take the bot offline; users will see "The bot you're looking for doesn't
  exist"
* **"Restore published version"** - Discard current changes and revert to the live published version
* **"Close bot"** - Temporarily disable the bot; users will see "This bot is now closed"
* **"Reopen bot"** - Reactivate a closed bot.
* **"Export bot"** - Download bot configuration as JSON file.

<Tip>
  Always test your bot thoroughly in Preview mode before publishing. Once published, changes require
  republishing to take effect for users.
</Tip>

### Publishing Issues

**Bot won't publish**:

* Check for incomplete blocks or missing connections
* Verify all required fields are filled
* Ensure no validation errors exist
* Try refreshing the page and publishing again

**Changes not appearing**:

* Confirm you clicked "Publish" not just "Save"
* Clear browser cache and reload
* Check if bot is closed or unpublished
* Verify correct URL is being accessed

<CardGroup>
  <Card title="Deploy" icon="rocket" href="../deploy/client">
    Learn about embedding and deployment options
  </Card>

  <Card title="Results" icon="chart-line" href="/builder/results/table">
    Analyze user interactions and bot performance
  </Card>
</CardGroup>


# Variables
Source: https://docs.quick.bot/builder/editor/variables



Variables are placeholders for dynamic content that you can use throughout your bot to create
personalized user experiences. They store data collected from user inputs, external integrations, or
predefined values, making your conversations interactive and context-aware.

<Frame>
  <img alt="Bot variables panel" />
</Frame>

## Understanding Variables

Variables in QuickBot serve as data containers that can store:

* **User responses** from user blocks (text, email, choices, etc.)
* **External data** from integrations (APIs, databases, etc.)
* **System values** (timestamps, user IDs, random values, etc.)
* **Calculated values** from custom scripts or logic blocks

<Frame>
  <img alt="Bot variables usage" />
</Frame>

### Accessing Variables

In the flow editor blocks, you'll find some fields with a  icon. This field allows you to view the
variables dropdown. This dropdown shows all available variables for use in the bot.

* **View all variables**: See every variable declared in your bot.
* **Search variables**: Use the search bar to quickly find specific variables.
* **Create new variables**: Click the plus icon or type a new name to create variables.
* **Insert variables**: Click the variable and it will be inserted into the field.
* **Edit variables**: Click the edit icon to modify variable properties.
* **Delete variables**: Click the delete icon to remove the variable.

<Frame>
  <img alt="Bot variables add" />
</Frame>

## Creating Variables

### From Input Blocks

The most common way to create variables is by configuring user blocks:

1. **Add an user block** (Text Input, Email, Buttons, etc.)
2. **Open the block settings**
3. **Select "Save answer in a variable"**
4. **Choose an existing variable** or type a new name to create one
5. **User responses** will automatically be stored in the variable

<Frame>
  <img alt="Bot variables create" />
</Frame>

### From Variables Panel

Create variables directly in the Variables tab:

1. **Open Variables tab** in the Flow editor sidebar
2. **Type a new variable name** in the search box
3. **Click "Create variable"** when prompted
4. **Configure variable properties** in the edit modal

<Frame>
  <img alt="Bot variables create" />
</Frame>

### Using Set Variable Block

For advanced variable management, use the Set Variable logic block:

1. **Drag a Set Variable block** onto the canvas
2. **Choose or create a variable** to modify
3. **Select the value type**:
   * **Custom**: Text or JavaScript expressions
   * **System variables**: Access built-in system values
   * **List operations**: Append, pop, or manipulate arrays
   * **Data mapping**: Transform data from other variables

## System Variables

QuickBot provides built-in system variables that give you access to contextual information about the
conversation, user, and environment. These variables are automatically available and can be
referenced directly using the `{{system_variableName}}` syntax.

### Available System Variables

#### Date and Time

* **`{{system_today}}`**: Current date (YYYY-MM-DD format)
* **`{{system_now}}`**: Current date and time (ISO 8601 format)
* **`{{system_yesterday}}`**: Previous day's date
* **`{{system_tomorrow}}`**: Next day's date
* **`{{system_momentOfTheDay}}`**: Time-based greeting value: `morning`, `afternoon`, `evening`, or
  `night`

**Example usage:**

```
Today's date is {{system_today}}
Current timestamp: {{system_now}}
```

#### Session Information

* **`{{system_randomId}}`**: Unique random identifier (CUID algorithm)
* **`{{Conversation}}`**: Complete conversation transcript including all messages exchanged

**Example usage:**

```
Session ID: {{system_randomId}}
```

#### Environment Context

* **`{{system_platform}}`**: Platform identifier (`web` or `whatsapp`)
* **`{{system_device}}`**: Device type (`mobile` or `desktop`)

**Example usage:**

```
You're using QuickBot on {{system_platform}}
```

#### Contact Variables

Filled automatically when the channel knows the person's identity (WhatsApp), or from the flow via an input or Set Variable on any channel:

* **`{{Contact Phone}}`**: User's phone number (auto-filled on WhatsApp)
* **`{{Contact Name}}`**: User's contact name (auto-filled on WhatsApp)
* **`{{Contact Email}}`**: User's email address (filled from the flow)

**Example usage:**

```
Hello {{Contact Name}}, your number is {{Contact Phone}}
```

### Using System Variables

System variables can be used anywhere regular variables are accepted:

**In text bubbles:**

```
Good {{system_momentOfTheDay}}, welcome to our bot!
```

**In Set Variable blocks:**

```
{{Conversation}}
```

**In JavaScript expressions:**

```js theme={null}
{{=new Date({{system_now}}).toLocaleDateString()=}}
```

**In condition blocks:**

```
If {{system_platform}} equals "whatsapp"
```

### System Variable Characteristics

* **Read-only**: System variables are automatically populated and cannot be manually modified
* **Always available**: No need to create or initialize them
* **Real-time**: Values are computed at runtime based on the current context
* **Not saved in results**: Most system variables are not persisted in the results table by default
* **No initialization required**: Ready to use immediately without any setup

## Using Variables in Your Bot

### Basic Variable Syntax

Display variable content using double curly braces:

```
{{varName}}
```

**Example**: "Hello `{{varName}}`, welcome back!"

### Inline Variable Formatting

Transform variables using JavaScript expressions:

```
{{={{varName}}.toUpperCase()=}}
```

**Common transformations**:

* **Uppercase**: `{{={{Name}}.toUpperCase()=}}`
* **Lowercase**: `{{={{Name}}.toLowerCase()=}}`
* **First item of list**: `{{={{Items}}[0]=}}` or `{{={{Items}}.at(0)=}}`
* **Last item of list**: `{{={{Items}}.at(-1)=}}`
* **List length**: `{{={{Items}}.length=}}`
* **Date formatting**: `{{=new Date({{Date}}).toLocaleDateString()=}}`

### Variable Types and Operations

Variables support these data types:

* **String**: Single text values
* **Array**: Lists of text values
* **Mixed**: Automatically converted to string representation

## Variable Properties

### Save in Results

Control whether variables appear in your results export:

* **Enabled**: Variable values appear as columns in results
* **Disabled**: Variables are used internally but not exported
* **Use case**: Enable for important data, disable for temporary calculations

## Advanced Variable Concepts

### Prefilled Variables

Initialize variables before the conversation starts:

**URL Parameters**:

```
https://quick.bot/my-bot?Email=john@gmail.com&First%20name=John
```

(Note: Replace spaces with `%20` in URLs)

**Embed Library**:

```js theme={null}
QuickBot.initBubble({
  botId: 'your-bot-id',
  prefilledVariables: {
    Email: 'john@gmail.com',
    'First Name': 'John',
    'User ID': '12345',
  },
})
```

### Save variables in results

You can also use save variables in results for internal tracking like:

* **Marketing**: UTM parameters, campaign IDs
* **User context**: Session IDs, referrer information
* **System data**: Timestamps, environment variables
* **Analytics**: Custom event tracking, user segments

**Use cases**:

* Track marketing campaign effectiveness
* Store user authentication data
* Maintain session context across conversations
* Collect analytics without user input

### Variable Validation and Types

Variables automatically handle type conversion:

**Valid types**:

```ts theme={null}
// ✅ Recommended
'Hello World'[('option1', 'option2')] // String // String array
;('123') // Number as string
;('true') // Boolean as string
```

**Auto-conversion**:

```ts theme={null}
// These are automatically converted
123 → '123'
true → 'true'
{ name: 'John' } → '{"name":"John"}'
```

**Complex data handling**:

```ts theme={null}
// Store complex objects as JSON strings
Use: {{=JSON.stringify({name: 'John', age: 30})=}}

// Parse back to objects when needed
Use: {{=JSON.parse({{User Data}}).name=}}
```

## Variable Best Practices

### Naming Conventions

* **Use descriptive names**: "User Email" instead of "email"
* **Be consistent**: Use the same case style throughout
* **Avoid special characters**: Stick to letters, numbers, and spaces
* **Group related variables**: "Address Line 1", "Address Line 2"

### Organization

* **Delete unused variables** to keep your bot clean
* **Enable "Save in Results"** only for variables you need to export
* **Group variables logically** in your variable names

### Performance

* **Avoid deeply nested objects** in variables
* **Use arrays efficiently** with proper indexing
* **Clean up temporary variables** when no longer needed
* **Test variable transformations** to ensure correct output

## Troubleshooting Variables

### Common Issues

**Variable not displaying**:

* Check variable name spelling and case
* Ensure variable has been created and assigned a value
* Verify variable syntax: `{{varName}}`

**Incorrect formatting**:

* Test JavaScript expressions in Set Variable block first
* Check for typos in transformation code
* Ensure proper escape characters for special content

**Missing in results**:

* Enable "Save in Results" in variable properties
* Verify variable has collected values from users

<CardGroup>
  <Card title="Set Variable Block" icon="code" href="./blocks/logic/variable">
    Learn how to manipulate and calculate variable values
  </Card>

  <Card title="Logic Blocks" icon="sitemap" href="./blocks/logic">
    Use variables in conditional logic and flow control
  </Card>
</CardGroup>

<Tip>
  Use the Variables tab frequently while building your bot. It provides a centralized view of all
  your data and makes it easy to manage complex bots with many variables.
</Tip>


# Settings
Source: https://docs.quick.bot/builder/settings/general



## General

The general settings represent the general behaviors of your bot.

<Frame>
  <img alt="General" />
</Frame>

* **Prefill input**: If enabled, the inputs will be automatically pre-filled whenever their
  associated variable has a value.
* **Hide query params on bot start**: If enabled, the query params will be hidden when the bot
  starts.
* **Remember user**: If enabled, the bot will remember the user's previous interactions and use them
  to improve future responses.

## Typing emulation

By default, your bot will emulate a certain typing speed. It is considered a good default as slow as
a human typing speed and it's not too fast so that multiple bubbles can be read sequentially.

You can customize this typing speed in the settings:

<Frame>
  <img alt="Bot typing emulation" />
</Frame>

The goal of a bot is not to pretend that the bot is a real human. So we suggest not setting the
typing speed too low.

The `Disable on first message` allows you to disable the typing emulation on the first message. This
is useful if you want to lower the first message display time since the site can take some time to
load first.

The `Delay between messages` by default is 0 and you can increase it up to 5 seconds if you want to
add a delay between **every** messages sent by the bot. If you ever want to pause the bot just once.
You can insert a [Wait block](../editor/blocks/logic/wait) between both messages.

## Security

By default, your bot can be executed from any origin but you can restrict the execution of your bot
to specific origins. This is useful if you want to embed your bot in your website and prevent it
from being executed on other websites by malicious actors.

For example, if you want to allow your bot to be executed only on `https://my-site.com`, you can add
`https://my-site.com` to the list of allowed origins.

<Warning>
  If you add a URL to the list but omit [https://quick.bot](https://quick.bot), then your bot shareable URL will not work
  anymore.
</Warning>

## Metadata

In the Metadata section, you can customize how the preview card will look if you share your bot URL
on social media for example.

You can also add some custom head code to add third-party scripts.

### Google Tag Manager

Allows you to easily add a GTM container to your bot. To find your GTM container ID, go to your GTM
dashboard and click on the container you want to use. The ID is displayed in the top right corner.

Note that you should not include it if you are embedding your bot in an existing website. GTM should
be installed in the parent website instead.

### Remember user

Head over to the `Settings` tab of your bot, under the `General` section you can find the
`Remember user` setting.

This setting allows you to save the chat session state into the user's web browser storage. It means
that if he answers a question and then closes the chat, the next time he opens it, the chat will be
in the same state as it was before.

There are 2 storage options:

* **Local storage**: The chat state will be saved in the user's web browser. It will be available
  only on the same device and web browser.
* **Session storage**: The chat state will be saved in the user's web browser. It will be available
  only on the same device and web browser, but it will be deleted when the user closes the current
  tab or the web browser.

Note that if you publish a new version of your bot, saved sessions will be automatically resetted.
It means that if the user has a saved session, if he refreshes the bot and that a new version is
published, the bot will restart from the beginning.


# Theme
Source: https://docs.quick.bot/builder/theme/general



The theme tab allows you to customize the look of your bot.

<Frame>
  <img alt="Bot theme customization" />
</Frame>

## General

This section allows you to enable or disable the bot branding, change the font and the background of
your bot.

### Typography

You can change the font of your bot in the Theme tab under the Global section.

There, you can choose between choosing a font from Google Fonts or defining your own custom font.

## Chat

This section allows you to customize all the conversations components (avatars, bubbles, inputs
etc...).

## Custom CSS

You can also decide to customize even further by adding any custom CSS you want. For this you
right-click on the bot in the Theme page and inspect the element you want to customize:

For example, if I want my buttons to be more rounded, and have a fancy gradient color, I can add
this to the custom CSS:

```css theme={null}
.bot-button {
  border-radius: 40px;
  background-image: linear-gradient(to right, #e052a0, #f15c41);
  border: none;
}
```


# Human Handoff
Source: https://docs.quick.bot/human-handoff/general



Human Handoff is a feature that allows you to transfer the conversation from your bot to a human
agent. This is useful when the bot is unable to handle a user's request or when the user prefers to
speak with a human.

## Human Handoff block

To start a human handoff you need to have your bot **published**.

In the flow editor, grab and drop the **Human Handoff** block into your flow. You can find it in the
**integration** section of the blocks panel.

<Frame>
  <img alt="Human Handoff Block" />
</Frame>

You don't need to configure any settings for the human handoff block or add any additional blocks,
the block itself has all the necessary to handle the conversation.

<Note>
  Currently the human handoff block does not have output points. This means it cannot direct the
  flow to other blocks. May change in future updates.

  We recommend placing the human handoff block at the end of your flow, after all other blocks have
  been executed. This ensures that the user has completed their interaction with the bot before being
  transferred to a human agent.
</Note>

Once you have added the human handoff block to your flow, you can start using it by speaking with
your bot in viewer or via whatsapp if you have it deployed.

<Info>
  Preview mode does not work here because you will use the inbox to take over the conversation.
</Info>

When the bot reaches the human handoff block, the customer will see a message that this conversation
is being transferred to a human agent.

<Frame>
  <img alt="Flow editor" />
</Frame>

The bot will send a request to the inbox for a human agent to take over the conversation. Until an
agent takes over, the customer cannot continue interacting with the bot.

## Human Handoff in the inbox

In your inbox, Search for the conversation with the customer awaiting a human agent.

Inside the conversation, you can see a new button in the inbox that says **Take Over**. This button
will only appear when the bot flow has a human handoff block and the customer is waiting for a human
agent.

<Frame>
  <img alt="Inbox conversation" />
</Frame>

You have the option to accept or reject the conversation. If you accept, you can start chatting with
the customer. If you reject, by clicking in **End conversation**, the customer will be notified that
the conversation will be closed.

To start a conversation with the customer, Click on **Take Over** and confirm.

<Frame>
  <img alt="Take Over" />
</Frame>

After taking over the conversation, the customer will be notified that an agent has joined and start
chatting. You can then send messages to the customer, and they will be able to reply.

<Frame>
  <img alt="Conversation Started" />
</Frame>

### Multiple agents support

If multiple agents are available, the first agent to click **Take Over** will be assigned to the
conversation. Other agents will not be able to take over the same conversation while it is being
handled.

<Frame>
  <img alt="Conversation Started" />
</Frame>

<Info>
  To have multiple agents, you need to invite other members to your workspace. To know more about
  how to invite members, check the [workspace members section](/app/workspace/members).
</Info>


# Contact Us
Source: https://docs.quick.bot/support/contact



Need help? We're here to support you! Here are your options for getting assistance

## Discord

**Join our Discord Community** Get help from our community and support team in our
[Discord server](https://discord.com/invite/U3rs3rPPQ4).

## Premium Support

**Create a Support Ticket** Available for **Personal**, **Business**, and **Enterprise** plan
subscribers.

* **How to Access**: Click the support icon in the platform sidebar
* **Response Time**: Priority support
* **Benefits**: Direct access to our support team


# FAQ
Source: https://docs.quick.bot/support/faq



Find answers to the most commonly asked questions about QuickBot. If you don't find what you're
looking for, feel free to [contact our support team](/support/contact).

## Getting Started

### How do I create my first bot?

Navigate to your workspace and click **Build my first bot**, it will open a step-by-step wizard. Check the [bot section](/app/bots/bots) to learn more about creating and managing bots.

### What templates are available?

QuickBot offers templates for:

* Lead generation and qualification
* Customer support and FAQ bots
* AI-powered chat assistants
* Product recommendation flows
* Event registration and surveys

Access templates from the **Templates** tab when creating a new bot.

### How do I test my bot before publishing?

Use the **Preview** button in the editor to test your bot in real-time. The preview shows exactly how users will experience your bot.

## Authentication & Account Management

### How can I change my password?

To change your login method, go to [Security Settings](https://app.quick.bot/account/security) and connect your
preferred OAuth provider.

### How do I delete my account?

Contact our [support team](/support/contact) to permanently delete your account. This will remove
all your bots, data, and workspace information.

### Can I change my email address?

Yes, update your email in [Security Settings](https://app.quick.bot/account/security). You'll need to verify the new
email address before the change takes effect.

## Building & Editing Bots

### How can I delete a block?

Right-click on any block in the flow editor to open the contextual menu with delete options.
You can also select elements and use the Delete key.

### Can I set a variable with the Script block?

No, the Script block is only for executing JavaScript code. To set variables using code, use the
[Set Variable block](/builder/editor/blocks/logic/variable) instead, which allows both manual input
and code-based variable assignment.

### How do I use conditional logic in my bot?

Use the [Condition block](/builder/editor/blocks/logic/condition) to create different paths based on
user responses, variables, or external data. You can create multiple branches with complex logical
expressions.

### Can I duplicate a bot?

Yes, from your bots list, click the three-dot menu next to any bot and select **Duplicate**. This
creates a complete copy including all blocks, variables, and settings.

## Billing & Subscription

### What's included in each plan?

* **FREE**: 2 bots, 2 members, 100 conversations/month
* **PERSONAL**: Unlimited bots, 5 members, 2,000 conversations/month
* **BUSINESS**: Everything in Personal + custom branding removal, priority
  support
* **ENTERPRISE**: Maximum limits with dedicated support

View detailed pricing at [Billing & Usage](/app/workspace/billing).

### How is usage calculated?

* **Members**: Each user invited to your workspace counts toward your member limit
* **Conversations**: Each conversation session where a user interacts with your bot counts as one
  chat
* **Storage**: Files uploaded through your bots count toward your storage quota

### What happens when I exceed my limits?

* **Chat limits**: Your bots will stop responding to new users until your next billing cycle
* **Member limits**: You can't invite additional members until you upgrade or remove existing ones
* **Storage limits**: File uploads will be disabled until you free up space

### How do I upgrade or downgrade my plan?

Go to [Billing](/app/workspace/billing) and click **Change Plan**. Upgrades take effect
immediately, while downgrades apply at your next billing cycle.

## Deployment & Integration

### How do I embed my bot on my website?

After publishing your bot, go to the [Deploy](/builder/deploy/client) section and choose from three
embed options:

* **Standard**: Full-page chat interface
* **Popup**: Modal overlay triggered by user action
* **Bubble**: Floating chat bubble in corner of page

Copy the provided embed code and paste it into your website's HTML.

### How do I set up WhatsApp integration?

Follow our [WhatsApp deployment guide](/builder/deploy/whatsapp) to:

1. Connect your Meta Business account
2. Verify your phone number
3. Configure webhook settings
4. Test your bot integration

### Can I use multiple deployment channels?

Yes, each bot can be deployed simultaneously to:

* Your website (standard, popup, or bubble)
* WhatsApp Business
* Custom integrations via API
* Third-party platforms through webhooks

## Integrations & AI

### What AI models are available?

QuickBot currenty support OpenAi's models.

Configure AI integrations in [Workspace Credentials](/app/workspace/credentials).

### How do I connect to Google Sheets?

Use the [Google Sheets block](/builder/editor/blocks/integrations/google-sheets) to:

1. Authenticate with your Google account
2. Select your spreadsheet
3. Configure read/write operations
4. Map bot variables to sheet columns

### How do I set up email notifications?

Use the [Send Email block](/builder/editor/blocks/integrations/email) with either:

* Default QuickBot email service
* Your own SMTP server for custom branding

Configure email settings in [Workspace Credentials](/app/workspace/credentials).

### What payment methods does Stripe support?

The [Payment block](/builder/editor/blocks/integrations/stripe) supports all Stripe-enabled payment
methods including:

* Credit and debit cards
* Digital wallets (Apple Pay, Google Pay)
* Bank transfers and local payment methods
* International payment options

## Team & Workspace Management

### How do I invite team members?

Go to [Workspace Members](/app/workspace/members) and click **Invite Member**. Enter their email
address and select their role (Admin or Member). They'll receive an invitation email to join your
workspace.

### What's the difference between members and admins?

* **Admins**: Full workspace control, billing management, can invite/remove members, access all bots
* **Members**: Can create and edit bots, limited workspace settings access

### How do I manage workspace settings?

Access [Workspace Settings](/app/workspace/settings) to:

* Change workspace name and icon
* View workspace ID for API access
* Configure default bot settings
* Manage workspace deletion

## Advanced Features & Troubleshooting

### Is human takeover available on QuickBot?

Live chat is coming soon!

### Is there an affiliate program available?

No, QuickBot doesn't offer an affiliate program by design. We believe natural recommendations from
satisfied customers carry more weight than affiliate-driven promotions. Our focus is on creating the
best user experience possible so you'll want to recommend QuickBot organically.

### My bot isn't responding - what should I check?

Common troubleshooting steps:

1. Verify your bot is **Published** (not just saved as draft)
2. Check if you've exceeded your plan's chat limits
3. Ensure all required blocks have proper connections
4. Test integrations and API credentials in [Workspace Credentials](/app/workspace/credentials)
5. Review error logs in the [Results](/builder/results/table) section

### How do I export my bot data?

Go to [Results](/builder/results/table) and click **Export** to download your data in CSV or Excel
format. You can filter by date range and select specific columns to export.

### Can I use custom code in my bot?

Yes, use the [Script block](/builder/editor/blocks/logic/script) to execute custom JavaScript code.
You can also use the [Set Variable block](/builder/editor/blocks/logic/variable) for code-based
variable manipulation.

<CardGroup>
  <Card title="Contact Support" icon="message-text" href="/support/contact">
    Get personalized help from our support team
  </Card>

  <Card title="Getting Started" icon="rocket-launch" href="/app/getting-started/welcome">
    New to QuickBot? Start with our welcome guide
  </Card>
</CardGroup>

<Tip>
  Can't find the answer you're looking for? Our comprehensive documentation covers every feature in
  detail, or reach out to our support team for personalized assistance.
</Tip>


# Troubleshooting
Source: https://docs.quick.bot/troubleshoot

Common issues and solutions for QuickBot

# Troubleshooting

This guide helps you resolve common issues you might encounter while using QuickBot.

## Common Issues

### Bot Not Responding

* Check if your bot is published
* Verify webhook URLs are accessible
* Review bot flow logic for any loops or blocked paths

### Variables Not Working

* Ensure variable names are spelled correctly
* Check variable scoping and initialization
* Verify data types match expected values

### Integration Issues

* Verify API credentials are correct and not expired
* Check rate limits for third-party services
* Review integration-specific documentation

### Publishing Problems

* Ensure all required blocks are properly configured
* Check for validation errors in the flow
* Verify workspace permissions

## Getting Help

If you can't find a solution here, please:

* Check our [FAQ](/support/faq)
* [Contact support](/support/contact) for personalized assistance